b6d33010ca
- Lava gem rewards on npcs reflect actual value (1000 and 4000) - Can't carry people into parkour areas now Removed unused code with Portal Added portal functionality for server quick join Disabled SG text Updated quick game menu text.
614 lines
17 KiB
Java
614 lines
17 KiB
Java
package mineplex.hub.server;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
|
|
import org.bukkit.ChatColor;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.event.EventHandler;
|
|
import org.bukkit.event.EventPriority;
|
|
import org.bukkit.event.entity.EntityPortalEnterEvent;
|
|
import org.bukkit.event.entity.EntityPortalEvent;
|
|
import org.bukkit.event.player.PlayerInteractEvent;
|
|
import org.bukkit.event.player.PlayerJoinEvent;
|
|
import org.bukkit.event.player.PlayerMoveEvent;
|
|
import org.bukkit.event.player.PlayerPortalEvent;
|
|
import org.bukkit.plugin.java.JavaPlugin;
|
|
import org.bukkit.util.Vector;
|
|
|
|
import mineplex.core.MiniPlugin;
|
|
import mineplex.core.account.CoreClientManager;
|
|
import mineplex.core.common.Rank;
|
|
import mineplex.core.common.util.C;
|
|
import mineplex.core.common.util.Callback;
|
|
import mineplex.core.common.util.F;
|
|
import mineplex.core.common.util.NautHashMap;
|
|
import mineplex.core.common.util.UtilAction;
|
|
import mineplex.core.common.util.UtilAlg;
|
|
import mineplex.core.common.util.UtilPlayer;
|
|
import mineplex.core.common.util.UtilTime;
|
|
import mineplex.core.common.util.UtilTime.TimeUnit;
|
|
import mineplex.core.donation.DonationManager;
|
|
import mineplex.core.itemstack.ItemStackFactory;
|
|
import mineplex.core.portal.Portal;
|
|
import mineplex.core.recharge.Recharge;
|
|
import mineplex.core.status.ServerStatusData;
|
|
import mineplex.core.status.ServerStatusManager;
|
|
import mineplex.core.updater.UpdateType;
|
|
import mineplex.core.updater.event.UpdateEvent;
|
|
import mineplex.hub.HubManager;
|
|
import mineplex.hub.modules.StackerManager;
|
|
import mineplex.hub.party.Party;
|
|
import mineplex.hub.party.PartyManager;
|
|
import mineplex.hub.server.command.ServerNpcCommand;
|
|
import mineplex.hub.server.ui.ServerGameMenu;
|
|
import mineplex.hub.server.ui.ServerNpcShop;
|
|
|
|
public class ServerManager extends MiniPlugin
|
|
{
|
|
private CoreClientManager _clientManager;
|
|
private DonationManager _donationManager;
|
|
private Portal _portal;
|
|
private PartyManager _partyManager;
|
|
private ServerStatusManager _statusManager;
|
|
private HubManager _hubManager;
|
|
private StackerManager _stackerManager;
|
|
|
|
private NautHashMap<String, HashSet<ServerInfo>> _serverNpcMap = new NautHashMap<String, HashSet<ServerInfo>>();
|
|
private NautHashMap<String, String> _serverNpcTag = new NautHashMap<String, String>();
|
|
private NautHashMap<String, ServerNpcShop> _serverNpcShopMap = new NautHashMap<String, ServerNpcShop>();
|
|
private NautHashMap<String, ServerInfo> _serverInfoMap = new NautHashMap<String, ServerInfo>();
|
|
private NautHashMap<String, Long> _serverUpdate = new NautHashMap<String, Long>();
|
|
private NautHashMap<Vector, String> _serverPortalLocations = new NautHashMap<Vector, String>();
|
|
|
|
private ServerNpcShop _quickShop;
|
|
|
|
private boolean _alternateUpdateFire = false;
|
|
private boolean _retrieving = false;
|
|
|
|
public ServerManager(JavaPlugin plugin, CoreClientManager clientManager, DonationManager donationManager, Portal portal, PartyManager partyManager, ServerStatusManager statusManager, HubManager hubManager, StackerManager stackerManager)
|
|
{
|
|
super("Server Manager", plugin);
|
|
|
|
_clientManager = clientManager;
|
|
_donationManager = donationManager;
|
|
_portal = portal;
|
|
_partyManager = partyManager;
|
|
_statusManager = statusManager;
|
|
_hubManager = hubManager;
|
|
_stackerManager = stackerManager;
|
|
|
|
plugin.getServer().getMessenger().registerOutgoingPluginChannel(plugin, "BungeeCord");
|
|
|
|
LoadServers();
|
|
|
|
new ServerManagerUpdater(this);
|
|
_quickShop = new ServerNpcShop(this, clientManager, donationManager, "Quick Menu");
|
|
}
|
|
|
|
public void AddCommands()
|
|
{
|
|
AddCommand(new ServerNpcCommand(this));
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOW)
|
|
public void playerPortalEvent(PlayerPortalEvent event)
|
|
{
|
|
event.setCancelled(true);
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOW)
|
|
public void entityPortalEvent(EntityPortalEvent event)
|
|
{
|
|
event.setCancelled(true);
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOW)
|
|
public void playerCheckPortalEvent(EntityPortalEnterEvent event)
|
|
{
|
|
if (!(event.getEntity() instanceof Player))
|
|
{
|
|
UtilAction.velocity(event.getEntity(), UtilAlg.getTrajectory(event.getEntity().getLocation(), _hubManager.GetSpawn()), 1, true, 0.8, 0, 1, true);
|
|
return;
|
|
}
|
|
|
|
Player player = (Player)event.getEntity();
|
|
|
|
if (!_stackerManager.CanPortal(player))
|
|
{
|
|
UtilAction.velocity(player, UtilAlg.getTrajectory(player.getLocation(), _hubManager.GetSpawn()), 1, true, 0.8, 0, 1, true);
|
|
return;
|
|
}
|
|
|
|
if (!Recharge.Instance.use(player, "Portal Server", 1000, false))
|
|
return;
|
|
|
|
String serverName = _serverPortalLocations.get(player.getLocation().getBlock().getLocation().toVector());
|
|
|
|
if (serverName != null)
|
|
{
|
|
List<ServerInfo> serverList = new ArrayList<ServerInfo>(GetServerList(serverName));
|
|
|
|
int slots = 1;
|
|
|
|
if (serverList.size() > 0)
|
|
{
|
|
slots = GetRequiredSlots(player, serverList.get(0).ServerType);
|
|
}
|
|
|
|
try
|
|
{
|
|
Collections.sort(serverList, new ServerSorter(slots));
|
|
|
|
for (ServerInfo serverInfo : serverList)
|
|
{
|
|
if ((serverInfo.MOTD.contains("Starting") || serverInfo.MOTD.contains("Recruiting") || serverInfo.MOTD.contains("Waiting") || serverInfo.MOTD.contains("Cup")) && (serverInfo.MaxPlayers - serverInfo.CurrentPlayers) >= slots)
|
|
{
|
|
SelectServer(player, serverInfo);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
exception.printStackTrace();
|
|
|
|
for (ServerInfo serverInfo : serverList)
|
|
{
|
|
System.out.println(F.main("ServerManager", ChatColor.YELLOW + serverInfo.Name + ": " + serverInfo.MOTD + " " + serverInfo.CurrentPlayers + "/" + serverInfo.MaxPlayers));
|
|
}
|
|
}
|
|
|
|
player.sendMessage(F.main("Server Portal", "There are currently no joinable servers!"));
|
|
}
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOW)
|
|
public void playerJoin(PlayerJoinEvent event)
|
|
{
|
|
event.getPlayer().getInventory().addItem(ItemStackFactory.Instance.CreateStack(Material.COMPASS.getId(), (byte)0, 1, ChatColor.GREEN + "Game Menu"));
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOWEST)
|
|
public void playerInteract(PlayerInteractEvent event)
|
|
{
|
|
if (event.getItem() != null && event.getItem().getType() == Material.COMPASS)
|
|
{
|
|
_quickShop.OpenPageForPlayer(event.getPlayer(), new ServerGameMenu(this, _quickShop, _clientManager, _donationManager, " " + ChatColor.UNDERLINE + "Quick Game Menu", event.getPlayer()));
|
|
}
|
|
}
|
|
|
|
public void RemoveServer(String serverName)
|
|
{
|
|
for (String key : _serverNpcMap.keySet())
|
|
{
|
|
_serverNpcMap.get(key).remove(serverName);
|
|
}
|
|
|
|
_serverInfoMap.remove(serverName);
|
|
}
|
|
|
|
public void AddServerNpc(String serverNpcName)
|
|
{
|
|
_serverNpcMap.put(serverNpcName, new HashSet<ServerInfo>());
|
|
_serverNpcShopMap.put(serverNpcName, new ServerNpcShop(this, _clientManager, _donationManager, serverNpcName));
|
|
}
|
|
|
|
public void RemoveServerNpc(String serverNpcName)
|
|
{
|
|
Set<ServerInfo> mappedServers = _serverNpcMap.remove(serverNpcName);
|
|
_serverNpcShopMap.remove(serverNpcName);
|
|
|
|
if (mappedServers != null)
|
|
{
|
|
for (ServerInfo mappedServer : mappedServers)
|
|
{
|
|
boolean isMappedElseWhere = false;
|
|
|
|
for (String key : _serverNpcMap.keySet())
|
|
{
|
|
for (ServerInfo value : _serverNpcMap.get(key))
|
|
{
|
|
if (value.Name.equalsIgnoreCase(mappedServer.Name))
|
|
{
|
|
isMappedElseWhere = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isMappedElseWhere)
|
|
break;
|
|
}
|
|
|
|
if (!isMappedElseWhere)
|
|
_serverInfoMap.remove(mappedServer.Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public Collection<ServerInfo> GetServerList(String serverNpcName)
|
|
{
|
|
return _serverNpcMap.get(serverNpcName);
|
|
}
|
|
|
|
public Set<String> GetAllServers()
|
|
{
|
|
return _serverInfoMap.keySet();
|
|
}
|
|
|
|
public ServerInfo GetServerInfo(String serverName)
|
|
{
|
|
return _serverInfoMap.get(serverName);
|
|
}
|
|
|
|
public boolean HasServerNpc(String serverNpcName)
|
|
{
|
|
return _serverNpcMap.containsKey(serverNpcName);
|
|
}
|
|
|
|
@EventHandler
|
|
public void updatePages(UpdateEvent event)
|
|
{
|
|
if (event.getType() != UpdateType.FAST)
|
|
return;
|
|
|
|
_quickShop.UpdatePages();
|
|
|
|
for (ServerNpcShop shop : _serverNpcShopMap.values())
|
|
{
|
|
shop.UpdatePages();
|
|
}
|
|
}
|
|
|
|
@EventHandler
|
|
public void updateServers(UpdateEvent event)
|
|
{
|
|
if (event.getType() != UpdateType.SEC || _retrieving)
|
|
return;
|
|
|
|
_alternateUpdateFire = !_alternateUpdateFire;
|
|
|
|
if (!_alternateUpdateFire)
|
|
return;
|
|
|
|
_retrieving = true;
|
|
|
|
_statusManager.retrieveServerStatuses(new Callback<List<ServerStatusData>>()
|
|
{
|
|
public void run(List<ServerStatusData> serverStatusList)
|
|
{
|
|
for (ServerStatusData serverStatus : serverStatusList)
|
|
{
|
|
if (!_serverInfoMap.containsKey(serverStatus.Name))
|
|
{
|
|
ServerInfo newServerInfo = new ServerInfo();
|
|
newServerInfo.Name = serverStatus.Name;
|
|
_serverInfoMap.put(serverStatus.Name, newServerInfo);
|
|
}
|
|
|
|
String[] args = serverStatus.Motd.split("\\|");
|
|
String tag = (serverStatus.Name != null && serverStatus.Name.contains("-")) ? serverStatus.Name.split("-")[0] : "N/A";
|
|
|
|
ServerInfo serverInfo = _serverInfoMap.get(serverStatus.Name);
|
|
serverInfo.MOTD = args.length > 0 ? args[0] : serverStatus.Motd;
|
|
serverInfo.CurrentPlayers = serverStatus.Players;
|
|
serverInfo.MaxPlayers = serverStatus.MaxPlayers;
|
|
|
|
if (args.length > 1)
|
|
serverInfo.ServerType = args[1];
|
|
|
|
if (args.length > 2)
|
|
serverInfo.Game = args[2];
|
|
|
|
if (args.length > 3)
|
|
serverInfo.Map = args[3];
|
|
|
|
_serverUpdate.put(serverStatus.Name, System.currentTimeMillis());
|
|
|
|
if (_serverNpcTag.containsKey(tag))
|
|
{
|
|
_serverNpcMap.get(_serverNpcTag.get(tag)).add(serverInfo);
|
|
}
|
|
}
|
|
|
|
for (String name : _serverUpdate.keySet())
|
|
{
|
|
if (_serverUpdate.get(name) != -1L && System.currentTimeMillis() - _serverUpdate.get(name) > 5000)
|
|
{
|
|
ServerInfo serverInfo = _serverInfoMap.get(name);
|
|
serverInfo.MOTD = ChatColor.DARK_RED + "OFFLINE";
|
|
serverInfo.CurrentPlayers = 0;
|
|
serverInfo.MaxPlayers = 0;
|
|
|
|
_serverUpdate.put(name, -1L);
|
|
}
|
|
}
|
|
|
|
// Reset
|
|
_retrieving = false;
|
|
}
|
|
});
|
|
}
|
|
|
|
public void Help(Player caller, String message)
|
|
{
|
|
UtilPlayer.message(caller, F.main(_moduleName, "Commands List:"));
|
|
UtilPlayer.message(caller, F.help("/servernpc create <name>", "<name> is name of npc.", Rank.OWNER));
|
|
UtilPlayer.message(caller, F.help("/servernpc delete <name>", "<name> is name of npc.", Rank.OWNER));
|
|
UtilPlayer.message(caller, F.help("/servernpc addserver <servernpc> | <name>", "Adds server.", Rank.OWNER));
|
|
UtilPlayer.message(caller, F.help("/servernpc removeserver <name>", "Removes server.", Rank.OWNER));
|
|
UtilPlayer.message(caller, F.help("/servernpc listnpcs", "Lists all server npcs.", Rank.OWNER));
|
|
UtilPlayer.message(caller, F.help("/servernpc listservers <servernpc>", "Lists all servers.", Rank.OWNER));
|
|
UtilPlayer.message(caller, F.help("/servernpc listoffline", "Shows all servers offline.", Rank.OWNER));
|
|
|
|
if (message != null)
|
|
UtilPlayer.message(caller, F.main(_moduleName, ChatColor.RED + message));
|
|
}
|
|
|
|
public void Help(Player caller)
|
|
{
|
|
Help(caller, null);
|
|
}
|
|
|
|
public PartyManager getPartyManager()
|
|
{
|
|
return _partyManager;
|
|
}
|
|
|
|
public void SelectServer(org.bukkit.entity.Player player, ServerInfo serverInfo)
|
|
{
|
|
Party party = _partyManager.GetParty(player);
|
|
|
|
if (party != null)
|
|
{
|
|
if (player.getName().equals(party.GetLeader()))
|
|
{
|
|
for (String name : party.GetPlayers())
|
|
{
|
|
Player partyPlayer = UtilPlayer.searchExact(name);
|
|
|
|
if (partyPlayer == null)
|
|
continue;
|
|
|
|
if (_clientManager.Get(partyPlayer).GetRank().Has(Rank.ULTRA) || _donationManager.Get(partyPlayer.getName()).OwnsUnknownPackage(serverInfo.ServerType + " ULTRA"))
|
|
continue;
|
|
|
|
partyPlayer.leaveVehicle();
|
|
partyPlayer.eject();
|
|
|
|
_portal.SendPlayerToServer(partyPlayer, serverInfo.Name);
|
|
}
|
|
|
|
for (String name : party.GetPlayers())
|
|
{
|
|
Player partyPlayer = UtilPlayer.searchExact(name);
|
|
|
|
if (partyPlayer == null)
|
|
continue;
|
|
|
|
if (_clientManager.Get(partyPlayer).GetRank().Has(Rank.ULTRA) || _donationManager.Get(partyPlayer.getName()).OwnsUnknownPackage(serverInfo.ServerType + " ULTRA"))
|
|
{
|
|
partyPlayer.leaveVehicle();
|
|
partyPlayer.eject();
|
|
|
|
_portal.SendPlayerToServer(partyPlayer, serverInfo.Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
player.leaveVehicle();
|
|
player.eject();
|
|
|
|
_portal.SendPlayerToServer(player, serverInfo.Name);
|
|
}
|
|
}
|
|
|
|
public void ListServerNpcs(Player caller)
|
|
{
|
|
UtilPlayer.message(caller, F.main(GetName(), "Listing Server Npcs:"));
|
|
|
|
for (String serverNpc : _serverNpcMap.keySet())
|
|
{
|
|
UtilPlayer.message(caller, F.main(GetName(), C.cYellow + serverNpc));
|
|
}
|
|
}
|
|
|
|
public void ListServers(Player caller, String serverNpcName)
|
|
{
|
|
UtilPlayer.message(caller, F.main(GetName(), "Listing Servers for '" + serverNpcName + "':"));
|
|
|
|
for (ServerInfo serverNpc : _serverNpcMap.get(serverNpcName))
|
|
{
|
|
UtilPlayer.message(caller, F.main(GetName(), C.cYellow + serverNpc.Name + C.cWhite + " - " + serverNpc.MOTD + " " + serverNpc.CurrentPlayers + "/" + serverNpc.MaxPlayers));
|
|
}
|
|
}
|
|
|
|
public void ListOfflineServers(Player caller)
|
|
{
|
|
UtilPlayer.message(caller, F.main(GetName(), "Listing Offline Servers:"));
|
|
|
|
for (ServerInfo serverNpc : _serverInfoMap.values())
|
|
{
|
|
if (serverNpc.MOTD.equalsIgnoreCase(ChatColor.DARK_RED + "OFFLINE"))
|
|
{
|
|
UtilPlayer.message(caller, F.main(GetName(), C.cYellow + serverNpc.Name + C.cWhite + " - " + F.time(UtilTime.convertString(System.currentTimeMillis() - _serverUpdate.get(serverNpc.Name), 0, TimeUnit.FIT))));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void LoadServers()
|
|
{
|
|
_serverInfoMap.clear();
|
|
_serverUpdate.clear();
|
|
|
|
for (String npcName : _serverNpcMap.keySet())
|
|
{
|
|
_serverNpcMap.get(npcName).clear();
|
|
}
|
|
|
|
_serverNpcTag.clear();
|
|
|
|
FileInputStream fstream = null;
|
|
BufferedReader br = null;
|
|
|
|
HashSet<String> npcNames = new HashSet<String>();
|
|
|
|
try
|
|
{
|
|
File npcFile = new File("ServerManager.dat");
|
|
|
|
if (npcFile.exists())
|
|
{
|
|
fstream = new FileInputStream(npcFile);
|
|
br = new BufferedReader(new InputStreamReader(fstream));
|
|
|
|
String line = br.readLine();
|
|
|
|
while (line != null)
|
|
{
|
|
String serverNpcName = line.substring(0, line.indexOf('|')).trim();
|
|
String serverTag = line.substring(line.indexOf('|') + 1, line.indexOf('|', line.indexOf('|') + 1)).trim();
|
|
String[] locations = line.substring(line.indexOf('|', line.indexOf('|') + 1) + 1).trim().split(",");
|
|
|
|
for (String location : locations)
|
|
{
|
|
_serverPortalLocations.put(ParseVector(location), serverNpcName);
|
|
}
|
|
|
|
if (!HasServerNpc(serverNpcName))
|
|
{
|
|
AddServerNpc(serverNpcName);
|
|
}
|
|
|
|
_serverNpcTag.put(serverTag, serverNpcName);
|
|
npcNames.add(serverNpcName);
|
|
|
|
line = br.readLine();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
System.out.println("ServerManager - Error parsing servers file : " + e.getMessage());
|
|
}
|
|
finally
|
|
{
|
|
if (br != null)
|
|
{
|
|
try
|
|
{
|
|
br.close();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
if (fstream != null)
|
|
{
|
|
try
|
|
{
|
|
fstream.close();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (String npcName : npcNames)
|
|
{
|
|
if (!_serverNpcShopMap.containsKey(npcName))
|
|
_serverNpcShopMap.remove(npcName);
|
|
|
|
if (!_serverNpcMap.containsKey(npcName))
|
|
_serverNpcMap.remove(npcName);
|
|
}
|
|
}
|
|
|
|
public int GetRequiredSlots(Player player, String serverType)
|
|
{
|
|
int slots = 0;
|
|
|
|
Party party = _partyManager.GetParty(player);
|
|
|
|
if (party != null)
|
|
{
|
|
if (player.getName().equals(party.GetLeader()))
|
|
{
|
|
for (String name : party.GetPlayers())
|
|
{
|
|
Player partyPlayer = UtilPlayer.searchExact(name);
|
|
|
|
if (partyPlayer == null)
|
|
continue;
|
|
|
|
if (_clientManager.Get(partyPlayer).GetRank().Has(Rank.ULTRA) || _donationManager.Get(partyPlayer.getName()).OwnsUnknownPackage(serverType + " ULTRA"))
|
|
continue;
|
|
|
|
slots++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!_clientManager.Get(player).GetRank().Has(Rank.ULTRA) && !_donationManager.Get(player.getName()).OwnsUnknownPackage(serverType + " ULTRA"))
|
|
slots++;
|
|
}
|
|
|
|
return slots;
|
|
}
|
|
|
|
public ServerNpcShop getMixedArcadeShop()
|
|
{
|
|
return _serverNpcShopMap.get("Mixed Arcade");
|
|
}
|
|
|
|
public ServerNpcShop getSuperSmashMobsShop()
|
|
{
|
|
return _serverNpcShopMap.get("Super Smash Mobs");
|
|
}
|
|
|
|
public ServerNpcShop getDominateShop()
|
|
{
|
|
return _serverNpcShopMap.get("Dominate");
|
|
}
|
|
|
|
public ServerNpcShop getBridgesShop()
|
|
{
|
|
return _serverNpcShopMap.get("The Bridges");
|
|
}
|
|
|
|
public ServerNpcShop getMinekartShop()
|
|
{
|
|
return _serverNpcShopMap.get("Minekart");
|
|
}
|
|
|
|
private Vector ParseVector(String vectorString)
|
|
{
|
|
Vector vector = new Vector();
|
|
|
|
String [] parts = vectorString.trim().split(" ");
|
|
|
|
vector.setX(Double.parseDouble(parts[0]));
|
|
vector.setY(Double.parseDouble(parts[1]));
|
|
vector.setZ(Double.parseDouble(parts[2]));
|
|
|
|
return vector;
|
|
}
|
|
}
|