Upstream
/
SubServers-2
mirror of https://github.com/ME1312/SubServers-2.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

ClientCommon API

This commit is contained in:
ME1312 2020-11-14 00:29:29 -05:00
parent 34b406e3ae
commit c0197759f4
No known key found for this signature in database
GPG Key ID: FEFFE2F698E88FA8
135 changed files with 950 additions and 14307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
SubServers.Bungee/common/pom.xml
View File

@ -31,7 +31,7 @@
<groupId>net.ME1312.Galaxi</groupId>
<artifactId>GalaxiUtil</artifactId>
<version>20w33a</version>
<scope>compile</scope>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>net.ME1312.Galaxi</groupId>

11
SubServers.Client/Bukkit/pom.xml
View File

@ -52,6 +52,13 @@
<scope>compile</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>net.ME1312.SubServers</groupId>
<artifactId>SubServers.Client.Common</artifactId>
<version>-PLACEHOLDER</version>
<scope>compile</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>net.ME1312.SubData</groupId>
<artifactId>Client</artifactId>
@ -160,6 +167,10 @@
<link>https://dev.me1312.net/jenkins/job/SubData/javadoc/Client/</link>
<link>https://hub.spigotmc.org/javadocs/spigot/</link>
</links>
<includeDependencySources>true</includeDependencySources>
<dependencySourceIncludes>
<dependencySourceInclude>net.ME1312.SubServers:SubServers.Client.Common:*</dependencySourceInclude>
</dependencySourceIncludes>
</configuration>
</execution>
</executions>

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Event/SubCreateEvent.java
View File

@ -4,7 +4,7 @@ import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.SubServers.Client.Bukkit.Library.SubEvent;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Bukkit.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Event/SubCreatedEvent.java
View File

@ -3,8 +3,8 @@ package net.ME1312.SubServers.Client.Bukkit.Event;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Client.Bukkit.Library.SubEvent;
import net.ME1312.SubServers.Client.Bukkit.Network.API.SubServer;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

21
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Graphic/DefaultUIHandler.java
View File

@ -7,10 +7,12 @@ import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Bukkit.Network.API.Host;
import net.ME1312.SubServers.Client.Bukkit.Network.API.SubServer;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.*;
import net.ME1312.SubServers.Client.Bukkit.SubPlugin;
import net.ME1312.SubServers.Client.Common.Network.API.Host;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketCreateServer;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketUpdateServer;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
@ -26,6 +28,8 @@ import org.bukkit.event.player.PlayerQuitEvent;
import java.util.HashMap;
import java.util.UUID;
import static net.ME1312.SubServers.Client.Bukkit.Library.ObjectPermission.*;
/**
* Default GUI Listener
*/
@ -111,7 +115,8 @@ public class DefaultUIHandler implements UIHandler, Listener {
if (player.hasPermission("subservers.host.*.*") || player.hasPermission("subservers.host.*.create") || player.hasPermission("subservers.host." + host + ".*") || player.hasPermission("subservers.host." + host + ".create")) {
player.closeInventory();
gui.setDownloading(plugin.api.getLang("SubServers", "Interface.Generic.Downloading.Response"));
((SubDataClient) plugin.api.getSubDataNetwork()[0]).sendPacket(new PacketCreateServer(player.getUniqueId(), ((UIRenderer.CreatorOptions) gui.lastVisitedObjects[0]), data -> {
UIRenderer.CreatorOptions options = ((UIRenderer.CreatorOptions) gui.lastVisitedObjects[0]);
((SubDataClient) plugin.api.getSubDataNetwork()[0]).sendPacket(new PacketCreateServer(player.getUniqueId(), options.getName(), options.getHost(), options.getTemplate(), options.getVersion(), options.getPort(), data -> {
gui.back();
}));
} else {
@ -319,7 +324,7 @@ public class DefaultUIHandler implements UIHandler, Listener {
gui.back();
} else if (item.equals(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Update"))) {
player.closeInventory();
if (((SubServer) gui.lastVisitedObjects[0]).permits(player, "subservers.subserver.%.*", "subservers.subserver.%.update")) {
if (permits((SubServer) gui.lastVisitedObjects[0], player, "subservers.subserver.%.*", "subservers.subserver.%.update")) {
if (!gui.sendTitle(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Update.Title"), 4 * 20))
player.sendMessage(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Update.Message"));
input.put(player.getUniqueId(), m -> {
@ -332,7 +337,7 @@ public class DefaultUIHandler implements UIHandler, Listener {
} else gui.reopen();
} else if (item.equals(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Start"))) {
player.closeInventory();
if (((SubServer) gui.lastVisitedObjects[0]).permits(player, "subservers.subserver.%.*", "subservers.subserver.%.start")) {
if (permits((SubServer) gui.lastVisitedObjects[0], player, "subservers.subserver.%.*", "subservers.subserver.%.start")) {
gui.setDownloading(plugin.api.getLang("SubServers", "Interface.Generic.Downloading.Response"));
((SubServer) gui.lastVisitedObjects[0]).start(player.getUniqueId(), response -> {
gui.setDownloading(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Start.Title"));
@ -341,7 +346,7 @@ public class DefaultUIHandler implements UIHandler, Listener {
} else gui.reopen();
} else if (item.equals(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Stop"))) {
player.closeInventory();
if (((SubServer) gui.lastVisitedObjects[0]).permits(player, "subservers.subserver.%.*", "subservers.subserver.%.stop")) {
if (permits((SubServer) gui.lastVisitedObjects[0], player, "subservers.subserver.%.*", "subservers.subserver.%.stop")) {
gui.setDownloading(plugin.api.getLang("SubServers", "Interface.Generic.Downloading.Response"));
final Container<Boolean> listening = new Container<Boolean>(true);
PacketInExRunEvent.callback("SubStoppedEvent", new Callback<ObjectMap<String>>() {
@ -365,7 +370,7 @@ public class DefaultUIHandler implements UIHandler, Listener {
} else gui.reopen();
} else if (item.equals(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Terminate"))) {
player.closeInventory();
if (((SubServer) gui.lastVisitedObjects[0]).permits(player, "subservers.subserver.%.*", "subservers.subserver.%.terminate")) {
if (permits((SubServer) gui.lastVisitedObjects[0], player, "subservers.subserver.%.*", "subservers.subserver.%.terminate")) {
gui.setDownloading(plugin.api.getLang("SubServers", "Interface.Generic.Downloading.Response"));
final Container<Boolean> listening = new Container<Boolean>(true);
PacketInExRunEvent.callback("SubStoppedEvent", new Callback<ObjectMap<String>>() {
@ -389,7 +394,7 @@ public class DefaultUIHandler implements UIHandler, Listener {
} else gui.reopen();
} else if (item.equals(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Command"))) {
player.closeInventory();
if (((SubServer) gui.lastVisitedObjects[0]).permits(player, "subservers.subserver.%.*", "subservers.subserver.%.command")) {
if (permits((SubServer) gui.lastVisitedObjects[0], player, "subservers.subserver.%.*", "subservers.subserver.%.command")) {
if (!gui.sendTitle(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Command.Title"), 4 * 20))
player.sendMessage(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Command.Message"));
input.put(player.getUniqueId(), m -> {

20
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Graphic/DefaultUIRenderer.java
View File

@ -3,10 +3,10 @@ package net.ME1312.SubServers.Client.Bukkit.Graphic;
import net.ME1312.Galaxi.Library.Container.Container;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Bukkit.Network.API.Host;
import net.ME1312.SubServers.Client.Bukkit.Network.API.Server;
import net.ME1312.SubServers.Client.Bukkit.Network.API.SubCreator;
import net.ME1312.SubServers.Client.Bukkit.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.Host;
import net.ME1312.SubServers.Client.Common.Network.API.Server;
import net.ME1312.SubServers.Client.Common.Network.API.SubCreator;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Client.Bukkit.SubPlugin;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
@ -19,6 +19,8 @@ import org.bukkit.inventory.meta.ItemMeta;
import java.text.DecimalFormat;
import java.util.*;
import static net.ME1312.SubServers.Client.Bukkit.Library.ObjectPermission.*;
/**
* Default GUI Renderer Class
*/
@ -1003,7 +1005,7 @@ public class DefaultUIRenderer extends UIRenderer {
Player player = Bukkit.getPlayer(this.player);
if (subserver.isRunning()) {
if (!subserver.permits(player, "subservers.subserver.%.*", "subservers.subserver.%.terminate")) {
if (!permits(subserver, player, "subservers.subserver.%.*", "subservers.subserver.%.terminate")) {
block = createItem("STAINED_GLASS_PANE", "GRAY_STAINED_GLASS_PANE", (short) 7);
blockMeta = block.getItemMeta();
blockMeta.setDisplayName(ChatColor.GRAY+ChatColor.stripColor(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Terminate")));
@ -1018,7 +1020,7 @@ public class DefaultUIRenderer extends UIRenderer {
inv.setItem(1, block);
inv.setItem(10, block);
if (!subserver.permits(player, "subservers.subserver.%.*", "subservers.subserver.%.stop")) {
if (!permits(subserver, player, "subservers.subserver.%.*", "subservers.subserver.%.stop")) {
block = createItem("STAINED_GLASS_PANE", "GRAY_STAINED_GLASS_PANE", (short) 7);
blockMeta = block.getItemMeta();
blockMeta.setDisplayName(ChatColor.GRAY+ChatColor.stripColor(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Stop")));
@ -1034,7 +1036,7 @@ public class DefaultUIRenderer extends UIRenderer {
inv.setItem(11, block);
inv.setItem(12, block);
if (!subserver.permits(player, "subservers.subserver.%.*", "subservers.subserver.%.command")) {
if (!permits(subserver, player, "subservers.subserver.%.*", "subservers.subserver.%.command")) {
block = createItem("STAINED_GLASS_PANE", "GRAY_STAINED_GLASS_PANE", (short) 7);
blockMeta = block.getItemMeta();
blockMeta.setDisplayName(ChatColor.GRAY+ChatColor.stripColor(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Command")));
@ -1052,7 +1054,7 @@ public class DefaultUIRenderer extends UIRenderer {
inv.setItem(15, block);
inv.setItem(16, block);
} else {
if (!subserver.permits(player, "subservers.subserver.%.*", "subservers.subserver.%.start")) {
if (!permits(subserver, player, "subservers.subserver.%.*", "subservers.subserver.%.start")) {
block = createItem("STAINED_GLASS_PANE", "GRAY_STAINED_GLASS_PANE", (short) 7);
blockMeta = block.getItemMeta();
blockMeta.setDisplayName(ChatColor.GRAY+ChatColor.stripColor(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Start")));
@ -1083,7 +1085,7 @@ public class DefaultUIRenderer extends UIRenderer {
inv.setItem(11, block);
inv.setItem(12, block);
if (!subserver.permits(player, "subservers.subserver.%.*", "subservers.subserver.%.update")) {
if (!permits(subserver, player, "subservers.subserver.%.*", "subservers.subserver.%.update")) {
block = createItem("STAINED_GLASS_PANE", "GRAY_STAINED_GLASS_PANE", (short) 7);
blockMeta = block.getItemMeta();
blockMeta.setDisplayName(ChatColor.GRAY+ChatColor.stripColor(plugin.api.getLang("SubServers", "Interface.SubServer-Admin.Update")));

4
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Graphic/UIRenderer.java
View File

@ -4,8 +4,8 @@ import net.ME1312.Galaxi.Library.Container.Container;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Bukkit.Network.API.Host;
import net.ME1312.SubServers.Client.Bukkit.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.Host;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Client.Bukkit.SubPlugin;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;

5
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Library/Compatibility/BungeeChat.java
View File

@ -1,9 +1,6 @@
package net.ME1312.SubServers.Client.Bukkit.Library.Compatibility;
import net.ME1312.SubServers.Client.Bukkit.Network.API.Host;
import net.ME1312.SubServers.Client.Bukkit.Network.API.Proxy;
import net.ME1312.SubServers.Client.Bukkit.Network.API.Server;
import net.ME1312.SubServers.Client.Bukkit.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.*;
import net.ME1312.SubServers.Client.Bukkit.SubPlugin;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.ClickEvent;

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Library/Compatibility/PlaceholderImpl.java
View File

@ -6,8 +6,8 @@ import me.clip.placeholderapi.expansion.PlaceholderExpansion;
import me.clip.placeholderapi.expansion.Taskable;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubServers.Client.Common.Network.API.*;
import net.ME1312.SubServers.Client.Bukkit.Event.*;
import net.ME1312.SubServers.Client.Bukkit.Network.API.*;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import net.ME1312.SubServers.Client.Bukkit.SubPlugin;
import org.bukkit.Bukkit;

104
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Library/ObjectPermission.java Normal file
View File

@ -0,0 +1,104 @@
package net.ME1312.SubServers.Client.Bukkit.Library;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubServers.Client.Common.Network.API.Host;
import net.ME1312.SubServers.Client.Common.Network.API.Proxy;
import net.ME1312.SubServers.Client.Common.Network.API.Server;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import org.bukkit.permissions.Permissible;
import java.util.List;
/**
* Object Permissions Class
*/
public class ObjectPermission {
private ObjectPermission() {}
/**
* Determine if an <i>object</i> can perform some action on this proxy using possible permissions
*
* @param proxy Proxy to check against
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the proxy name)
* @return Permission Check Result
*/
public static boolean permits(Proxy proxy, Permissible object, String... permissions) {
return permits(proxy.getName(), object, permissions);
}
/**
* Determine if an <i>object</i> can perform some action on a host using possible permissions
*
* @param host Host to check against
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the host name)
* @return Permission Check Result
*/
public static boolean permits(Host host, Permissible object, String... permissions) {
return permits(host.getName(), object, permissions);
}
/**
* Determine if an <i>object</i> can perform some action on another object using possible permissions
*
* @param string String to check against
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the object name)
* @return Permission Check Result
*/
private static boolean permits(String string, Permissible object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all proxies & individual proxies permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", string.toLowerCase()));
}
}
return permitted;
}
/**
* Determine if an <i>object</i> can perform some action on a server using possible permissions
*
* @param server Server to check against
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the server name)
* @return Permission Check Result
*/
public static boolean permits(Server server, Permissible object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all servers & individual servers permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", server.getName().toLowerCase()));
// Check all hosts & individual hosts permission
if (server instanceof SubServer) {
permitted = permitted || object.hasPermission(perm.replace("%", "::*"))
|| object.hasPermission(perm.replace("%", "::" + ((SubServer) server).getHost().toLowerCase()));
}
// Check all groups & individual groups permission
List<String> groups = server.getGroups();
if (groups.size() > 0) {
permitted = permitted || object.hasPermission(perm.replace("%", ":*"));
for (int g = 0; !permitted && g < groups.size(); g++) {
permitted = object.hasPermission(perm.replace("%", ":" + groups.get(g).toLowerCase()));
}
}
}
}
return permitted;
}
}

777
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/API/Host.java
View File

@ -1,777 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.*;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import org.bukkit.permissions.Permissible;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.*;
/**
* Simplified Host Data Class
*/
public class Host {
HashMap<String, SubServer> servers = new HashMap<String, SubServer>();
private SubCreator creator;
private List<RemotePlayer> players = null;
ObjectMap<String> raw;
DataClient client;
long timestamp;
/**
* Create an API representation of a Host
*
* @param raw Raw representation of the Host
*/
public Host(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Host
*
* @param client SubData connection
* @param raw Raw representation of the Host
*/
Host(DataClient client, ObjectMap<String> raw) {
this.client = client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof Host && getSignature().equals(((Host) obj).getSignature());
}
private void load(ObjectMap<String> raw) {
this.raw = raw;
this.players = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
servers.clear();
this.creator = new SubCreator(this, raw.getMap("creator"));
for (String server : raw.getMap("servers").getKeys()) {
servers.put(server.toLowerCase(), new SubServer(this, raw.getMap("servers").getMap(server)));
}
}
private SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
String name = getName();
client().sendPacket(new PacketDownloadHostInfo(Collections.singletonList(name), data -> load(data.getMap(name))));
}
/**
* Gets the SubData Client Channel IDs
*
* @return SubData Client Channel ID Array (may be empty if unsupported)
*/
@SuppressWarnings("unchecked")
public DataSender[] getSubData() {
if (raw.contains("subdata")) {
ObjectMap<Integer> subdata = new ObjectMap<Integer>((Map<Integer, ?>) raw.getObject("subdata"));
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
} else {
return new SubDataSender[0];
}
}
/**
* Determine if an <i>object</i> can perform some action on this host using possible permissions
*
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the host name)
* @return Permission Check Result
*/
public boolean permits(Permissible object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all proxies & individual proxies permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", this.getName().toLowerCase()));
}
}
return permitted;
}
/**
* Is this Host Available?
*
* @return Availability Status
*/
public boolean isAvailable() {
return raw.getBoolean("available");
}
/**
* Is this Host Enabled?
*
* @return Enabled Status
*/
public boolean isEnabled() {
return raw.getBoolean("enabled");
}
/**
* Get the Address of this Host
*
* @return Host Address
*/
public InetAddress getAddress() {
try {
return InetAddress.getByName(raw.getRawString("address"));
} catch (UnknownHostException e) {
throw new IllegalStateException("Invalid address response from raw data key: address");
}
}
/**
* Get the host Directory Path
*
* @return Host Directory Path
*/
public String getPath() {
return raw.getRawString("dir");
}
/**
* Get the Name of this Host
*
* @return Host Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Host
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Get players on servers provided by this host across all known proxies
*
* @return Remote Player Collection
*/
public Collection<NamedContainer<String, UUID>> getGlobalPlayers() {
List<NamedContainer<String, UUID>> players = new ArrayList<NamedContainer<String, UUID>>();
for (String id : raw.getMap("players").getKeys()) {
players.add(new NamedContainer<String, UUID>(raw.getMap("players").getRawString(id), UUID.fromString(id)));
}
return players;
}
/**
* Get the players on servers provided by this host across all known proxies
*
* @param callback Remote Player Collection
*/
public void getGlobalPlayers(Callback<Collection<RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (players == null) {
LinkedList<UUID> ids = new LinkedList<UUID>();
for (SubServer server : getSubServers().values()) for (NamedContainer<String, UUID> player : server.getGlobalPlayers()) ids.add(player.get());
client().sendPacket(new PacketDownloadPlayerInfo(ids, data -> {
LinkedList<RemotePlayer> players = new LinkedList<RemotePlayer>();
for (String player : data.getKeys()) {
players.add(new RemotePlayer(data.getMap(player)));
}
this.players = players;
run.run();
}));
} else {
run.run();
}
}
/**
* Starts the Servers Specified
*
* @param servers Servers
*/
public void start(String... servers) {
start(null, servers);
}
/**
* Starts the Servers Specified
*
* @param player Player who started
* @param servers Servers
*/
public void start(UUID player, String... servers) {
for (String server : servers) {
getSubServer(server.toLowerCase()).start(player);
}
}
/**
* Stops the Servers Specified
*
* @param servers Servers
*/
public void stop(String... servers) {
stop(null, servers);
}
/**
* Stops the Servers Specified
*
* @param player Player who started
* @param servers Servers
*/
public void stop(UUID player, String... servers) {
for (String server : servers) {
getSubServer(server.toLowerCase()).stop(player);
}
}
/**
* Terminates the Servers Specified
*
* @param servers Servers
*/
public void terminate(String... servers) {
terminate(null, servers);
}
/**
* Terminates the Servers Specified
*
* @param player Player who started
* @param servers Servers
*/
public void terminate(UUID player, String... servers) {
for (String server : servers) {
getSubServer(server.toLowerCase()).terminate(player);
}
}
/**
* Commands the Servers Specified
*
* @param command Command to send
* @param servers Servers
*/
public void command(String command, String... servers) {
command(null, command, servers);
}
/**
* Commands the Servers Specified
*
* @param player Player who started
* @param command Command to send
* @param servers Servers
* @return Success Status
*/
public void command(UUID player, String command, String... servers) {
for (String server : servers) {
getSubServer(server.toLowerCase()).command(player, command);
}
}
/**
* Gets the SubCreator Instance for this Host
*
* @return SubCreator
*/
public SubCreator getCreator() {
return creator;
}
/**
* Gets the SubServers on this Host
*
* @return SubServer Map
*/
public Map<String, ? extends SubServer> getSubServers() {
return new TreeMap<String, SubServer>(servers);
}
/**
* Gets a SubServer
*
* @param name SubServer Name
* @return a SubServer
*/
public SubServer getSubServer(String name) {
if (Util.isNull(name)) throw new NullPointerException();
return getSubServers().get(name.toLowerCase());
}
/**
* Adds a SubServer
*
* @param name Name of Server
* @param enabled Enabled Status
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
* @return The SubServer
*/
public void addSubServer(String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted, Callback<Integer> response) {
addSubServer(null, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted, response);
}
/**
* Adds a SubServer
*
* @param player Player adding
* @param name Name of Server
* @param enabled Enabled Status
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
* @return The SubServer
*/
public void addSubServer(UUID player, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketAddServer(player, name, enabled, getName(), port, motd, log, directory, executable, stopcmd, hidden, restricted, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Adds a SubServer
*
* @param name Name of Server
* @param enabled Enabled Status
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @return The SubServer
*/
public void addSubServer(String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) {
addSubServer(null, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
}
/**
* Adds a SubServer
*
* @param player Player adding
* @param name Name of Server
* @param enabled Enabled Status
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @return The SubServer
*/
public void addSubServer(UUID player, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) {
addSubServer(player, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted, i -> {});
}
/**
* Removes a SubServer
*
* @param name SubServer Name
*/
public void removeSubServer(String name) {
removeSubServer(null, name);
}
/**
* Removes a SubServer
*
* @param player Player Removing
* @param name SubServer Name
*/
public void removeSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
removeSubServer(player, name, false, i -> {});
}
/**
* Forces the Removal of a SubServer
*
* @param name SubServer Name
*/
public void forceRemoveSubServer(String name) {
forceRemoveSubServer(null, name);
}
/**
* Forces the Removal of a SubServer
*
* @param player Player Removing
* @param name SubServer Name
*/
public void forceRemoveSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
removeSubServer(player, name, true, i -> {});
}
/**
* Removes a SubServer
*
* @param name SubServer Name
* @param response Response Code
*/
public void removeSubServer(String name, Callback<Integer> response) {
removeSubServer(null, name, response);
}
/**
* Removes a SubServer
*
* @param player Player Removing
* @param name SubServer Name
* @param response Response Code
*/
public void removeSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeSubServer(player, name, false, response);
}
/**
* Forces the Removal of a SubServer
*
* @param name SubServer Name
* @param response Response Code
*/
public void forceRemoveSubServer(String name, Callback<Integer> response) {
forceRemoveSubServer(null, name, response);
}
/**
* Forces the Removal of a SubServer
*
* @param player Player Removing
* @param name SubServer Name
* @param response Response Code
*/
public void forceRemoveSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeSubServer(player, name, true, response);
}
private void removeSubServer(UUID player, String name, boolean force, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketRemoveServer(player, name, force, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Deletes a SubServer (will move to 'Recently Deleted')
*
* @param name SubServer Name
*/
public void recycleSubServer(String name) {
recycleSubServer(null, name);
}
/**
* Deletes a SubServer (will move to 'Recently Deleted')
*
* @param player Player Deleting
* @param name SubServer Name
*/
public void recycleSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, true, false, i -> {});
}
/**
* Forces the Deletion of a SubServer (will move to 'Recently Deleted')
*
* @param name SubServer Name
*/
public void forceRecycleSubServer(String name) {
forceRecycleSubServer(null, name);
}
/**
* Forces the Deletion of a SubServer (will move to 'Recently Deleted')
*
* @param player Player Deleting
* @param name SubServer Name
*/
public void forceRecycleSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, true, true, i -> {});
}
/**
* Deletes a SubServer (will move to 'Recently Deleted')
*
* @param name SubServer Name
* @param response Response Code
*/
public void recycleSubServer(String name, Callback<Integer> response) {
recycleSubServer(null, name, response);
}
/**
* Deletes a SubServer (will move to 'Recently Deleted')
*
* @param player Player Deleting
* @param name SubServer Name
* @param response Response Code
*/
public void recycleSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, true, false, response);
}
/**
* Forces the Deletion of a SubServer (will move to 'Recently Deleted')
*
* @param name SubServer Name
* @param response Response Code
*/
public void forceRecycleSubServer(String name, Callback<Integer> response) {
forceRecycleSubServer(null, name, response);
}
/**
* Forces the Deletion of a SubServer (will move to 'Recently Deleted')
*
* @param player Player Deleting
* @param name SubServer Name
* @param response Response Code
*/
public void forceRecycleSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, true, true, response);
}
/**
* Deletes a SubServer
*
* @param name SubServer Name
* @return Success Status
*/
public void deleteSubServer(String name) {
deleteSubServer(null, name);
}
/**
* Deletes a SubServer
*
* @param player Player Deleting
* @param name SubServer Name
* @return Success Status
*/
public void deleteSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, false, false, i -> {});
}
/**
* Forces the Deletion of a SubServer
*
* @param name SubServer Name
* @return Success Status
*/
public void forceDeleteSubServer(String name) {
forceDeleteSubServer(null, name);
}
/**
* Forces the Deletion of a SubServer
*
* @param player Player Deleting
* @param name SubServer Name
* @return Success Status
*/
public void forceDeleteSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, false, true, i -> {});
}
/**
* Deletes a SubServer
*
* @param name SubServer Name
* @return Success Status
*/
public void deleteSubServer(String name, Callback<Integer> response) {
deleteSubServer(null, name, response);
}
/**
* Deletes a SubServer
*
* @param player Player Deleting
* @param name SubServer Name
* @return Success Status
*/
public void deleteSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, false, false, response);
}
/**
* Forces the Deletion of a SubServer
*
* @param name SubServer Name
* @return Success Status
*/
public void forceDeleteSubServer(String name, Callback<Integer> response) {
forceDeleteSubServer(null, name, response);
}
/**
* Forces the Deletion of a SubServer
*
* @param player Player Deleting
* @param name SubServer Name
* @return Success Status
*/
public void forceDeleteSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, false, true, response);
}
private void deleteSubServer(UUID player, String name, boolean recycle, boolean force, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketDeleteServer(player, name, recycle, force, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Get the Signature of this Object
*
* @return Object Signature
*/
public final String getSignature() {
return raw.getRawString("signature");
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Determine if an extra value exists
*
* @param handle Handle
* @return Value Status
*/
public boolean hasExtra(String handle) {
if (Util.isNull(handle)) throw new NullPointerException();
return raw.getMap("extra").getKeys().contains(handle);
}
/**
* Get an extra value
*
* @param handle Handle
* @return Value
*/
public ObjectMapValue<String> getExtra(String handle) {
if (Util.isNull(handle)) throw new NullPointerException();
return raw.getMap("extra").get(handle);
}
/**
* Get the extra value section
*
* @return Extra Value Section
*/
public ObjectMap<String> getExtra() {
return raw.getMap("extra").clone();
}
/**
* Get the raw representation of the Host
*
* @return Raw Host
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

243
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/API/Proxy.java
View File

@ -1,243 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.PacketDownloadProxyInfo;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import org.bukkit.permissions.Permissible;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
/**
* Simplified Proxy Data Class
*/
public class Proxy {
ObjectMap<String> raw;
private List<RemotePlayer> players = null;
DataClient client;
long timestamp;
/**
* Create an API representation of a Proxy
*
* @param raw Raw representation of the Proxy
*/
public Proxy(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Proxy
*
* @param client SubData connection
* @param raw Raw representation of the Proxy
*/
Proxy(DataClient client, ObjectMap<String> raw) {
this.client = client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof Proxy && getSignature().equals(((Proxy) obj).getSignature());
}
private void load(ObjectMap<String> raw) {
this.raw = raw;
this.players = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
}
private SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
String name = getName();
client().sendPacket(new PacketDownloadProxyInfo(Collections.singletonList(name), data -> load(data.getMap(name))));
}
/**
* Gets the SubData Client Channel IDs
*
* @return SubData Client Channel ID Array
*/
@SuppressWarnings("unchecked")
public DataSender[] getSubData() {
ObjectMap<Integer> subdata = new ObjectMap<Integer>((Map<Integer, ?>) raw.getObject("subdata"));
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
}
/**
* Determine if an <i>object</i> can perform some action on this proxy using possible permissions
*
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the proxy name)
* @return Permission Check Result
*/
public boolean permits(Permissible object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all proxies & individual proxies permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", this.getName().toLowerCase()));
}
}
return permitted;
}
/**
* Get the Name of this Proxy
*
* @return Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Proxy
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Determine if the proxy is the Master Proxy
*
* @return Master Proxy Status
*/
public boolean isMaster() {
return raw.getBoolean("master");
}
/**
* Get the players on this proxy (via RedisBungee)
*
* @return Remote Player Collection
*/
public Collection<NamedContainer<String, UUID>> getPlayers() {
List<NamedContainer<String, UUID>> players = new ArrayList<NamedContainer<String, UUID>>();
for (String id : raw.getMap("players").getKeys()) {
players.add(new NamedContainer<String, UUID>(raw.getMap("players").getRawString(id), UUID.fromString(id)));
}
return players;
}
/**
* Get the players on this proxy (via RedisBungee)
*
* @param callback Remote Player Collection
*/
public void getPlayers(Callback<Collection<RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (players == null) {
LinkedList<UUID> ids = new LinkedList<UUID>();
for (String id : raw.getMap("players").getKeys()) ids.add(UUID.fromString(id));
client().sendPacket(new PacketDownloadPlayerInfo(ids, data -> {
LinkedList<RemotePlayer> players = new LinkedList<RemotePlayer>();
for (String player : data.getKeys()) {
players.add(new RemotePlayer(data.getMap(player)));
}
this.players = players;
run.run();
}));
} else {
run.run();
}
}
/**
* Get the Signature of this Object
*
* @return Object Signature
*/
public final String getSignature() {
return raw.getRawString("signature");
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Determine if an extra value exists
*
* @param handle Handle
* @return Value Status
*/
public boolean hasExtra(String handle) {
if (Util.isNull(handle)) throw new NullPointerException();
return raw.getMap("extra").getKeys().contains(handle);
}
/**
* Get an extra value
*
* @param handle Handle
* @return Value
*/
public ObjectMapValue<String> getExtra(String handle) {
if (Util.isNull(handle)) throw new NullPointerException();
return raw.getMap("extra").get(handle);
}
/**
* Get the extra value section
*
* @return Extra Value Section
*/
public ObjectMap<String> getExtra() {
return raw.getMap("extra").clone();
}
/**
* Get the raw representation of the Proxy
*
* @return Raw Proxy
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

188
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/API/RemotePlayer.java
View File

@ -1,188 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.*;
/**
* Simplified RemotePlayer Data Class
*/
public class RemotePlayer {
ObjectMap<String> raw;
private Proxy proxy = null;
private Server server = null;
DataClient client;
long timestamp;
/**
* Create an API representation of a Remote Player
*
* @param raw Raw representation of the Remote Player
*/
public RemotePlayer(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Remote Player
*
* @param client SubData connection
* @param raw Raw representation of the Remote Player
*/
RemotePlayer(DataClient client, ObjectMap<String> raw) {
this.client = client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof RemotePlayer && getUniqueId().equals(((RemotePlayer) obj).getUniqueId());
}
void load(ObjectMap<String> raw) {
this.raw = raw;
this.proxy = null;
this.server = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
}
private SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
UUID id = getUniqueId();
client().sendPacket(new PacketDownloadPlayerInfo(Collections.singletonList(id), data -> load(data.getMap(id.toString()))));
}
/**
* Get the UUID of this player.
*
* @return the UUID
*/
public UUID getUniqueId() {
return raw.getUUID("id");
}
/**
* Get the unique name of this player.
*
* @return the players username
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Gets the remote address of this connection.
*
* @return the remote address
*/
public InetSocketAddress getAddress() {
return new InetSocketAddress(raw.getRawString("address").split(":")[0], Integer.parseInt(raw.getRawString("address").split(":")[1]));
}
/**
* Gets the proxy this player is connected to.
*
* @return the proxy this player is connected to
*/
public String getProxy() {
return raw.getRawString("proxy");
}
/**
* Gets the proxy this player is connected to.
*
* @param callback the proxy this player is connected to
*/
public void getProxy(Callback<Proxy> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(proxy);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (proxy == null || !proxy.getName().equalsIgnoreCase(raw.getRawString("proxy"))) {
SubAPI.getInstance().getProxy(raw.getRawString("proxy"), proxy -> {
this.proxy = proxy;
run.run();
});
} else {
run.run();
}
}
/**
* Gets the server this player is connected to.
*
* @return the server this player is connected to
*/
public String getServer() {
return raw.getRawString("server");
}
/**
* Gets the server this player is connected to.
*
* @param callback the server this player is connected to
*/
public void getServer(Callback<Server> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(server);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (server == null || !server.getName().equalsIgnoreCase(raw.getRawString("server"))) {
SubAPI.getInstance().getServer(raw.getRawString("server"), server -> {
this.server = server;
run.run();
});
} else {
run.run();
}
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Get the raw representation of the Server
*
* @return Raw Server
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

281
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/API/Server.java
View File

@ -1,281 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.PacketDownloadServerInfo;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import org.bukkit.permissions.Permissible;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
import java.util.*;
/**
* Simplified Server Data Class
*/
public class Server {
ObjectMap<String> raw;
private List<RemotePlayer> players = null;
DataClient client;
long timestamp;
/**
* Create an API representation of a Server
*
* @param raw Raw representation of the Server
*/
public Server(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Server
*
* @param client SubData connection
* @param raw Raw representation of the Server
*/
Server(DataClient client, ObjectMap<String> raw) {
this.client = (SubDataClient) client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof Server && getSignature().equals(((Server) obj).getSignature());
}
void load(ObjectMap<String> raw) {
this.raw = raw;
this.players = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
}
SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
String name = getName();
client().sendPacket(new PacketDownloadServerInfo(Collections.singletonList(name), data -> load(data.getMap(name))));
}
/**
* Gets the SubData Client Channel IDs
*
* @return SubData Client Channel ID Array
*/
@SuppressWarnings("unchecked")
public DataSender[] getSubData() {
ObjectMap<Integer> subdata = new ObjectMap<Integer>((Map<Integer, ?>) raw.getObject("subdata"));
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
}
/**
* Determine if an <i>object</i> can perform some action on this server using possible permissions
*
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the server name)
* @return Permission Check Result
*/
public boolean permits(Permissible object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all servers & individual servers permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", this.getName().toLowerCase()));
// Check all hosts & individual hosts permission
if (this instanceof SubServer) {
permitted = permitted || object.hasPermission(perm.replace("%", "::*"))
|| object.hasPermission(perm.replace("%", "::" + ((SubServer) this).getHost().toLowerCase()));
}
// Check all groups & individual groups permission
List<String> groups = this.getGroups();
if (groups.size() > 0) {
permitted = permitted || object.hasPermission(perm.replace("%", ":*"));
for (int g = 0; !permitted && g < groups.size(); g++) {
permitted = object.hasPermission(perm.replace("%", ":" + groups.get(g).toLowerCase()));
}
}
}
}
return permitted;
}
/**
* Get the Name of this Server
*
* @return Server Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Server
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Get the Address of this Server
*
* @return Server Address
*/
public InetSocketAddress getAddress() {
return new InetSocketAddress(raw.getRawString("address").split(":")[0], Integer.parseInt(raw.getRawString("address").split(":")[1]));
}
/**
* Get this Server's Groups
*
* @return Group names
*/
public List<String> getGroups() {
return new LinkedList<String>(raw.getRawStringList("group"));
}
/**
* Get players on this server across all known proxies
*
* @return Remote Player Collection
*/
public Collection<NamedContainer<String, UUID>> getGlobalPlayers() {
List<NamedContainer<String, UUID>> players = new ArrayList<NamedContainer<String, UUID>>();
for (String id : raw.getMap("players").getKeys()) {
players.add(new NamedContainer<String, UUID>(raw.getMap("players").getRawString(id), UUID.fromString(id)));
}
return players;
}
/**
* Get players on this server across all known proxies
*
* @param callback Remote Player Collection
*/
public void getGlobalPlayers(Callback<Collection<RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (players == null) {
LinkedList<UUID> ids = new LinkedList<UUID>();
for (String id : raw.getMap("players").getKeys()) ids.add(UUID.fromString(id));
client().sendPacket(new PacketDownloadPlayerInfo(ids, data -> {
LinkedList<RemotePlayer> players = new LinkedList<RemotePlayer>();
for (String player : data.getKeys()) {
players.add(new RemotePlayer(data.getMap(player)));
}
this.players = players;
run.run();
}));
} else {
run.run();
}
}
/**
* If the server is hidden from players
*
* @return Hidden Status
*/
public boolean isHidden() {
return raw.getBoolean("hidden");
}
/**
* Gets the MOTD of the Server
*
* @return Server MOTD
*/
public String getMotd() {
return raw.getRawString("motd");
}
/**
* Gets if the Server is Restricted
*
* @return Restricted Status
*/
public boolean isRestricted() {
return raw.getBoolean("restricted");
}
/**
* Get a copy of the current whitelist
*
* @return Player Whitelist
*/
public Collection<UUID> getWhitelist() {
return raw.getUUIDList("whitelist");
}
/**
* See if a player is whitelisted
*
* @param player Player to check
* @return Whitelisted Status
*/
public boolean isWhitelisted(UUID player) {
return getWhitelist().contains(player);
}
/**
* Get the Signature of this Object
*
* @return Object Signature
*/
public String getSignature() {
return raw.getRawString("signature");
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Get the raw representation of the Server
*
* @return Raw Server
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

400
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/API/SimplifiedData.java
View File

@ -1,400 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.*;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
/**
* Simplified Data Requesting Class
*/
public final class SimplifiedData {
private SimplifiedData() {}
static SubDataClient client(DataClient client) {
return (SubDataClient) ((client != null)? client : SubAPI.getInstance().getSubDataNetwork()[0]);
}
/**
* Requests the Hosts
*
* @param client SubData connection
* @param callback Host Map
*/
public static void requestHosts(DataClient client, Callback<Map<String, Host>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadHostInfo(null, data -> {
TreeMap<String, Host> hosts = new TreeMap<String, Host>();
for (String host : data.getKeys()) {
hosts.put(host.toLowerCase(), new Host(client, data.getMap(host)));
}
try {
callback.run(hosts);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a Host
*
* @param client SubData connection
* @param name Host name
* @param callback a Host
*/
public static void requestHost(DataClient client, String name, Callback<Host> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadHostInfo(Collections.singletonList(name), data -> {
Host host = null;
if (data.getKeys().size() > 0) {
host = new Host(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(host);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests the Server Groups (Group names are case sensitive here)
*
* @param client SubData connection
* @param callback Group Map
*/
public static void requestGroups(DataClient client, Callback<Map<String, List<Server>>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadGroupInfo(null, data -> {
TreeMap<String, List<Server>> groups = new TreeMap<String, List<Server>>();
for (String group : data.getKeys()) {
ArrayList<Server> servers = new ArrayList<Server>();
for (String server : data.getMap(group).getKeys()) {
if (data.getMap(group).getMap(server).getRawString("type", "Server").equals("SubServer")) {
servers.add(new SubServer(client, data.getMap(group).getMap(server)));
} else {
servers.add(new Server(client, data.getMap(group).getMap(server)));
}
}
if (servers.size() > 0) groups.put(group, servers);
}
try {
callback.run(groups);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests the Server Groups (Group names are all lowercase here)
*
* @param client SubData connection
* @param callback Group Map
*/
public static void requestLowercaseGroups(DataClient client, Callback<Map<String, List<Server>>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
requestGroups(client, groups -> {
TreeMap<String, List<Server>> lowercaseGroups = new TreeMap<String, List<Server>>();
for (String key : groups.keySet()) {
lowercaseGroups.put(key.toLowerCase(), groups.get(key));
}
callback.run(lowercaseGroups);
});
}
/**
* Requests a Server Group (Group names are case insensitive here)
*
* @param client SubData connection
* @param name Group name
* @param callback a Server Group
*/
public static void requestGroup(DataClient client, String name, Callback<NamedContainer<String, List<Server>>> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadGroupInfo(Collections.singletonList(name), data -> {
NamedContainer<String, List<Server>> group = null;
if (data.getKeys().size() > 0) {
String key = new LinkedList<String>(data.getKeys()).getFirst();
List<Server> servers = new ArrayList<Server>();
for (String server : data.getMap(key).getKeys()) {
if (data.getMap(key).getMap(server).getRawString("type", "Server").equals("SubServer")) {
servers.add(new SubServer(client, data.getMap(key).getMap(server)));
} else {
servers.add(new Server(client, data.getMap(key).getMap(server)));
}
}
group = new NamedContainer<>(key, servers);
}
try {
callback.run(group);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests the Servers (including SubServers)
*
* @param client SubData connection
* @param callback Server Map
*/
public static void requestServers(DataClient client, Callback<Map<String, Server>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadServerInfo(null, data -> {
TreeMap<String, Server> servers = new TreeMap<String, Server>();
for (String server : data.getKeys()) {
if (data.getMap(server).getRawString("type", "Server").equals("SubServer")) {
servers.put(server.toLowerCase(), new SubServer(client, data.getMap(server)));
} else {
servers.put(server.toLowerCase(), new Server(client, data.getMap(server)));
}
}
try {
callback.run(servers);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a Server
*
* @param client SubData connection
* @param name Server name
* @param callback a Server
*/
public static void requestServer(DataClient client, String name, Callback<Server> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadServerInfo(Collections.singletonList(name), data -> {
Server server = null;
if (data.getKeys().size() > 0) {
String key = new LinkedList<String>(data.getKeys()).getFirst();
if (data.getMap(key).getRawString("type", "Server").equals("SubServer")) {
server = new SubServer(client, data.getMap(key));
} else {
server = new Server(client, data.getMap(key));
}
}
try {
callback.run(server);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests the SubServers
*
* @param client SubData connection
* @param callback SubServer Map
*/
public static void requestSubServers(DataClient client, Callback<Map<String, SubServer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
requestServers(client, servers -> {
TreeMap<String, SubServer> subservers = new TreeMap<String, SubServer>();
for (String server : servers.keySet()) {
if (servers.get(server) instanceof SubServer) subservers.put(server, (SubServer) servers.get(server));
}
callback.run(subservers);
});
}
/**
* Requests a SubServer
*
* @param client SubData connection
* @param name SubServer name
* @param callback a SubServer
*/
public static void requestSubServer(DataClient client, String name, Callback<SubServer> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
requestServer(client, name, server -> callback.run((server instanceof SubServer)?(SubServer) server:null));
}
/**
* Requests the known Proxies
*
* @param client SubData connection
* @param callback Proxy Map
*/
public static void requestProxies(DataClient client, Callback<Map<String, Proxy>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadProxyInfo(null, data -> {
TreeMap<String, Proxy> proxies = new TreeMap<String, Proxy>();
for (String proxy : data.getKeys()) {
proxies.put(proxy.toLowerCase(), new Proxy(client, data.getMap(proxy)));
}
try {
callback.run(proxies);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a Proxy
*
* @param client SubData connection
* @param name Proxy name
* @param callback a Proxy
*/
public static void requestProxy(DataClient client, String name, Callback<Proxy> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadProxyInfo(Collections.singletonList(name), data -> {
Proxy proxy = null;
if (data.getKeys().size() > 0) {
proxy = new Proxy(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(proxy);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Request the Master Proxy redis container (null if unavailable)
*
* @param client SubData connection
* @param callback Master Proxy
*/
public static void requestMasterProxy(DataClient client, Callback<Proxy> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadProxyInfo(Collections.emptyList(), data -> {
Proxy proxy = null;
if (data.getKeys().size() > 0) {
proxy = new Proxy(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(proxy);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests players on this network across all known proxies
*
* @param client SubData connection
* @param callback Remote Player Collection
*/
public static void requestGlobalPlayers(DataClient client, Callback<Map<UUID, RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadPlayerInfo((List<UUID>) null, data -> {
TreeMap<UUID, RemotePlayer> players = new TreeMap<UUID, RemotePlayer>();
for (String player : data.getKeys()) {
players.put(UUID.fromString(player), new RemotePlayer(client, data.getMap(player)));
}
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a player on this network by searching across all known proxies
*
* @param client SubData connection
* @param name Player name
* @param callback Remote Player
*/
public static void requestGlobalPlayer(DataClient client, String name, Callback<RemotePlayer> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadPlayerInfo(Collections.singletonList(name), data -> {
RemotePlayer player = null;
if (data.getKeys().size() > 0) {
player = new RemotePlayer(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(player);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a player on this network by searching across all known proxies
*
* @param client SubData connection
* @param id Player UUID
* @param callback Remote Player
*/
public static void requestGlobalPlayer(DataClient client, UUID id, Callback<RemotePlayer> callback) {
if (Util.isNull(id, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadPlayerInfo(Collections.singletonList(id), data -> {
RemotePlayer player = null;
if (data.getKeys().size() > 0) {
player = new RemotePlayer(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(player);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
}

948
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/API/SubServer.java
View File

@ -1,948 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.*;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
/**
* Simplified SubServer Data Class
*/
public class SubServer extends Server {
private List<SubServer> incompatibilities = null;
private List<SubServer> currentIncompatibilities = null;
private Host host = null;
/**
* SubServer Stop Action Class
*/
public enum StopAction {
NONE,
RESTART,
REMOVE_SERVER,
RECYCLE_SERVER,
DELETE_SERVER;
@Override
public String toString() {
return super.toString().substring(0, 1).toUpperCase()+super.toString().substring(1).toLowerCase().replace('_', ' ');
}
}
/**
* Create an API representation of a SubServer
*
* @param raw JSON representation of the SubServer
*/
public SubServer(ObjectMap<String> raw) {
super(null, raw);
}
/**
* Create an API representation of a SubServer
*
* @param client SubData connection
* @param raw JSON representation of the SubServer
*/
SubServer(DataClient client, ObjectMap<String> raw) {
super(client, raw);
}
/**
* Create an API representation of a SubServer
*
* @param host Host
* @param raw JSON representation of the SubServer
*/
SubServer(Host host, ObjectMap<String> raw) {
super(host.client, raw);
this.host = host;
}
@Override
public boolean equals(Object obj) {
return obj instanceof SubServer && super.equals(obj);
}
@Override
public void refresh() {
host = null;
incompatibilities = null;
currentIncompatibilities = null;
super.refresh();
}
/**
* Starts the Server
*
* @param player Player who Started
* @param response Response Code
*/
public void start(UUID player, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketStartServer(player, getName(), data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Starts the Server
*
* @param response Response Code
*/
public void start(Callback<Integer> response) {
start(null, response);
}
/**
* Starts the Server
*
* @param player Player who Started
*/
public void start(UUID player) {
start(player, i -> {});
}
/**
* Starts the Server
*/
public void start() {
start(i -> {});
}
/**
* Stops the Server
*
* @param player Player who Stopped
* @param response Response Code
*/
public void stop(UUID player, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketStopServer(player, getName(), false, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Stops the Server
*
* @param response Response Code
*/
public void stop(Callback<Integer> response) {
stop(null, response);
}
/**
* Stops the Server
*
* @param player Player who Stopped
*/
public void stop(UUID player) {
stop(player, i -> {});
}
/**
* Stops the Server
*/
public void stop() {
stop(i -> {});
}
/**
* Terminates the Server
*
* @param player Player who Terminated
* @param response Response Code
*/
public void terminate(UUID player, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketStopServer(player, getName(), true, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Terminates the Server
*
* @param response Response Code
*/
public void terminate(Callback<Integer> response) {
terminate(null, response);
}
/**
* Terminates the Server
*
* @param player Player who Terminated
*/
public void terminate(UUID player) {
terminate(player, i -> {});
}
/**
* Terminates the Server
*/
public void terminate() {
terminate(i -> {});
}
/**
* Commands the Server
*
* @param player Player who Commanded
* @param command Commmand to Send
* @param response Response Code
*/
public void command(UUID player, String command, Callback<Integer> response) {
if (Util.isNull(command, response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketCommandServer(player, getName(), command, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Commands the Server
*
* @param command Commmand to Send
* @param response Response Code
*/
public void command(String command, Callback<Integer> response) {
command(null, command, response);
}
/**
* Commands the Server
*
* @param player Player who Commanded
* @param command Command to Send
*/
public void command(UUID player, String command) {
command(player, command, i -> {});
}
/**
* Commands the Server
*
* @param command Command to Send
*/
public void command(String command) {
command(command, i -> {});
}
/**
* Edits the Server
*
* @param player Player Editing
* @param edit Edits
* @param response Negative Response Code -or- Positive Success Status
*/
public void edit(UUID player, ObjectMap<String> edit, Callback<Integer> response) {
edit(player, edit, false, response);
}
/**
* Edits the Server
*
* @param edit Edits
* @param response Negative Response Code -or- Positive Success Status
*/
public void edit(ObjectMap<String> edit, Callback<Integer> response) {
edit(null, edit, response);
}
/**
* Edits the Server
*
* @param player Player Editing
* @param edit Edits
*/
public void edit(UUID player, ObjectMap<String> edit) {
edit(player, edit, i -> {});
}
/**
* Edits the Server
*
* @param edit Edits
*/
public void edit(ObjectMap<String> edit) {
edit(null, edit);
}
/**
* Edits the Server (& Saves Changes)
*
* @param player Player Editing
* @param edit Edits
* @param response Negative Response Code -or- Positive Success Status
*/
public void permaEdit(UUID player, ObjectMap<String> edit, Callback<Integer> response) {
edit(player, edit, true, response);
}
/**
* Edits the Server (& Saves Changes)
*
* @param edit Edits
* @param response Negative Response Code -or- Positive Success Status
*/
public void permaEdit(ObjectMap<String> edit, Callback<Integer> response) {
permaEdit(null, edit, response);
}
/**
* Edits the Server (& Saves Changes)
*
* @param player Player Editing
* @param edit Edits
*/
public void permaEdit(UUID player, ObjectMap<String> edit) {
permaEdit(player, edit, i -> {});
}
/**
* Edits the Server (& Saves Changes)
*
* @param edit Edits
*/
public void permaEdit(ObjectMap<String> edit) {
permaEdit(null, edit);
}
private void edit(UUID player, ObjectMap<String> edit, boolean perma, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketEditServer(player, getName(), edit, perma, data -> {
try {
if (data.getInt(0x0001) != 0) {
response.run(data.getInt(0x0001) * -1);
} else {
response.run(data.getInt(0x0002));
}
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* If the Server is Running
*
* @return Running Status
*/
public boolean isRunning() {
return raw.getBoolean("running");
}
/**
* If the Server is Online<br>
* <b>This method can only be true when a SubData connection is made!</b>
*
* @return Online Status
*/
public boolean isOnline() {
return raw.getBoolean("online");
}
/**
* Grabs the Host of the Server
*
* @return The Host Name
*/
public String getHost() {
return raw.getRawString("host");
}
/**
* Grabs the Host of the Server
*
* @param callback The Host
*/
public void getHost(Callback<Host> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(host);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (host == null || !host.getName().equalsIgnoreCase(raw.getRawString("host"))) {
SubAPI.getInstance().getHost(raw.getRawString("host"), host -> {
this.host = host;
run.run();
});
} else {
run.run();
}
}
/**
* Grabs the Template this Server was created from
*
* @return The Template
*/
public String getTemplate() {
return raw.getRawString("template");
}
/**
* Is this Server Available?
*
* @return Availability Status
*/
public boolean isAvailable() {
return raw.getBoolean("available");
}
/**
* If the Server is Enabled
*
* @return Enabled Status
*/
public boolean isEnabled() {
return raw.getBoolean("enabled");
}
/**
* Set if the Server is Enabled
*
* @param value Value
*/
public void setEnabled(boolean value) {
setEnabled(value, b -> {});
}
/**
* Set if the Server is Enabled
*
* @param value Value
* @param response Success Status
*/
public void setEnabled(boolean value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("enabled", value);
edit(edit, r -> {
if (r > 0) raw.set("enabled", value);
response.run(r > 0);
});
}
/**
* If the Server is accepting requests to edit()
*
* @return Edit Status
*/
public boolean isEditable() {
return raw.getBoolean("editable");
}
/**
* If the Server is Logging
*
* @return Logging Status
*/
public boolean isLogging() {
return raw.getBoolean("log");
}
/**
* Set if the Server is Logging
*
* @param value Value
*/
public void setLogging(boolean value) {
setLogging(value, b -> {});
}
/**
* Set if the Server is Logging
*
* @param value Value
* @param response Success Status
*/
public void setLogging(boolean value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("log", value);
edit(edit, r -> {
if (r > 0) raw.set("log", value);
response.run(r > 0);
});
}
/**
* Get the Server Directory Path
*
* @return Server Directory Path
*/
public String getPath() {
return raw.getRawString("dir");
}
/**
* Get the Server's Executable String
*
* @return Executable String
*/
public String getExecutable() {
return raw.getRawString("exec");
}
/**
* Grab the Command to Stop the Server
*
* @return Stop Command
*/
public String getStopCommand() {
return raw.getRawString("stop-cmd");
}
/**
* Set the Command that Stops the Server
*
* @param value Value
*/
public void setStopCommand(String value) {
setStopCommand(value, b -> {});
}
/**
* Set the Command that Stops the Server
*
* @param value Value
* @param response Success Status
*/
public void setStopCommand(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("stop-cmd", value);
edit(edit, r -> {
if (r > 0) raw.set("stop-cmd", value);
response.run(r > 0);
});
}
/**
* Get the action the Server will take when it stops
*
* @return Stop Action
*/
public StopAction getStopAction() {
return Util.getDespiteException(() -> StopAction.valueOf(raw.getRawString("stop-action").toUpperCase().replace('-', '_').replace(' ', '_')), StopAction.NONE);
}
/**
* Set the action the Server will take when it stops
*
* @param action Stop Action
*/
public void setStopAction(StopAction action) {
setStopAction(action, b -> {});
}
/**
* Set the action the Server will take when it stops
*
* @param action Stop Action
* @param response Success Status
*/
public void setStopAction(StopAction action, Callback<Boolean> response) {
if (Util.isNull(action, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("stop-action", action.toString());
edit(edit, r -> {
if (r > 0) raw.set("stop-action", action.toString());
response.run(r > 0);
});
}
/**
* Toggles compatibility with other Servers
*
* @param server SubServer to toggle
*/
public void toggleCompatibility(String server) {
toggleCompatibility(server, b -> {});
}
/**
* Toggles compatibility with other Servers
*
* @param server SubServer to toggle
*/
public void toggleCompatibility(String server, Callback<Boolean> response) {
if (Util.isNull(server, response)) throw new NullPointerException();
ArrayList<String> value = new ArrayList<String>();
value.addAll(getIncompatibilities());
if (!value.contains(server)) value.add(server);
else value.remove(server);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("incompatible", value);
edit(edit, r -> {
if (r > 0) raw.set("incompatible", value);
response.run(r > 0);
});
}
/**
* Checks if a Server is compatible
*
* @param server Server name to check
* @return Compatible Status
*/
public boolean isCompatible(String server) {
LinkedList<String> lowercaseIncompatibilities = new LinkedList<String>();
for (String key : getIncompatibilities()) {
lowercaseIncompatibilities.add(key.toLowerCase());
}
return lowercaseIncompatibilities.contains(server.toLowerCase());
}
/**
* Get all listed incompatibilities for this Server
*
* @return Incompatibility List
*/
public List<String> getIncompatibilities() {
return new LinkedList<String>(raw.getRawStringList("incompatible-list"));
}
/**
* Get all listed incompatibilities for this Server
*
* @param callback Incompatibility List
*/
public void getIncompatibilities(Callback<List<SubServer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(incompatibilities);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (incompatibilities == null) {
LinkedList<String> incompatible = new LinkedList<String>();
for (String subserver : raw.getRawStringList("incompatible-list")) incompatible.add(subserver.toLowerCase());
client().sendPacket(new PacketDownloadServerInfo(incompatible, data -> {
LinkedList<SubServer> incompatibilities = new LinkedList<SubServer>();
for (String server : data.getKeys()) {
if (data.getMap(server).getRawString("type", "Server").equals("SubServer")) incompatibilities.add(new SubServer(data.getMap(server)));
}
this.incompatibilities = incompatibilities;
run.run();
}));
} else {
run.run();
}
}
/**
* Get incompatibility issues this server currently has
*
* @return Current Incompatibility List
*/
public List<String> getCurrentIncompatibilities() {
return new LinkedList<String>(raw.getRawStringList("incompatible"));
}
/**
* Get incompatibility issues this server currently has
*
* @param callback Current Incompatibility List
*/
public void getCurrentIncompatibilities(Callback<List<SubServer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(currentIncompatibilities);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (currentIncompatibilities == null) {
LinkedList<String> incompatible = new LinkedList<String>();
for (String subserver : raw.getRawStringList("incompatible")) incompatible.add(subserver.toLowerCase());
client().sendPacket(new PacketDownloadServerInfo(incompatible, data -> {
LinkedList<SubServer> incompatibilities = new LinkedList<SubServer>();
for (String server : data.getKeys()) {
if (data.getMap(server).getRawString("type", "Server").equals("SubServer")) incompatibilities.add(new SubServer(data.getMap(server)));
}
this.currentIncompatibilities = incompatibilities;
run.run();
}));
} else {
run.run();
}
}
/**
* Sets the Display Name for this Server
*
* @param value Value (or null to reset)
*/
public void setDisplayName(String value) {
setMotd(value, b -> {});
}
/**
* Sets the Display Name for this Server
*
* @param value Value (or null to reset)
* @param response Success Status
*/
public void setDisplayName(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("display", (value == null)?"":value);
edit(edit, r -> {
if (r > 0) raw.set("display", (value == null)?getName():value);
response.run(r > 0);
});
}
/**
* Add this Server to a Group
*
* @param value Group name
*/
public void addGroup(String value) {
addGroup(value, b -> {});
}
/**
* Add this Server to a Group
*
* @param value Group name
* @param response Success Status
*/
public void addGroup(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ArrayList<String> v = new ArrayList<String>();
v.addAll(getGroups());
if (!v.contains(value)) v.add(value);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("group", v);
edit(edit, r -> {
if (r > 0) raw.set("group", v);
response.run(r > 0);
});
}
/**
* Remove this Server from a Group
*
* @param value value Group name
*/
public void removeGroup(String value) {
removeGroup(value, b -> {});
}
/**
* Remove this Server from a Group
*
* @param value value Group name
* @param response Success Status
*/
public void removeGroup(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ArrayList<UUID> v = new ArrayList<UUID>();
v.addAll(getWhitelist());
v.remove(value);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("group", v);
edit(edit, r -> {
if (r > 0) raw.set("group", v);
response.run(r > 0);
});
}
/**
* Set if the server is hidden from players
*
* @param value Value
*/
public void setHidden(boolean value) {
setHidden(value, b -> {});
}
/**
* Set if the server is hidden from players
*
* @param value Value
* @param response Success Status
*/
public void setHidden(boolean value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("restricted", value);
edit(edit, r -> {
if (r > 0) raw.set("restricted", value);
response.run(r > 0);
});
}
/**
* Sets the MOTD of the Server
*
* @param value Value
*/
public void setMotd(String value) {
setMotd(value, b -> {});
}
/**
* Sets the MOTD of the Server
*
* @param value Value
* @param response Success Status
*/
public void setMotd(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("motd", value);
edit(edit, r -> {
if (r > 0) raw.set("motd", value);
response.run(r > 0);
});
}
/**
* Sets if the Server is Restricted
*
* @param value Value
*/
public void setRestricted(boolean value) {
setRestricted(value, b -> {});
}
/**
* Sets if the Server is Restricted
*
* @param value Value
* @param response Success Status
*/
public void setRestricted(boolean value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("restricted", value);
edit(edit, r -> {
if (r > 0) raw.set("restricted", value);
response.run(r > 0);
});
}
/**
* Add a player to the whitelist (for use with restricted servers)
*
* @param player Player to add
*/
public void whitelist(UUID player) {
whitelist(player, b -> {});
}
/**
* Add a player to the whitelist (for use with restricted servers)
*
* @param player Player to add
* @param response Success Status
*/
public void whitelist(UUID player, Callback<Boolean> response) {
if (Util.isNull(player, response)) throw new NullPointerException();
ArrayList<UUID> value = new ArrayList<UUID>();
value.addAll(getWhitelist());
if (!value.contains(player)) value.add(player);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("whitelist", value);
edit(edit, r -> {
if (r > 0) raw.set("whitelist", value);
response.run(r > 0);
});
}
/**
* Remove a player to the whitelist
*
* @param player Player to remove
*/
public void unwhitelist(UUID player) {
unwhitelist(player, b -> {});
}
/**
* Remove a player to the whitelist
*
* @param player Player to remove
* @param response Success Status
*/
public void unwhitelist(UUID player, Callback<Boolean> response) {
if (Util.isNull(player, response)) throw new NullPointerException();
ArrayList<UUID> value = new ArrayList<UUID>();
value.addAll(getWhitelist());
value.remove(player);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("whitelist", value);
edit(edit, r -> {
if (r > 0) raw.set("whitelist", value);
response.run(r > 0);
});
}
}

125
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketAddServer.java
View File

@ -1,125 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Bukkit.Graphic.UIRenderer;
import java.net.InetAddress;
import java.util.HashMap;
import java.util.UUID;
/**
* Add Server Packet
*/
public class PacketAddServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String name;
private ObjectMap<String> opt;
private boolean subserver;
private UUID tracker;
/**
* New PacketAddServer (In)
*/
public PacketAddServer() {}
/**
* New PacketCreateServer [Server] (Out)
*
* @param player Player who added
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden If the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param callback Callbacks
*/
@SafeVarargs
public PacketAddServer(UUID player, String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(name, ip, port, motd, hidden, restricted)) throw new NullPointerException();
this.player = player;
this.name = name;
this.subserver = false;
ObjectMap<String> opt = new ObjectMap<String>();
opt.set("address", ip.getHostAddress() + ':' + port);
opt.set("motd", motd);
opt.set("restricted", restricted);
opt.set("hidden", hidden);
this.opt = opt;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
/**
* New PacketAddServer [SubServer] (Out)
*
* @param player Player who Added
* @param name Name of Server
* @param enabled Enabled Status
* @param host Host of Server
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param callback Callbacks
*/
@SafeVarargs
public PacketAddServer(UUID player, String name, boolean enabled, String host, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(host, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted)) throw new NullPointerException();
this.player = player;
this.name = name;
this.subserver = true;
ObjectMap<String> opt = new ObjectMap<String>();
opt.set("enabled", enabled);
opt.set("host", host);
opt.set("port", port);
opt.set("motd", motd);
opt.set("log", log);
opt.set("dir", directory);
opt.set("exec", executable);
opt.set("stop-cmd", stopcmd);
opt.set("restricted", restricted);
opt.set("hidden", hidden);
this.opt = opt;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, name);
data.set(0x0002, subserver);
data.set(0x0003, opt);
if (player != null) data.set(0x0004, player);
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

135
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketCreateServer.java
View File

@ -1,135 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Bukkit.Graphic.UIRenderer;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import java.util.HashMap;
import java.util.UUID;
/**
* Create Server Packet
*/
public class PacketCreateServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String name;
private String host;
private String template;
private Version version;
private Integer port;
private boolean waitfor;
private UUID tracker;
/**
* New PacketCreateServer (In)
*/
public PacketCreateServer() {}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param name Server Name
* @param host Host to use
* @param template Server Template
* @param version Server Version
* @param port Server Port
* @param callback Callbacks
*/
@SafeVarargs
public PacketCreateServer(UUID player, String name, String host, String template, Version version, Integer port, Callback<ObjectMap<Integer>>... callback) {
this(player, name, host, template, version, port, false, callback);
}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param name Server Name
* @param host Host to use
* @param template Server Template
* @param version Server Version
* @param port Server Port
* @param waitfor Wait until completion to send callback
* @param callback Callbacks
*/
@SafeVarargs
public PacketCreateServer(UUID player, String name, String host, String template, Version version, Integer port, boolean waitfor, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(name, host, template, callback)) throw new NullPointerException();
this.player = player;
this.name = name;
this.host = host;
this.template = template;
this.version = version;
this.port = port;
this.waitfor = waitfor;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param options Creator UI Options
* @param callback Callbacks
*/
@SafeVarargs
public PacketCreateServer(UUID player, UIRenderer.CreatorOptions options, Callback<ObjectMap<Integer>>... callback) {
this(player, options, false, callback);
}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param options Creator UI Options
* @param waitfor Wait until completion to send callback
* @param callback Callbacks
*/
@SafeVarargs
public PacketCreateServer(UUID player, UIRenderer.CreatorOptions options, boolean waitfor, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(options, callback)) throw new NullPointerException();
this.player = player;
this.name = options.getName();
this.host = options.getHost();
this.template = options.getTemplate();
this.version = options.getVersion();
this.port = options.getPort();
this.waitfor = waitfor;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, name);
data.set(0x0002, host);
data.set(0x0003, template);
if (version != null) data.set(0x0004, version);
if (port != null) data.set(0x0005, port);
if (player != null) data.set(0x0006, player);
if (waitfor) data.set(0x0007, true);
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

68
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketDeleteServer.java
View File

@ -1,68 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Delete Server Packet
*/
public class PacketDeleteServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private boolean recycle;
private boolean force;
private UUID tracker;
/**
* New PacketDeleteServer (In)
*/
public PacketDeleteServer() {}
/**
* New PacketDeleteServer (Out)
*
* @param player Player Deleting
* @param server Server
* @param callback Callbacks
*/
@SafeVarargs
public PacketDeleteServer(UUID player, String server, boolean recycle, boolean force, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.recycle = recycle;
this.force = force;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, recycle);
data.set(0x0003, force);
if (player != null) data.set(0x0004, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

61
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketDownloadGroupInfo.java
View File

@ -1,61 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Download Group Info Packet
*/
public class PacketDownloadGroupInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private List<String> groups;
private UUID tracker;
/**
* New PacketDownloadGroupInfo (In)
*/
public PacketDownloadGroupInfo() {}
/**
* New PacketDownloadGroupInfo (Out)
*
* @param groups Group names (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadGroupInfo(List<String> groups, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.groups = groups;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (groups != null) json.set(0x0001, groups);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

61
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketDownloadHostInfo.java
View File

@ -1,61 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Download Host Info Packet
*/
public class PacketDownloadHostInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private List<String> hosts;
private UUID tracker;
/**
* New PacketDownloadHostInfo (In)
*/
public PacketDownloadHostInfo() {}
/**
* New PacketDownloadHostInfo (Out)
*
* @param hosts Host names (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadHostInfo(List<String> hosts, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.hosts = hosts;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (hosts != null) json.set(0x0001, hosts);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

50
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketDownloadPlatformInfo.java
View File

@ -1,50 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* Download Proxy Info Packet
*/
public class PacketDownloadPlatformInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private UUID tracker;
/**
* New PacketDownloadPlatformInfo
*
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadPlatformInfo(Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
return data;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

70
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketEditServer.java
View File

@ -1,70 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Edit Server Packet
*/
public class PacketEditServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private ObjectMap<String> edit;
private boolean perma;
private UUID tracker;
/**
* New PacketEditServer (In)
*/
public PacketEditServer() {}
/**
* New PacketEditServer (Out)
*
* @param player Player Editing
* @param server Server
* @param edit Edits
* @param perma Save Changes
* @param callback Callbacks
*/
@SafeVarargs
public PacketEditServer(UUID player, String server, ObjectMap<String> edit, boolean perma, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.edit = edit;
this.perma = perma;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, edit);
data.set(0x0003, perma);
if (player != null) data.set(0x0004, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

65
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketRemoveServer.java
View File

@ -1,65 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Remove Server Packet
*/
public class PacketRemoveServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private boolean force;
private UUID tracker;
/**
* New PacketRemoveServer (In)
*/
public PacketRemoveServer() {}
/**
* New PacketRemoveServer (Out)
*
* @param player Player Removing
* @param server Server
* @param callback Callbacks
*/
@SafeVarargs
public PacketRemoveServer(UUID player, String server, boolean force, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.force = force;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, force);
if (player != null) data.set(0x0003, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

62
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketStartServer.java
View File

@ -1,62 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Start Server Packet
*/
public class PacketStartServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private UUID tracker;
/**
* New PacketStartServer (In)
*/
public PacketStartServer() {}
/**
* New PacketStartServer (Out)
*
* @param player Player Starting
* @param server Server
* @param callback Callbacks
*/
@SafeVarargs
public PacketStartServer(UUID player, String server, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
if (player != null) data.set(0x0002, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

90
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketUpdateServer.java
View File

@ -1,90 +0,0 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Bukkit.Graphic.UIRenderer;
import java.util.HashMap;
import java.util.UUID;
/**
* Create Server Packet
*/
public class PacketUpdateServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String name;
private String template;
private Version version;
private boolean waitfor;
private UUID tracker;
/**
* New PacketCreateServer (In)
*/
public PacketUpdateServer() {}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param name Server Name
* @param template Server Template
* @param version Server Version
* @param callback Callbacks
*/
@SafeVarargs
public PacketUpdateServer(UUID player, String name, String template, Version version, Callback<ObjectMap<Integer>>... callback) {
this(player, name, template, version, false, callback);
}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param name Server Name
* @param template Server Template
* @param version Server Version
* @param waitfor Wait until completion to send callback
* @param callback Callbacks
*/
@SafeVarargs
public PacketUpdateServer(UUID player, String name, String template, Version version, boolean waitfor, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
this.player = player;
this.name = name;
this.template = template;
this.version = version;
this.waitfor = waitfor;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, name);
if (template != null) data.set(0x0002, template);
if (version != null) data.set(0x0003, version);
if (player != null) data.set(0x0004, player);
if (waitfor) data.set(0x0005, true);
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

1
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/SubProtocol.java
View File

@ -12,6 +12,7 @@ import net.ME1312.SubServers.Client.Bukkit.Event.SubNetworkDisconnectEvent;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.*;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import net.ME1312.SubServers.Client.Bukkit.SubPlugin;
import net.ME1312.SubServers.Client.Common.Network.Packet.*;
import org.bukkit.Bukkit;
import java.io.IOException;

339
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/SubAPI.java
View File

@ -1,27 +1,20 @@
package net.ME1312.SubServers.Client.Bukkit;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataProtocol;
import net.ME1312.SubServers.Client.Bukkit.Graphic.UIHandler;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Bukkit.Network.API.*;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.*;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Bukkit.Graphic.UIHandler;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import org.bukkit.Bukkit;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.util.*;
import static net.ME1312.SubServers.Client.Bukkit.Network.API.SimplifiedData.*;
/**
* SubAPI Class
*/
public final class SubAPI {
public final class SubAPI extends ClientAPI {
LinkedList<Runnable> reloadListeners = new LinkedList<Runnable>();
private final SubPlugin plugin;
private static SubAPI api;
@ -71,316 +64,6 @@ public final class SubAPI {
return name;
}
/**
* Gets the Hosts
*
* @param callback Host Map
*/
public void getHosts(Callback<Map<String, Host>> callback) {
requestHosts(null, callback);
}
/**
* Gets a Host
*
* @param name Host name
* @param callback a Host
*/
public void getHost(String name, Callback<Host> callback) {
requestHost(null, name, callback);
}
/**
* Gets the Server Groups (Group names are case sensitive here)
*
* @param callback Group Map
*/
public void getGroups(Callback<Map<String, List<Server>>> callback) {
requestGroups(null, callback);
}
/**
* Gets the Server Groups (Group names are all lowercase here)
*
* @param callback Group Map
*/
public void getLowercaseGroups(Callback<Map<String, List<Server>>> callback) {
requestLowercaseGroups(null, callback);
}
/**
* Gets a Server Group (Group names are case insensitive here)
*
* @param name Group name
* @param callback a Server Group
*/
public void getGroup(String name, Callback<NamedContainer<String, List<Server>>> callback) {
requestGroup(null, name, callback);
}
/**
* Gets the Servers (including SubServers)
*
* @param callback Server Map
*/
public void getServers(Callback<Map<String, Server>> callback) {
requestServers(null, callback);
}
/**
* Gets a Server
*
* @param name Server name
* @param callback a Server
*/
public void getServer(String name, Callback<Server> callback) {
requestServer(null, name, callback);
}
/**
* Adds a Server to the Network
*
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
*/
public void addServer(String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted, Callback<Integer> response) {
addServer(null, name, ip, port, motd, hidden, restricted, response);
}
/**
* Adds a Server to the Network
*
* @param player Player who added
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden If the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
*/
public void addServer(UUID player, String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketAddServer(player, name, ip, port, motd, hidden, restricted, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Adds a Server to the Network
*
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
*/
public void addServer(String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted) {
addServer(null, name, ip, port, motd, hidden, restricted);
}
/**
* Adds a Server to the Network
*
* @param player Player who added
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden If the server should be hidden from players
* @param restricted Players will need a permission to join if true
*/
public void addServer(UUID player, String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted) {
addServer(player, name, ip, port, motd, hidden, restricted, i -> {});
}
/**
* Remove a Server from the Network
*
* @param name Name of the Server
* @param response Response Code
*/
public void removeServer(String name, Callback<Integer> response) {
removeServer(null, name, response);
}
/**
* Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
* @param response Response Code
*/
public void removeServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, false, response);
}
/**
* Remove a Server from the Network
*
* @param name Name of the Server
*/
public void removeServer(String name) {
removeServer(null, name);
}
/**
* Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
*/
public void removeServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, i -> {});
}
/**
* Force Remove a Server from the Network
*
* @param name Name of the Server
* @param response Response Code
*/
public void forceRemoveServer(String name, Callback<Integer> response) {
forceRemoveServer(null, name, response);
}
/**
* Force Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
* @param response Response Code
*/
public void forceRemoveServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, true, response);
}
/**
* Force Remove a Server from the Network
*
* @param name Name of the Server
*/
public void forceRemoveServer(String name) {
forceRemoveServer(null, name);
}
/**
* Force Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
*/
public void forceRemoveServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
forceRemoveServer(player, name, i -> {});
}
private void removeServer(UUID player, String name, boolean force, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketRemoveServer(player, name, force, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Gets the SubServers
*
* @param callback SubServer Map
*/
public void getSubServers(Callback<Map<String, SubServer>> callback) {
requestSubServers(null, callback);
}
/**
* Gets a SubServer
*
* @param name SubServer name
* @param callback a SubServer
*/
public void getSubServer(String name, Callback<SubServer> callback) {
requestSubServer(null, name, callback);
}
/**
* Gets the known Proxies
*
* @param callback Proxy Map
*/
public void getProxies(Callback<Map<String, Proxy>> callback) {
requestProxies(null, callback);
}
/**
* Gets a Proxy
*
* @param name Proxy name
* @param callback a Proxy
*/
public void getProxy(String name, Callback<Proxy> callback) {
requestProxy(null, name, callback);
}
/**
* Get the Master Proxy Container
*
* @param callback Master Proxy
*/
public void getMasterProxy(Callback<Proxy> callback) {
requestMasterProxy(null, callback);
}
/**
* Gets players on this network across all known proxies
*
* @param callback Remote Player Collection
*/
public void getGlobalPlayers(Callback<Map<UUID, RemotePlayer>> callback) {
requestGlobalPlayers(null, callback);
}
/**
* Gets a player on this network by searching across all known proxies
*
* @param name Player name
* @param callback Remote Player
*/
public void getGlobalPlayer(String name, Callback<RemotePlayer> callback) {
requestGlobalPlayer(null, name, callback);
}
/**
* Gets a player on this network by searching across all known proxies
*
* @param id Player UUID
* @param callback Remote Player
*/
public void getGlobalPlayer(UUID id, Callback<RemotePlayer> callback) {
requestGlobalPlayer(null, id, callback);
}
/**
* Gets the SubData Network Connections
*
@ -423,18 +106,6 @@ public final class SubAPI {
return new LinkedHashMap<>(plugin.lang.get().get(channel.toLowerCase()));
}
/**
* Gets a value from the SubServers Lang
*
* @param channel Lang Channel
* @param key Key
* @return Lang Values
*/
public String getLang(String channel, String key) {
if (Util.isNull(channel, key)) throw new NullPointerException();
return getLang(channel).get(key);
}
/**
* Gets the Graphics Handler
*

13
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/SubCommand.java
View File

@ -10,7 +10,10 @@ import net.ME1312.SubServers.Client.Bukkit.Graphic.UIRenderer;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Config.YAMLSection;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Bukkit.Network.API.*;
import net.ME1312.SubServers.Client.Common.Network.API.*;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketCreateServer;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketRestartServer;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketUpdateServer;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.*;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
@ -26,6 +29,8 @@ import java.net.URL;
import java.nio.charset.Charset;
import java.util.*;
import static net.ME1312.SubServers.Client.Bukkit.Library.ObjectPermission.*;
public final class SubCommand extends BukkitCommand {
private SubPlugin plugin;
@ -726,11 +731,11 @@ public final class SubCommand extends BukkitCommand {
String select = args[(args.length > 2)?2:1];
plugin.api.getServer(select, server -> {
if (server != null) {
if (server.permits(sender, "subservers.server.%.*", "subservers.server.%.teleport")) {
if (permits(server, sender, "subservers.server.%.*", "subservers.server.%.teleport")) {
if (!(server instanceof SubServer) || ((SubServer) server).isRunning()) {
Player target = (args.length > 2)?Bukkit.getPlayer(args[1]):null;
if (target != null || args.length == 2) {
if (target == null || target == sender || server.permits(sender, "subservers.server.%.*", "subservers.server.%.teleport-others")) {
if (target == null || target == sender || permits(server, sender, "subservers.server.%.*", "subservers.server.%.teleport-others")) {
if (target == null) target = (Player) sender;
sender.sendMessage(plugin.api.getLang("SubServers", "Command.Teleport").replace("$str$", target.getName()));
@ -870,7 +875,7 @@ public final class SubCommand extends BukkitCommand {
List<String>[] checks = permissions.toArray(new List[0]);
for (int p = 0; permitted && p < permissions.size(); p++) {
if (checks[p] == null || checks[p].size() <= 0) continue;
else permitted = server.permits(sender, checks[p].toArray(new String[0]));
else permitted = permits(server, sender, checks[p].toArray(new String[0]));
}
}

57
SubServers.Client/Common/pom.xml Normal file
View File

@ -0,0 +1,57 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>net.ME1312.SubServers</groupId>
<artifactId>SubServers.Client.Common</artifactId>
<version>-PLACEHOLDER</version>
<packaging>jar</packaging>
<repositories>
<repository>
<id>me1312-repo</id>
<url>https://dev.me1312.net/maven</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>net.ME1312.Galaxi</groupId>
<artifactId>GalaxiUtil</artifactId>
<version>20w33a</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>net.ME1312.SubData</groupId>
<artifactId>Client</artifactId>
<version>20w46b</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<directory>../../out/compile/target/SubServers.Client.Common</directory>
<sourceDirectory>src</sourceDirectory>
<resources>
<resource>
<directory>src</directory>
<excludes>
<exclude>**/*.java</exclude>
</excludes>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

391
SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/ClientAPI.java Normal file
View File

@ -0,0 +1,391 @@
package net.ME1312.SubServers.Client.Common;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataProtocol;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Common.Network.API.*;
import net.ME1312.SubServers.Client.Common.Network.Packet.*;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.util.*;
import static net.ME1312.SubServers.Client.Common.Network.API.SimplifiedData.*;
public abstract class ClientAPI {
private static ClientAPI api;
protected ClientAPI() {
api = this;
}
/**
* Gets the SubAPI Client Common Methods
*
* @return SubAPI Client Common
*/
public static ClientAPI getInstance() {
return api;
}
/**
* Get the Server Name
*
* @return Server Name
*/
public abstract String getName();
/**
* Gets the Hosts
*
* @param callback Host Map
*/
public void getHosts(Callback<Map<String, Host>> callback) {
requestHosts(null, callback);
}
/**
* Gets a Host
*
* @param name Host name
* @param callback a Host
*/
public void getHost(String name, Callback<Host> callback) {
requestHost(null, name, callback);
}
/**
* Gets the Server Groups (Group names are case sensitive here)
*
* @param callback Group Map
*/
public void getGroups(Callback<Map<String, List<Server>>> callback) {
requestGroups(null, callback);
}
/**
* Gets the Server Groups (Group names are all lowercase here)
*
* @param callback Group Map
*/
public void getLowercaseGroups(Callback<Map<String, List<Server>>> callback) {
requestLowercaseGroups(null, callback);
}
/**
* Gets a Server Group (Group names are case insensitive here)
*
* @param name Group name
* @param callback a Server Group
*/
public void getGroup(String name, Callback<NamedContainer<String, List<Server>>> callback) {
requestGroup(null, name, callback);
}
/**
* Gets the Servers (including SubServers)
*
* @param callback Server Map
*/
public void getServers(Callback<Map<String, Server>> callback) {
requestServers(null, callback);
}
/**
* Gets a Server
*
* @param name Server name
* @param callback a Server
*/
public void getServer(String name, Callback<Server> callback) {
requestServer(null, name, callback);
}
/**
* Adds a Server to the Network
*
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
*/
public void addServer(String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted, Callback<Integer> response) {
addServer(null, name, ip, port, motd, hidden, restricted, response);
}
/**
* Adds a Server to the Network
*
* @param player Player who added
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden If the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
*/
public void addServer(UUID player, String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) getSubDataNetwork()[0]).sendPacket(new PacketAddServer(player, name, ip, port, motd, hidden, restricted, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Adds a Server to the Network
*
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
*/
public void addServer(String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted) {
addServer(null, name, ip, port, motd, hidden, restricted);
}
/**
* Adds a Server to the Network
*
* @param player Player who added
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden If the server should be hidden from players
* @param restricted Players will need a permission to join if true
*/
public void addServer(UUID player, String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted) {
addServer(player, name, ip, port, motd, hidden, restricted, i -> {});
}
/**
* Remove a Server from the Network
*
* @param name Name of the Server
* @param response Response Code
*/
public void removeServer(String name, Callback<Integer> response) {
removeServer(null, name, response);
}
/**
* Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
* @param response Response Code
*/
public void removeServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, false, response);
}
/**
* Remove a Server from the Network
*
* @param name Name of the Server
*/
public void removeServer(String name) {
removeServer(null, name);
}
/**
* Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
*/
public void removeServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, i -> {});
}
/**
* Force Remove a Server from the Network
*
* @param name Name of the Server
* @param response Response Code
*/
public void forceRemoveServer(String name, Callback<Integer> response) {
forceRemoveServer(null, name, response);
}
/**
* Force Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
* @param response Response Code
*/
public void forceRemoveServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, true, response);
}
/**
* Force Remove a Server from the Network
*
* @param name Name of the Server
*/
public void forceRemoveServer(String name) {
forceRemoveServer(null, name);
}
/**
* Force Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
*/
public void forceRemoveServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
forceRemoveServer(player, name, i -> {});
}
private void removeServer(UUID player, String name, boolean force, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) getSubDataNetwork()[0]).sendPacket(new PacketRemoveServer(player, name, force, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Gets the SubServers
*
* @param callback SubServer Map
*/
public void getSubServers(Callback<Map<String, SubServer>> callback) {
requestSubServers(null, callback);
}
/**
* Gets a SubServer
*
* @param name SubServer name
* @param callback a SubServer
*/
public void getSubServer(String name, Callback<SubServer> callback) {
requestSubServer(null, name, callback);
}
/**
* Gets the known Proxies
*
* @param callback Proxy Map
*/
public void getProxies(Callback<Map<String, Proxy>> callback) {
requestProxies(null, callback);
}
/**
* Gets a Proxy
*
* @param name Proxy name
* @param callback a Proxy
*/
public void getProxy(String name, Callback<Proxy> callback) {
requestProxy(null, name, callback);
}
/**
* Get the Master Proxy Container
*
* @param callback Master Proxy
*/
public void getMasterProxy(Callback<Proxy> callback) {
requestMasterProxy(null, callback);
}
/**
* Gets players on this network across all known proxies
*
* @param callback Remote Player Collection
*/
public void getGlobalPlayers(Callback<Map<UUID, RemotePlayer>> callback) {
requestGlobalPlayers(null, callback);
}
/**
* Gets a player on this network by searching across all known proxies
*
* @param name Player name
* @param callback Remote Player
*/
public void getGlobalPlayer(String name, Callback<RemotePlayer> callback) {
requestGlobalPlayer(null, name, callback);
}
/**
* Gets a player on this network by searching across all known proxies
*
* @param id Player UUID
* @param callback Remote Player
*/
public void getGlobalPlayer(UUID id, Callback<RemotePlayer> callback) {
requestGlobalPlayer(null, id, callback);
}
/**
* Gets the SubData Network Connections
*
* @return SubData Network Connections
*/
public abstract DataClient[] getSubDataNetwork();
/**
* Gets the SubData Network Protocol
*
* @return SubData Network Protocol
*/
public abstract DataProtocol getSubDataProtocol();
/**
* Gets the current SubServers Lang Channels
*
* @return SubServers Lang Channel list
*/
public abstract Collection<String> getLangChannels();
/**
* Gets values from the SubServers Lang
*
* @param channel Lang Channel
* @return Lang Value
*/
public abstract Map<String, String> getLang(String channel);
/**
* Gets a value from the SubServers Lang
*
* @param channel Lang Channel
* @param key Key
* @return Lang Values
*/
public String getLang(String channel, String key) {
if (Util.isNull(channel, key)) throw new NullPointerException();
return getLang(channel).get(key);
}
}

8
SubServers.Host/src/net/ME1312/SubServers/Host/Network/API/Host.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/API/Host.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Host.Network.API;
package net.ME1312.SubServers.Client.Common.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
@ -10,8 +10,8 @@ import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Host.Network.Packet.*;
import net.ME1312.SubServers.Host.SubAPI;
import net.ME1312.SubServers.Client.Common.Network.Packet.*;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
@ -90,7 +90,7 @@ public class Host {
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) ClientAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
} else {
return new SubDataSender[0];

10
SubServers.Host/src/net/ME1312/SubServers/Host/Network/API/Proxy.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/API/Proxy.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Host.Network.API;
package net.ME1312.SubServers.Client.Common.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
@ -10,9 +10,9 @@ import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Host.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Host.Network.Packet.PacketDownloadProxyInfo;
import net.ME1312.SubServers.Host.SubAPI;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketDownloadProxyInfo;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
@ -80,7 +80,7 @@ public class Proxy {
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) ClientAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
}

19
SubServers.Host/src/net/ME1312/SubServers/Host/Network/API/RemotePlayer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/API/RemotePlayer.java
View File

@ -1,12 +1,12 @@
package net.ME1312.SubServers.Host.Network.API;
package net.ME1312.SubServers.Client.Common.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Host.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Host.SubAPI;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
@ -123,7 +123,7 @@ public class RemotePlayer {
};
if (proxy == null || !proxy.getName().equalsIgnoreCase(raw.getRawString("proxy"))) {
SubAPI.getInstance().getProxy(raw.getRawString("proxy"), proxy -> {
ClientAPI.getInstance().getProxy(raw.getRawString("proxy"), proxy -> {
this.proxy = proxy;
run.run();
});
@ -160,7 +160,7 @@ public class RemotePlayer {
};
if (server == null || !server.getName().equalsIgnoreCase(raw.getRawString("server"))) {
SubAPI.getInstance().getServer(raw.getRawString("server"), server -> {
ClientAPI.getInstance().getServer(raw.getRawString("server"), server -> {
this.server = server;
run.run();
});
@ -186,4 +186,13 @@ public class RemotePlayer {
public ObjectMap<String> getRaw() {
return raw.clone();
}
/**
* Get the raw representation of the Server
*
* @return Raw Server
*/
protected static ObjectMap<String> raw(RemotePlayer player) {
return player.raw;
}
}

10
SubServers.Sync/src/net/ME1312/SubServers/Sync/Network/API/Server.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/API/Server.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Sync.Network.API;
package net.ME1312.SubServers.Client.Common.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
@ -9,9 +9,9 @@ import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Sync.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Sync.Network.Packet.PacketDownloadServerInfo;
import net.ME1312.SubServers.Sync.SubAPI;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketDownloadServerInfo;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
@ -80,7 +80,7 @@ public class Server {
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) ClientAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
}

8
SubServers.Host/src/net/ME1312/SubServers/Host/Network/API/SimplifiedData.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/API/SimplifiedData.java
View File

@ -1,12 +1,12 @@
package net.ME1312.SubServers.Host.Network.API;
package net.ME1312.SubServers.Client.Common.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Host.Network.Packet.*;
import net.ME1312.SubServers.Host.SubAPI;
import net.ME1312.SubServers.Client.Common.Network.Packet.*;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
@ -17,7 +17,7 @@ import java.util.*;
public final class SimplifiedData {
private SimplifiedData() {}
static SubDataClient client(DataClient client) {
return (SubDataClient) ((client != null)? client : SubAPI.getInstance().getSubDataNetwork()[0]);
return (SubDataClient) ((client != null)? client : ClientAPI.getInstance().getSubDataNetwork()[0]);
}
/**

12
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/API/SubCreator.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/API/SubCreator.java
View File

@ -1,13 +1,13 @@
package net.ME1312.SubServers.Client.Bukkit.Network.API;
package net.ME1312.SubServers.Client.Common.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.PacketCreateServer;
import net.ME1312.SubServers.Client.Bukkit.Network.Packet.PacketUpdateServer;
import net.ME1312.SubServers.Client.Bukkit.SubAPI;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketCreateServer;
import net.ME1312.SubServers.Client.Common.Network.Packet.PacketUpdateServer;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
@ -135,7 +135,7 @@ public class SubCreator {
public void create(UUID player, String name, ServerTemplate template, Version version, Integer port, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketCreateServer(player, name, host.getName(), template.getName(), version, port, data -> {
((SubDataClient) ClientAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketCreateServer(player, name, host.getName(), template.getName(), version, port, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
@ -196,7 +196,7 @@ public class SubCreator {
public void update(UUID player, SubServer server, ServerTemplate template, Version version, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketUpdateServer(player, server.getName(), template.getName(), version, data -> {
((SubDataClient) ClientAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketUpdateServer(player, server.getName(), template.getName(), version, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {

8
SubServers.Host/src/net/ME1312/SubServers/Host/Network/API/SubServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/API/SubServer.java
View File

@ -1,11 +1,11 @@
package net.ME1312.SubServers.Host.Network.API;
package net.ME1312.SubServers.Client.Common.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubServers.Host.Network.Packet.*;
import net.ME1312.SubServers.Host.SubAPI;
import net.ME1312.SubServers.Client.Common.Network.Packet.*;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
@ -411,7 +411,7 @@ public class SubServer extends Server {
};
if (host == null || !host.getName().equalsIgnoreCase(raw.getRawString("host"))) {
SubAPI.getInstance().getHost(raw.getRawString("host"), host -> {
ClientAPI.getInstance().getHost(raw.getRawString("host"), host -> {
this.host = host;
run.run();
});

2
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketAddServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketAddServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Host.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketCommandServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketCommandServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

8
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketCreateServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketCreateServer.java
View File

@ -1,12 +1,12 @@
package net.ME1312.SubServers.Host.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;

2
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketDeleteServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketDeleteServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketDownloadGroupInfo.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketDownloadGroupInfo.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Host.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketDownloadHostInfo.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketDownloadHostInfo.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Sync/src/net/ME1312/SubServers/Sync/Network/Packet/PacketDownloadPlatformInfo.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketDownloadPlatformInfo.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Sync.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketDownloadPlayerInfo.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketDownloadPlayerInfo.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketDownloadProxyInfo.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketDownloadProxyInfo.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketDownloadServerInfo.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketDownloadServerInfo.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketEditServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketEditServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Host.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Sync/src/net/ME1312/SubServers/Sync/Network/Packet/PacketRemoveServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketRemoveServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Sync.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketRestartServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketRestartServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Sync/src/net/ME1312/SubServers/Sync/Network/Packet/PacketStartServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketStartServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Sync.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Client/Bukkit/src/net/ME1312/SubServers/Client/Bukkit/Network/Packet/PacketStopServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketStopServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Client.Bukkit.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

2
SubServers.Sync/src/net/ME1312/SubServers/Sync/Network/Packet/PacketUpdateServer.java → SubServers.Client/Common/src/net/ME1312/SubServers/Client/Common/Network/Packet/PacketUpdateServer.java
View File

@ -1,4 +1,4 @@
package net.ME1312.SubServers.Sync.Network.Packet;
package net.ME1312.SubServers.Client.Common.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;

11
SubServers.Client/Sponge/pom.xml
View File

@ -34,6 +34,13 @@
<scope>compile</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>net.ME1312.SubServers</groupId>
<artifactId>SubServers.Client.Common</artifactId>
<version>-PLACEHOLDER</version>
<scope>compile</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>net.ME1312.SubData</groupId>
<artifactId>Client</artifactId>
@ -130,6 +137,10 @@
<link>https://dev.me1312.net/jenkins/job/SubData/javadoc/Client/</link>
<link>https://jd.spongepowered.org/</link>
</links>
<includeDependencySources>true</includeDependencySources>
<dependencySourceIncludes>
<dependencySourceInclude>net.ME1312.SubServers:SubServers.Client.Common:*</dependencySourceInclude>
</dependencySourceIncludes>
</configuration>
</execution>
</executions>

1
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Event/SubAddProxyEvent.java
View File

@ -1,6 +1,5 @@
package net.ME1312.SubServers.Client.Sponge.Event;
import net.ME1312.SubServers.Client.Sponge.Library.SubEvent;
import net.ME1312.Galaxi.Library.Util;
import org.spongepowered.api.event.cause.Cause;

2
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Event/SubCreateEvent.java
View File

@ -4,7 +4,7 @@ import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.SubServers.Client.Sponge.Library.SubEvent;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Sponge.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import org.spongepowered.api.event.cause.Cause;
import org.spongepowered.api.event.impl.AbstractEvent;

2
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Event/SubCreatedEvent.java
View File

@ -4,7 +4,7 @@ import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.SubServers.Client.Sponge.Library.SubEvent;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Sponge.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import org.spongepowered.api.event.cause.Cause;
import org.spongepowered.api.event.impl.AbstractEvent;

1
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Event/SubStopEvent.java
View File

@ -1,6 +1,5 @@
package net.ME1312.SubServers.Client.Sponge.Event;
import net.ME1312.SubServers.Client.Sponge.Library.SubEvent;
import net.ME1312.Galaxi.Library.Util;
import org.spongepowered.api.event.cause.Cause;

4
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Graphic/UIRenderer.java
View File

@ -5,8 +5,8 @@ import net.ME1312.Galaxi.Library.Container.Container;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Sponge.Network.API.Host;
import net.ME1312.SubServers.Client.Sponge.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.Host;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Client.Sponge.SubPlugin;
import org.spongepowered.api.Sponge;
import org.spongepowered.api.item.ItemType;

104
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Library/ObjectPermission.java Normal file
View File

@ -0,0 +1,104 @@
package net.ME1312.SubServers.Client.Sponge.Library;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubServers.Client.Common.Network.API.Host;
import net.ME1312.SubServers.Client.Common.Network.API.Proxy;
import net.ME1312.SubServers.Client.Common.Network.API.Server;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import org.spongepowered.api.service.permission.Subject;
import java.util.List;
/**
* Object Permissions Class
*/
public class ObjectPermission {
private ObjectPermission() {}
/**
* Determine if an <i>object</i> can perform some action on this proxy using possible permissions
*
* @param proxy Proxy to check against
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the proxy name)
* @return Permission Check Result
*/
public static boolean permits(Proxy proxy, Subject object, String... permissions) {
return permits(proxy.getName(), object, permissions);
}
/**
* Determine if an <i>object</i> can perform some action on a host using possible permissions
*
* @param host Host to check against
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the host name)
* @return Permission Check Result
*/
public static boolean permits(Host host, Subject object, String... permissions) {
return permits(host.getName(), object, permissions);
}
/**
* Determine if an <i>object</i> can perform some action on another object using possible permissions
*
* @param string String to check against
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the object name)
* @return Permission Check Result
*/
private static boolean permits(String string, Subject object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all proxies & individual proxies permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", string.toLowerCase()));
}
}
return permitted;
}
/**
* Determine if an <i>object</i> can perform some action on a server using possible permissions
*
* @param server Server to check against
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the server name)
* @return Permission Check Result
*/
public static boolean permits(Server server, Subject object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all servers & individual servers permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", server.getName().toLowerCase()));
// Check all hosts & individual hosts permission
if (server instanceof SubServer) {
permitted = permitted || object.hasPermission(perm.replace("%", "::*"))
|| object.hasPermission(perm.replace("%", "::" + ((SubServer) server).getHost().toLowerCase()));
}
// Check all groups & individual groups permission
List<String> groups = server.getGroups();
if (groups.size() > 0) {
permitted = permitted || object.hasPermission(perm.replace("%", ":*"));
for (int g = 0; !permitted && g < groups.size(); g++) {
permitted = object.hasPermission(perm.replace("%", ":" + groups.get(g).toLowerCase()));
}
}
}
}
return permitted;
}
}

777
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/API/Host.java
View File

@ -1,777 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.*;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import org.spongepowered.api.service.permission.Subject;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.*;
/**
* Simplified Host Data Class
*/
public class Host {
HashMap<String, SubServer> servers = new HashMap<String, SubServer>();
private SubCreator creator;
private List<RemotePlayer> players = null;
ObjectMap<String> raw;
DataClient client;
long timestamp;
/**
* Create an API representation of a Host
*
* @param raw Raw representation of the Host
*/
public Host(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Host
*
* @param client SubData connection
* @param raw Raw representation of the Host
*/
Host(DataClient client, ObjectMap<String> raw) {
this.client = client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof Host && getSignature().equals(((Host) obj).getSignature());
}
private void load(ObjectMap<String> raw) {
this.raw = raw;
this.players = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
servers.clear();
this.creator = new SubCreator(this, raw.getMap("creator"));
for (String server : raw.getMap("servers").getKeys()) {
servers.put(server.toLowerCase(), new SubServer(this, raw.getMap("servers").getMap(server)));
}
}
private SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
String name = getName();
client().sendPacket(new PacketDownloadHostInfo(Collections.singletonList(name), data -> load(data.getMap(name))));
}
/**
* Gets the SubData Client Channel IDs
*
* @return SubData Client Channel ID Array (may be empty if unsupported)
*/
@SuppressWarnings("unchecked")
public DataSender[] getSubData() {
if (raw.contains("subdata")) {
ObjectMap<Integer> subdata = new ObjectMap<Integer>((Map<Integer, ?>) raw.getObject("subdata"));
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
} else {
return new SubDataSender[0];
}
}
/**
* Determine if an <i>object</i> can perform some action on this host using possible permissions
*
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the host name)
* @return Permission Check Result
*/
public boolean permits(Subject object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all proxies & individual proxies permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", this.getName().toLowerCase()));
}
}
return permitted;
}
/**
* Is this Host Available?
*
* @return Availability Status
*/
public boolean isAvailable() {
return raw.getBoolean("available");
}
/**
* Is this Host Enabled?
*
* @return Enabled Status
*/
public boolean isEnabled() {
return raw.getBoolean("enabled");
}
/**
* Get the Address of this Host
*
* @return Host Address
*/
public InetAddress getAddress() {
try {
return InetAddress.getByName(raw.getRawString("address"));
} catch (UnknownHostException e) {
throw new IllegalStateException("Invalid address response from raw data key: address");
}
}
/**
* Get the host Directory Path
*
* @return Host Directory Path
*/
public String getPath() {
return raw.getRawString("dir");
}
/**
* Get the Name of this Host
*
* @return Host Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Host
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Get players on servers provided by this host across all known proxies
*
* @return Remote Player Collection
*/
public Collection<NamedContainer<String, UUID>> getGlobalPlayers() {
List<NamedContainer<String, UUID>> players = new ArrayList<NamedContainer<String, UUID>>();
for (String id : raw.getMap("players").getKeys()) {
players.add(new NamedContainer<String, UUID>(raw.getMap("players").getRawString(id), UUID.fromString(id)));
}
return players;
}
/**
* Get the players on servers provided by this host across all known proxies
*
* @param callback Remote Player Collection
*/
public void getGlobalPlayers(Callback<Collection<RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (players == null) {
LinkedList<UUID> ids = new LinkedList<UUID>();
for (SubServer server : getSubServers().values()) for (NamedContainer<String, UUID> player : server.getGlobalPlayers()) ids.add(player.get());
client().sendPacket(new PacketDownloadPlayerInfo(ids, data -> {
LinkedList<RemotePlayer> players = new LinkedList<RemotePlayer>();
for (String player : data.getKeys()) {
players.add(new RemotePlayer(data.getMap(player)));
}
this.players = players;
run.run();
}));
} else {
run.run();
}
}
/**
* Starts the Servers Specified
*
* @param servers Servers
*/
public void start(String... servers) {
start(null, servers);
}
/**
* Starts the Servers Specified
*
* @param player Player who started
* @param servers Servers
*/
public void start(UUID player, String... servers) {
for (String server : servers) {
getSubServer(server.toLowerCase()).start(player);
}
}
/**
* Stops the Servers Specified
*
* @param servers Servers
*/
public void stop(String... servers) {
stop(null, servers);
}
/**
* Stops the Servers Specified
*
* @param player Player who started
* @param servers Servers
*/
public void stop(UUID player, String... servers) {
for (String server : servers) {
getSubServer(server.toLowerCase()).stop(player);
}
}
/**
* Terminates the Servers Specified
*
* @param servers Servers
*/
public void terminate(String... servers) {
terminate(null, servers);
}
/**
* Terminates the Servers Specified
*
* @param player Player who started
* @param servers Servers
*/
public void terminate(UUID player, String... servers) {
for (String server : servers) {
getSubServer(server.toLowerCase()).terminate(player);
}
}
/**
* Commands the Servers Specified
*
* @param command Command to send
* @param servers Servers
*/
public void command(String command, String... servers) {
command(null, command, servers);
}
/**
* Commands the Servers Specified
*
* @param player Player who started
* @param command Command to send
* @param servers Servers
* @return Success Status
*/
public void command(UUID player, String command, String... servers) {
for (String server : servers) {
getSubServer(server.toLowerCase()).command(player, command);
}
}
/**
* Gets the SubCreator Instance for this Host
*
* @return SubCreator
*/
public SubCreator getCreator() {
return creator;
}
/**
* Gets the SubServers on this Host
*
* @return SubServer Map
*/
public Map<String, ? extends SubServer> getSubServers() {
return new TreeMap<String, SubServer>(servers);
}
/**
* Gets a SubServer
*
* @param name SubServer Name
* @return a SubServer
*/
public SubServer getSubServer(String name) {
if (Util.isNull(name)) throw new NullPointerException();
return getSubServers().get(name.toLowerCase());
}
/**
* Adds a SubServer
*
* @param name Name of Server
* @param enabled Enabled Status
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
* @return The SubServer
*/
public void addSubServer(String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted, Callback<Integer> response) {
addSubServer(null, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted, response);
}
/**
* Adds a SubServer
*
* @param player Player adding
* @param name Name of Server
* @param enabled Enabled Status
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
* @return The SubServer
*/
public void addSubServer(UUID player, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketAddServer(player, name, enabled, getName(), port, motd, log, directory, executable, stopcmd, hidden, restricted, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Adds a SubServer
*
* @param name Name of Server
* @param enabled Enabled Status
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @return The SubServer
*/
public void addSubServer(String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) {
addSubServer(null, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
}
/**
* Adds a SubServer
*
* @param player Player adding
* @param name Name of Server
* @param enabled Enabled Status
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @return The SubServer
*/
public void addSubServer(UUID player, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) {
addSubServer(player, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted, i -> {});
}
/**
* Removes a SubServer
*
* @param name SubServer Name
*/
public void removeSubServer(String name) {
removeSubServer(null, name);
}
/**
* Removes a SubServer
*
* @param player Player Removing
* @param name SubServer Name
*/
public void removeSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
removeSubServer(player, name, false, i -> {});
}
/**
* Forces the Removal of a SubServer
*
* @param name SubServer Name
*/
public void forceRemoveSubServer(String name) {
forceRemoveSubServer(null, name);
}
/**
* Forces the Removal of a SubServer
*
* @param player Player Removing
* @param name SubServer Name
*/
public void forceRemoveSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
removeSubServer(player, name, true, i -> {});
}
/**
* Removes a SubServer
*
* @param name SubServer Name
* @param response Response Code
*/
public void removeSubServer(String name, Callback<Integer> response) {
removeSubServer(null, name, response);
}
/**
* Removes a SubServer
*
* @param player Player Removing
* @param name SubServer Name
* @param response Response Code
*/
public void removeSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeSubServer(player, name, false, response);
}
/**
* Forces the Removal of a SubServer
*
* @param name SubServer Name
* @param response Response Code
*/
public void forceRemoveSubServer(String name, Callback<Integer> response) {
forceRemoveSubServer(null, name, response);
}
/**
* Forces the Removal of a SubServer
*
* @param player Player Removing
* @param name SubServer Name
* @param response Response Code
*/
public void forceRemoveSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeSubServer(player, name, true, response);
}
private void removeSubServer(UUID player, String name, boolean force, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketRemoveServer(player, name, force, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Deletes a SubServer (will move to 'Recently Deleted')
*
* @param name SubServer Name
*/
public void recycleSubServer(String name) {
recycleSubServer(null, name);
}
/**
* Deletes a SubServer (will move to 'Recently Deleted')
*
* @param player Player Deleting
* @param name SubServer Name
*/
public void recycleSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, true, false, i -> {});
}
/**
* Forces the Deletion of a SubServer (will move to 'Recently Deleted')
*
* @param name SubServer Name
*/
public void forceRecycleSubServer(String name) {
forceRecycleSubServer(null, name);
}
/**
* Forces the Deletion of a SubServer (will move to 'Recently Deleted')
*
* @param player Player Deleting
* @param name SubServer Name
*/
public void forceRecycleSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, true, true, i -> {});
}
/**
* Deletes a SubServer (will move to 'Recently Deleted')
*
* @param name SubServer Name
* @param response Response Code
*/
public void recycleSubServer(String name, Callback<Integer> response) {
recycleSubServer(null, name, response);
}
/**
* Deletes a SubServer (will move to 'Recently Deleted')
*
* @param player Player Deleting
* @param name SubServer Name
* @param response Response Code
*/
public void recycleSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, true, false, response);
}
/**
* Forces the Deletion of a SubServer (will move to 'Recently Deleted')
*
* @param name SubServer Name
* @param response Response Code
*/
public void forceRecycleSubServer(String name, Callback<Integer> response) {
forceRecycleSubServer(null, name, response);
}
/**
* Forces the Deletion of a SubServer (will move to 'Recently Deleted')
*
* @param player Player Deleting
* @param name SubServer Name
* @param response Response Code
*/
public void forceRecycleSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, true, true, response);
}
/**
* Deletes a SubServer
*
* @param name SubServer Name
* @return Success Status
*/
public void deleteSubServer(String name) {
deleteSubServer(null, name);
}
/**
* Deletes a SubServer
*
* @param player Player Deleting
* @param name SubServer Name
* @return Success Status
*/
public void deleteSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, false, false, i -> {});
}
/**
* Forces the Deletion of a SubServer
*
* @param name SubServer Name
* @return Success Status
*/
public void forceDeleteSubServer(String name) {
forceDeleteSubServer(null, name);
}
/**
* Forces the Deletion of a SubServer
*
* @param player Player Deleting
* @param name SubServer Name
* @return Success Status
*/
public void forceDeleteSubServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, false, true, i -> {});
}
/**
* Deletes a SubServer
*
* @param name SubServer Name
* @return Success Status
*/
public void deleteSubServer(String name, Callback<Integer> response) {
deleteSubServer(null, name, response);
}
/**
* Deletes a SubServer
*
* @param player Player Deleting
* @param name SubServer Name
* @return Success Status
*/
public void deleteSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, false, false, response);
}
/**
* Forces the Deletion of a SubServer
*
* @param name SubServer Name
* @return Success Status
*/
public void forceDeleteSubServer(String name, Callback<Integer> response) {
forceDeleteSubServer(null, name, response);
}
/**
* Forces the Deletion of a SubServer
*
* @param player Player Deleting
* @param name SubServer Name
* @return Success Status
*/
public void forceDeleteSubServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
deleteSubServer(player, name, false, true, response);
}
private void deleteSubServer(UUID player, String name, boolean recycle, boolean force, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketDeleteServer(player, name, recycle, force, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Get the Signature of this Object
*
* @return Object Signature
*/
public final String getSignature() {
return raw.getRawString("signature");
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Determine if an extra value exists
*
* @param handle Handle
* @return Value Status
*/
public boolean hasExtra(String handle) {
if (Util.isNull(handle)) throw new NullPointerException();
return raw.getMap("extra").getKeys().contains(handle);
}
/**
* Get an extra value
*
* @param handle Handle
* @return Value
*/
public ObjectMapValue<String> getExtra(String handle) {
if (Util.isNull(handle)) throw new NullPointerException();
return raw.getMap("extra").get(handle);
}
/**
* Get the extra value section
*
* @return Extra Value Section
*/
public ObjectMap<String> getExtra() {
return raw.getMap("extra").clone();
}
/**
* Get the raw representation of the Host
*
* @return Raw Host
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

243
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/API/Proxy.java
View File

@ -1,243 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.PacketDownloadProxyInfo;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import org.spongepowered.api.service.permission.Subject;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
/**
* Simplified Proxy Data Class
*/
public class Proxy {
ObjectMap<String> raw;
private List<RemotePlayer> players = null;
DataClient client;
long timestamp;
/**
* Create an API representation of a Proxy
*
* @param raw Raw representation of the Proxy
*/
public Proxy(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Proxy
*
* @param client SubData connection
* @param raw Raw representation of the Proxy
*/
Proxy(DataClient client, ObjectMap<String> raw) {
this.client = client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof Proxy && getSignature().equals(((Proxy) obj).getSignature());
}
private void load(ObjectMap<String> raw) {
this.raw = raw;
this.players = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
}
private SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
String name = getName();
client().sendPacket(new PacketDownloadProxyInfo(Collections.singletonList(name), data -> load(data.getMap(name))));
}
/**
* Gets the SubData Client Channel IDs
*
* @return SubData Client Channel ID Array
*/
@SuppressWarnings("unchecked")
public DataSender[] getSubData() {
ObjectMap<Integer> subdata = new ObjectMap<Integer>((Map<Integer, ?>) raw.getObject("subdata"));
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
}
/**
* Determine if an <i>object</i> can perform some action on this proxy using possible permissions
*
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the proxy name)
* @return Permission Check Result
*/
public boolean permits(Subject object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all proxies & individual proxies permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", this.getName().toLowerCase()));
}
}
return permitted;
}
/**
* Get the Name of this Proxy
*
* @return Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Proxy
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Determine if the proxy is the Master Proxy
*
* @return Master Proxy Status
*/
public boolean isMaster() {
return raw.getBoolean("master");
}
/**
* Get the players on this proxy (via RedisBungee)
*
* @return Remote Player Collection
*/
public Collection<NamedContainer<String, UUID>> getPlayers() {
List<NamedContainer<String, UUID>> players = new ArrayList<NamedContainer<String, UUID>>();
for (String id : raw.getMap("players").getKeys()) {
players.add(new NamedContainer<String, UUID>(raw.getMap("players").getRawString(id), UUID.fromString(id)));
}
return players;
}
/**
* Get the players on this proxy (via RedisBungee)
*
* @param callback Remote Player Collection
*/
public void getPlayers(Callback<Collection<RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (players == null) {
LinkedList<UUID> ids = new LinkedList<UUID>();
for (String id : raw.getMap("players").getKeys()) ids.add(UUID.fromString(id));
client().sendPacket(new PacketDownloadPlayerInfo(ids, data -> {
LinkedList<RemotePlayer> players = new LinkedList<RemotePlayer>();
for (String player : data.getKeys()) {
players.add(new RemotePlayer(data.getMap(player)));
}
this.players = players;
run.run();
}));
} else {
run.run();
}
}
/**
* Get the Signature of this Object
*
* @return Object Signature
*/
public final String getSignature() {
return raw.getRawString("signature");
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Determine if an extra value exists
*
* @param handle Handle
* @return Value Status
*/
public boolean hasExtra(String handle) {
if (Util.isNull(handle)) throw new NullPointerException();
return raw.getMap("extra").getKeys().contains(handle);
}
/**
* Get an extra value
*
* @param handle Handle
* @return Value
*/
public ObjectMapValue<String> getExtra(String handle) {
if (Util.isNull(handle)) throw new NullPointerException();
return raw.getMap("extra").get(handle);
}
/**
* Get the extra value section
*
* @return Extra Value Section
*/
public ObjectMap<String> getExtra() {
return raw.getMap("extra").clone();
}
/**
* Get the raw representation of the Proxy
*
* @return Raw Proxy
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

187
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/API/RemotePlayer.java
View File

@ -1,187 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
import java.util.*;
/**
* Simplified RemotePlayer Data Class
*/
public class RemotePlayer {
ObjectMap<String> raw;
private Proxy proxy = null;
private Server server = null;
DataClient client;
long timestamp;
/**
* Create an API representation of a Remote Player
*
* @param raw Raw representation of the Remote Player
*/
public RemotePlayer(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Remote Player
*
* @param client SubData connection
* @param raw Raw representation of the Remote Player
*/
RemotePlayer(DataClient client, ObjectMap<String> raw) {
this.client = client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof RemotePlayer && getUniqueId().equals(((RemotePlayer) obj).getUniqueId());
}
void load(ObjectMap<String> raw) {
this.raw = raw;
this.proxy = null;
this.server = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
}
private SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
UUID id = getUniqueId();
client().sendPacket(new PacketDownloadPlayerInfo(Collections.singletonList(id), data -> load(data.getMap(id.toString()))));
}
/**
* Get the UUID of this player.
*
* @return the UUID
*/
public UUID getUniqueId() {
return raw.getUUID("id");
}
/**
* Get the unique name of this player.
*
* @return the players username
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Gets the remote address of this connection.
*
* @return the remote address
*/
public InetSocketAddress getAddress() {
return new InetSocketAddress(raw.getRawString("address").split(":")[0], Integer.parseInt(raw.getRawString("address").split(":")[1]));
}
/**
* Gets the proxy this player is connected to.
*
* @return the proxy this player is connected to
*/
public String getProxy() {
return raw.getRawString("proxy");
}
/**
* Gets the proxy this player is connected to.
*
* @param callback the proxy this player is connected to
*/
public void getProxy(Callback<Proxy> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(proxy);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (proxy == null || !proxy.getName().equalsIgnoreCase(raw.getRawString("proxy"))) {
SubAPI.getInstance().getProxy(raw.getRawString("proxy"), proxy -> {
this.proxy = proxy;
run.run();
});
} else {
run.run();
}
}
/**
* Gets the server this player is connected to.
*
* @return the server this player is connected to
*/
public String getServer() {
return raw.getRawString("server");
}
/**
* Gets the server this player is connected to.
*
* @param callback the server this player is connected to
*/
public void getServer(Callback<Server> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(server);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (server == null || !server.getName().equalsIgnoreCase(raw.getRawString("server"))) {
SubAPI.getInstance().getServer(raw.getRawString("server"), server -> {
this.server = server;
run.run();
});
} else {
run.run();
}
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Get the raw representation of the Server
*
* @return Raw Server
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

281
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/API/Server.java
View File

@ -1,281 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.PacketDownloadServerInfo;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import org.spongepowered.api.service.permission.Subject;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
import java.util.*;
/**
* Simplified Server Data Class
*/
public class Server {
ObjectMap<String> raw;
private List<RemotePlayer> players = null;
DataClient client;
long timestamp;
/**
* Create an API representation of a Server
*
* @param raw Raw representation of the Server
*/
public Server(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Server
*
* @param client SubData connection
* @param raw Raw representation of the Server
*/
Server(DataClient client, ObjectMap<String> raw) {
this.client = (SubDataClient) client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof Server && getSignature().equals(((Server) obj).getSignature());
}
void load(ObjectMap<String> raw) {
this.raw = raw;
this.players = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
}
SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
String name = getName();
client().sendPacket(new PacketDownloadServerInfo(Collections.singletonList(name), data -> load(data.getMap(name))));
}
/**
* Gets the SubData Client Channel IDs
*
* @return SubData Client Channel ID Array
*/
@SuppressWarnings("unchecked")
public DataSender[] getSubData() {
ObjectMap<Integer> subdata = new ObjectMap<Integer>((Map<Integer, ?>) raw.getObject("subdata"));
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
}
/**
* Determine if an <i>object</i> can perform some action on this server using possible permissions
*
* @param object Object to check against
* @param permissions Permissions to check (use <b>%</b> as a placeholder for the server name)
* @return Permission Check Result
*/
public boolean permits(Subject object, String... permissions) {
if (Util.isNull(object)) throw new NullPointerException();
boolean permitted = false;
for (int p = 0; !permitted && p < permissions.length; p++) {
String perm = permissions[p];
if (perm != null) {
// Check all servers & individual servers permission
permitted = object.hasPermission(perm.replace("%", "*"))
|| object.hasPermission(perm.replace("%", this.getName().toLowerCase()));
// Check all hosts & individual hosts permission
if (this instanceof SubServer) {
permitted = permitted || object.hasPermission(perm.replace("%", "::*"))
|| object.hasPermission(perm.replace("%", "::" + ((SubServer) this).getHost().toLowerCase()));
}
// Check all groups & individual groups permission
List<String> groups = this.getGroups();
if (groups.size() > 0) {
permitted = permitted || object.hasPermission(perm.replace("%", ":*"));
for (int g = 0; !permitted && g < groups.size(); g++) {
permitted = object.hasPermission(perm.replace("%", ":" + groups.get(g).toLowerCase()));
}
}
}
}
return permitted;
}
/**
* Get the Name of this Server
*
* @return Server Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Server
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Get the Address of this Server
*
* @return Server Address
*/
public InetSocketAddress getAddress() {
return new InetSocketAddress(raw.getRawString("address").split(":")[0], Integer.parseInt(raw.getRawString("address").split(":")[1]));
}
/**
* Get this Server's Groups
*
* @return Group names
*/
public List<String> getGroups() {
return new LinkedList<String>(raw.getRawStringList("group"));
}
/**
* Get players on this server across all known proxies
*
* @return Remote Player Collection
*/
public Collection<NamedContainer<String, UUID>> getGlobalPlayers() {
List<NamedContainer<String, UUID>> players = new ArrayList<NamedContainer<String, UUID>>();
for (String id : raw.getMap("players").getKeys()) {
players.add(new NamedContainer<String, UUID>(raw.getMap("players").getRawString(id), UUID.fromString(id)));
}
return players;
}
/**
* Get players on this server across all known proxies
*
* @param callback Remote Player Collection
*/
public void getGlobalPlayers(Callback<Collection<RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (players == null) {
LinkedList<UUID> ids = new LinkedList<UUID>();
for (String id : raw.getMap("players").getKeys()) ids.add(UUID.fromString(id));
client().sendPacket(new PacketDownloadPlayerInfo(ids, data -> {
LinkedList<RemotePlayer> players = new LinkedList<RemotePlayer>();
for (String player : data.getKeys()) {
players.add(new RemotePlayer(data.getMap(player)));
}
this.players = players;
run.run();
}));
} else {
run.run();
}
}
/**
* If the server is hidden from players
*
* @return Hidden Status
*/
public boolean isHidden() {
return raw.getBoolean("hidden");
}
/**
* Gets the MOTD of the Server
*
* @return Server MOTD
*/
public String getMotd() {
return raw.getRawString("motd");
}
/**
* Gets if the Server is Restricted
*
* @return Restricted Status
*/
public boolean isRestricted() {
return raw.getBoolean("restricted");
}
/**
* Get a copy of the current whitelist
*
* @return Player Whitelist
*/
public Collection<UUID> getWhitelist() {
return raw.getUUIDList("whitelist");
}
/**
* See if a player is whitelisted
*
* @param player Player to check
* @return Whitelisted Status
*/
public boolean isWhitelisted(UUID player) {
return getWhitelist().contains(player);
}
/**
* Get the Signature of this Object
*
* @return Object Signature
*/
public String getSignature() {
return raw.getRawString("signature");
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Get the raw representation of the Server
*
* @return Raw Server
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

400
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/API/SimplifiedData.java
View File

@ -1,400 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.*;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
/**
* Simplified Data Requesting Class
*/
public final class SimplifiedData {
private SimplifiedData() {}
static SubDataClient client(DataClient client) {
return (SubDataClient) ((client != null)? client : SubAPI.getInstance().getSubDataNetwork()[0]);
}
/**
* Requests the Hosts
*
* @param client SubData connection
* @param callback Host Map
*/
public static void requestHosts(DataClient client, Callback<Map<String, Host>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadHostInfo(null, data -> {
TreeMap<String, Host> hosts = new TreeMap<String, Host>();
for (String host : data.getKeys()) {
hosts.put(host.toLowerCase(), new Host(client, data.getMap(host)));
}
try {
callback.run(hosts);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a Host
*
* @param client SubData connection
* @param name Host name
* @param callback a Host
*/
public static void requestHost(DataClient client, String name, Callback<Host> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadHostInfo(Collections.singletonList(name), data -> {
Host host = null;
if (data.getKeys().size() > 0) {
host = new Host(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(host);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests the Server Groups (Group names are case sensitive here)
*
* @param client SubData connection
* @param callback Group Map
*/
public static void requestGroups(DataClient client, Callback<Map<String, List<Server>>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadGroupInfo(null, data -> {
TreeMap<String, List<Server>> groups = new TreeMap<String, List<Server>>();
for (String group : data.getKeys()) {
ArrayList<Server> servers = new ArrayList<Server>();
for (String server : data.getMap(group).getKeys()) {
if (data.getMap(group).getMap(server).getRawString("type", "Server").equals("SubServer")) {
servers.add(new SubServer(client, data.getMap(group).getMap(server)));
} else {
servers.add(new Server(client, data.getMap(group).getMap(server)));
}
}
if (servers.size() > 0) groups.put(group, servers);
}
try {
callback.run(groups);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests the Server Groups (Group names are all lowercase here)
*
* @param client SubData connection
* @param callback Group Map
*/
public static void requestLowercaseGroups(DataClient client, Callback<Map<String, List<Server>>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
requestGroups(client, groups -> {
TreeMap<String, List<Server>> lowercaseGroups = new TreeMap<String, List<Server>>();
for (String key : groups.keySet()) {
lowercaseGroups.put(key.toLowerCase(), groups.get(key));
}
callback.run(lowercaseGroups);
});
}
/**
* Requests a Server Group (Group names are case insensitive here)
*
* @param client SubData connection
* @param name Group name
* @param callback a Server Group
*/
public static void requestGroup(DataClient client, String name, Callback<NamedContainer<String, List<Server>>> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadGroupInfo(Collections.singletonList(name), data -> {
NamedContainer<String, List<Server>> group = null;
if (data.getKeys().size() > 0) {
String key = new LinkedList<String>(data.getKeys()).getFirst();
List<Server> servers = new ArrayList<Server>();
for (String server : data.getMap(key).getKeys()) {
if (data.getMap(key).getMap(server).getRawString("type", "Server").equals("SubServer")) {
servers.add(new SubServer(client, data.getMap(key).getMap(server)));
} else {
servers.add(new Server(client, data.getMap(key).getMap(server)));
}
}
group = new NamedContainer<>(key, servers);
}
try {
callback.run(group);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests the Servers (including SubServers)
*
* @param client SubData connection
* @param callback Server Map
*/
public static void requestServers(DataClient client, Callback<Map<String, Server>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadServerInfo(null, data -> {
TreeMap<String, Server> servers = new TreeMap<String, Server>();
for (String server : data.getKeys()) {
if (data.getMap(server).getRawString("type", "Server").equals("SubServer")) {
servers.put(server.toLowerCase(), new SubServer(client, data.getMap(server)));
} else {
servers.put(server.toLowerCase(), new Server(client, data.getMap(server)));
}
}
try {
callback.run(servers);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a Server
*
* @param client SubData connection
* @param name Server name
* @param callback a Server
*/
public static void requestServer(DataClient client, String name, Callback<Server> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadServerInfo(Collections.singletonList(name), data -> {
Server server = null;
if (data.getKeys().size() > 0) {
String key = new LinkedList<String>(data.getKeys()).getFirst();
if (data.getMap(key).getRawString("type", "Server").equals("SubServer")) {
server = new SubServer(client, data.getMap(key));
} else {
server = new Server(client, data.getMap(key));
}
}
try {
callback.run(server);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests the SubServers
*
* @param client SubData connection
* @param callback SubServer Map
*/
public static void requestSubServers(DataClient client, Callback<Map<String, SubServer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
requestServers(client, servers -> {
TreeMap<String, SubServer> subservers = new TreeMap<String, SubServer>();
for (String server : servers.keySet()) {
if (servers.get(server) instanceof SubServer) subservers.put(server, (SubServer) servers.get(server));
}
callback.run(subservers);
});
}
/**
* Requests a SubServer
*
* @param client SubData connection
* @param name SubServer name
* @param callback a SubServer
*/
public static void requestSubServer(DataClient client, String name, Callback<SubServer> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
requestServer(client, name, server -> callback.run((server instanceof SubServer)?(SubServer) server:null));
}
/**
* Requests the known Proxies
*
* @param client SubData connection
* @param callback Proxy Map
*/
public static void requestProxies(DataClient client, Callback<Map<String, Proxy>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadProxyInfo(null, data -> {
TreeMap<String, Proxy> proxies = new TreeMap<String, Proxy>();
for (String proxy : data.getKeys()) {
proxies.put(proxy.toLowerCase(), new Proxy(client, data.getMap(proxy)));
}
try {
callback.run(proxies);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a Proxy
*
* @param client SubData connection
* @param name Proxy name
* @param callback a Proxy
*/
public static void requestProxy(DataClient client, String name, Callback<Proxy> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadProxyInfo(Collections.singletonList(name), data -> {
Proxy proxy = null;
if (data.getKeys().size() > 0) {
proxy = new Proxy(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(proxy);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Request the Master Proxy redis container (null if unavailable)
*
* @param client SubData connection
* @param callback Master Proxy
*/
public static void requestMasterProxy(DataClient client, Callback<Proxy> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadProxyInfo(Collections.emptyList(), data -> {
Proxy proxy = null;
if (data.getKeys().size() > 0) {
proxy = new Proxy(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(proxy);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests players on this network across all known proxies
*
* @param client SubData connection
* @param callback Remote Player Collection
*/
public static void requestGlobalPlayers(DataClient client, Callback<Map<UUID, RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadPlayerInfo((List<UUID>) null, data -> {
TreeMap<UUID, RemotePlayer> players = new TreeMap<UUID, RemotePlayer>();
for (String player : data.getKeys()) {
players.put(UUID.fromString(player), new RemotePlayer(client, data.getMap(player)));
}
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a player on this network by searching across all known proxies
*
* @param client SubData connection
* @param name Player name
* @param callback Remote Player
*/
public static void requestGlobalPlayer(DataClient client, String name, Callback<RemotePlayer> callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadPlayerInfo(Collections.singletonList(name), data -> {
RemotePlayer player = null;
if (data.getKeys().size() > 0) {
player = new RemotePlayer(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(player);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Requests a player on this network by searching across all known proxies
*
* @param client SubData connection
* @param id Player UUID
* @param callback Remote Player
*/
public static void requestGlobalPlayer(DataClient client, UUID id, Callback<RemotePlayer> callback) {
if (Util.isNull(id, callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client(client).sendPacket(new PacketDownloadPlayerInfo(Collections.singletonList(id), data -> {
RemotePlayer player = null;
if (data.getKeys().size() > 0) {
player = new RemotePlayer(client, data.getMap(new LinkedList<String>(data.getKeys()).getFirst()));
}
try {
callback.run(player);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
}

293
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/API/SubCreator.java
View File

@ -1,293 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.PacketCreateServer;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.PacketUpdateServer;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.UUID;
/**
* Simplified SubCreator Data Class
*/
public class SubCreator {
HashMap<String, ServerTemplate> templates = new HashMap<String, ServerTemplate>();
Host host;
ObjectMap<String> raw;
SubCreator(Host host, ObjectMap<String> raw) {
this.host = host;
this.raw = raw;
for (String template : raw.getMap("templates").getKeys()) {
templates.put(template.toLowerCase(), new ServerTemplate(raw.getMap("templates").getMap(template)));
}
}
@Override
public boolean equals(Object obj) {
return obj instanceof SubCreator && host.getSignature().equals(((SubCreator) obj).host.getSignature());
}
public static class ServerTemplate {
private ObjectMap<String> raw;
private ServerType type;
public ServerTemplate(ObjectMap<String> raw) {
this.raw = raw;
this.type = Util.getDespiteException(() -> ServerType.valueOf(raw.getRawString("type").toUpperCase().replace('-', '_').replace(' ', '_')), ServerType.CUSTOM);
}
/**
* Get the Name of this Template
*
* @return Template Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Template
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Get the Enabled Status of this Template
*
* @return Enabled Status
*/
public boolean isEnabled() {
return raw.getBoolean("enabled");
}
/**
* Get the Item Icon for this Template
*
* @return Item Icon Name/ID
*/
public String getIcon() {
return raw.getString("icon");
}
/**
* Get the Type of this Template
*
* @return Template Type
*/
public ServerType getType() {
return type;
}
/**
* Get whether this Template requires the Version argument
*
* @return Version Requirement
*/
public boolean requiresVersion() {
return raw.getBoolean("version-req");
}
/**
* Get whether this Template can be used to update it's servers
*
* @return Updatable Status
*/
public boolean canUpdate() {
return raw.getBoolean("can-update");
}
}
public enum ServerType {
SPIGOT,
VANILLA,
FORGE,
SPONGE,
CUSTOM;
@Override
public String toString() {
return super.toString().substring(0, 1).toUpperCase()+super.toString().substring(1).toLowerCase();
}
}
/**
* Create a SubServer
*
* @param player Player Creating
* @param name Server Name
* @param template Server Template
* @param version Server Version (may be null)
* @param port Server Port Number (null to auto-select)
* @param response Response Code
*/
public void create(UUID player, String name, ServerTemplate template, Version version, Integer port, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketCreateServer(player, name, host.getName(), template.getName(), version, port, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Create a SubServer
*
* @param name Server Name
* @param template Server Template
* @param version Server Version (may be null)
* @param port Server Port Number (null to auto-select)
* @param response Response Code
*/
public void create(String name, ServerTemplate template, Version version, Integer port, Callback<Integer> response) {
create(null, name, template, version, port, response);
}
/**
* Create a SubServer
*
* @param player Player Creating
* @param name Server Name
* @param template Server Template
* @param version Server Version (may be null)
* @param port Server Port Number (null to auto-select)
*/
public void create(UUID player, String name, ServerTemplate template, Version version, Integer port) {
create(player, name, template, version, port, i -> {});
}
/**
* Create a SubServer
*
* @param name Server Name
* @param template Server Template
* @param version Server Version (may be null)
* @param port Server Port Number (null to auto-select)
*/
public void create(String name, ServerTemplate template, Version version, Integer port) {
create(name, template, version, port, i -> {});
}
/**
* Update a SubServer
*
* @param player Player Updating
* @param server Server to Update
* @param template Server Template
* @param version Server Version (may be null)
* @param response Response Code
*/
public void update(UUID player, SubServer server, ServerTemplate template, Version version, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketUpdateServer(player, server.getName(), template.getName(), version, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
};
/**
* Update a SubServer
*
* @param player Player Updating
* @param server Server to Update
* @param template Server Template
* @param version Server Version (may be null)
*/
public void update(UUID player, SubServer server, ServerTemplate template, Version version) {
update(player, server, template, version, null);
}
/**
* Update a SubServer
*
* @param server Server to Update
* @param template Server Template
* @param version Server Version (may be null)
* @param response Response Code
*/
public void update(SubServer server, ServerTemplate template, Version version, Callback<Integer> response) {
update(null, server, template, version, response);
}
/**
* Update a SubServer
*
* @param server Server to Update
* @param template Server Template
* @param version Server Version (may be null)
*/
public void update(SubServer server, ServerTemplate template, Version version) {
update(null, server, template, version);
}
/**
* Update a SubServer
*
* @param player Player Updating
* @param server Server to Update
* @param version Server Version (may be null)
*/
public void update(UUID player, SubServer server, Version version) {
update(player, server, null, version);
}
/**
* Update a SubServer
*
* @param server Server to Update
* @param version Server Version (may be null)
*/
public void update(SubServer server, Version version) {
update(null, server, version);
}
/**
* Gets the host this creator belongs to
*
* @return Host
*/
public Host getHost() {
return host;
}
/**
* Gets the Templates that can be used in this SubCreator instance
*
* @return Template Map
*/
public Map<String, ServerTemplate> getTemplates() {
return new TreeMap<String, ServerTemplate>(templates);
}
/**
* Gets a SubCreator Template by name
*
* @param name Template Name
* @return Template
*/
public ServerTemplate getTemplate(String name) {
return getTemplates().get(name.toLowerCase());
}
}

947
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/API/SubServer.java
View File

@ -1,947 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.*;
import net.ME1312.SubServers.Client.Sponge.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
/**
* Simplified SubServer Data Class
*/
public class SubServer extends Server {
private List<SubServer> incompatibilities = null;
private List<SubServer> currentIncompatibilities = null;
private Host host = null;
/**
* SubServer Stop Action Class
*/
public enum StopAction {
NONE,
RESTART,
REMOVE_SERVER,
RECYCLE_SERVER,
DELETE_SERVER;
@Override
public String toString() {
return super.toString().substring(0, 1).toUpperCase()+super.toString().substring(1).toLowerCase().replace('_', ' ');
}
}
/**
* Create an API representation of a SubServer
*
* @param raw JSON representation of the SubServer
*/
public SubServer(ObjectMap<String> raw) {
super(null, raw);
}
/**
* Create an API representation of a SubServer
*
* @param client SubData connection
* @param raw JSON representation of the SubServer
*/
SubServer(DataClient client, ObjectMap<String> raw) {
super(client, raw);
}
/**
* Create an API representation of a SubServer
*
* @param host Host
* @param raw JSON representation of the SubServer
*/
SubServer(Host host, ObjectMap<String> raw) {
super(host.client, raw);
this.host = host;
}
@Override
public boolean equals(Object obj) {
return obj instanceof SubServer && super.equals(obj);
}
@Override
public void refresh() {
host = null;
incompatibilities = null;
currentIncompatibilities = null;
super.refresh();
}
/**
* Starts the Server
*
* @param player Player who Started
* @param response Response Code
*/
public void start(UUID player, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketStartServer(player, getName(), data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Starts the Server
*
* @param response Response Code
*/
public void start(Callback<Integer> response) {
start(null, response);
}
/**
* Starts the Server
*
* @param player Player who Started
*/
public void start(UUID player) {
start(player, i -> {});
}
/**
* Starts the Server
*/
public void start() {
start(i -> {});
}
/**
* Stops the Server
*
* @param player Player who Stopped
* @param response Response Code
*/
public void stop(UUID player, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketStopServer(player, getName(), false, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Stops the Server
*
* @param response Response Code
*/
public void stop(Callback<Integer> response) {
stop(null, response);
}
/**
* Stops the Server
*
* @param player Player who Stopped
*/
public void stop(UUID player) {
stop(player, i -> {});
}
/**
* Stops the Server
*/
public void stop() {
stop(i -> {});
}
/**
* Terminates the Server
*
* @param player Player who Terminated
* @param response Response Code
*/
public void terminate(UUID player, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketStopServer(player, getName(), true, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Terminates the Server
*
* @param response Response Code
*/
public void terminate(Callback<Integer> response) {
terminate(null, response);
}
/**
* Terminates the Server
*
* @param player Player who Terminated
*/
public void terminate(UUID player) {
terminate(player, i -> {});
}
/**
* Terminates the Server
*/
public void terminate() {
terminate(i -> {});
}
/**
* Commands the Server
*
* @param player Player who Commanded
* @param command Commmand to Send
* @param response Response Code
*/
public void command(UUID player, String command, Callback<Integer> response) {
if (Util.isNull(command, response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketCommandServer(player, getName(), command, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Commands the Server
*
* @param command Commmand to Send
* @param response Response Code
*/
public void command(String command, Callback<Integer> response) {
command(null, command, response);
}
/**
* Commands the Server
*
* @param player Player who Commanded
* @param command Command to Send
*/
public void command(UUID player, String command) {
command(player, command, i -> {});
}
/**
* Commands the Server
*
* @param command Command to Send
*/
public void command(String command) {
command(command, i -> {});
}
/**
* Edits the Server
*
* @param player Player Editing
* @param edit Edits
* @param response Negative Response Code -or- Positive Success Status
*/
public void edit(UUID player, ObjectMap<String> edit, Callback<Integer> response) {
edit(player, edit, false, response);
}
/**
* Edits the Server
*
* @param edit Edits
* @param response Negative Response Code -or- Positive Success Status
*/
public void edit(ObjectMap<String> edit, Callback<Integer> response) {
edit(null, edit, response);
}
/**
* Edits the Server
*
* @param player Player Editing
* @param edit Edits
*/
public void edit(UUID player, ObjectMap<String> edit) {
edit(player, edit, i -> {});
}
/**
* Edits the Server
*
* @param edit Edits
*/
public void edit(ObjectMap<String> edit) {
edit(null, edit);
}
/**
* Edits the Server (& Saves Changes)
*
* @param player Player Editing
* @param edit Edits
* @param response Negative Response Code -or- Positive Success Status
*/
public void permaEdit(UUID player, ObjectMap<String> edit, Callback<Integer> response) {
edit(player, edit, true, response);
}
/**
* Edits the Server (& Saves Changes)
*
* @param edit Edits
* @param response Negative Response Code -or- Positive Success Status
*/
public void permaEdit(ObjectMap<String> edit, Callback<Integer> response) {
permaEdit(null, edit, response);
}
/**
* Edits the Server (& Saves Changes)
*
* @param player Player Editing
* @param edit Edits
*/
public void permaEdit(UUID player, ObjectMap<String> edit) {
permaEdit(player, edit, i -> {});
}
/**
* Edits the Server (& Saves Changes)
*
* @param edit Edits
*/
public void permaEdit(ObjectMap<String> edit) {
permaEdit(null, edit);
}
private void edit(UUID player, ObjectMap<String> edit, boolean perma, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
client().sendPacket(new PacketEditServer(player, getName(), edit, perma, data -> {
try {
if (data.getInt(0x0001) != 0) {
response.run(data.getInt(0x0001) * -1);
} else {
response.run(data.getInt(0x0002));
}
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* If the Server is Running
*
* @return Running Status
*/
public boolean isRunning() {
return raw.getBoolean("running");
}
/**
* If the Server is Online<br>
* <b>This method can only be true when a SubData connection is made!</b>
*
* @return Online Status
*/
public boolean isOnline() {
return raw.getBoolean("online");
}
/**
* Grabs the Host of the Server
*
* @return The Host Name
*/
public String getHost() {
return raw.getRawString("host");
}
/**
* Grabs the Host of the Server
*
* @param callback The Host
*/
public void getHost(Callback<Host> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(host);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (host == null || !host.getName().equalsIgnoreCase(raw.getRawString("host"))) {
SubAPI.getInstance().getHost(raw.getRawString("host"), host -> {
this.host = host;
run.run();
});
} else {
run.run();
}
}
/**
* Grabs the Template this Server was created from
*
* @return The Template
*/
public String getTemplate() {
return raw.getRawString("template");
}
/**
* Is this Server Available?
*
* @return Availability Status
*/
public boolean isAvailable() {
return raw.getBoolean("available");
}
/**
* If the Server is Enabled
*
* @return Enabled Status
*/
public boolean isEnabled() {
return raw.getBoolean("enabled");
}
/**
* Set if the Server is Enabled
*
* @param value Value
*/
public void setEnabled(boolean value) {
setEnabled(value, b -> {});
}
/**
* Set if the Server is Enabled
*
* @param value Value
* @param response Success Status
*/
public void setEnabled(boolean value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("enabled", value);
edit(edit, r -> {
if (r > 0) raw.set("enabled", value);
response.run(r > 0);
});
}
/**
* If the Server is accepting requests to edit()
*
* @return Edit Status
*/
public boolean isEditable() {
return raw.getBoolean("editable");
}
/**
* If the Server is Logging
*
* @return Logging Status
*/
public boolean isLogging() {
return raw.getBoolean("log");
}
/**
* Set if the Server is Logging
*
* @param value Value
*/
public void setLogging(boolean value) {
setLogging(value, b -> {});
}
/**
* Set if the Server is Logging
*
* @param value Value
* @param response Success Status
*/
public void setLogging(boolean value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("log", value);
edit(edit, r -> {
if (r > 0) raw.set("log", value);
response.run(r > 0);
});
}
/**
* Get the Server Directory Path
*
* @return Server Directory Path
*/
public String getPath() {
return raw.getRawString("dir");
}
/**
* Get the Server's Executable String
*
* @return Executable String
*/
public String getExecutable() {
return raw.getRawString("exec");
}
/**
* Grab the Command to Stop the Server
*
* @return Stop Command
*/
public String getStopCommand() {
return raw.getRawString("stop-cmd");
}
/**
* Set the Command that Stops the Server
*
* @param value Value
*/
public void setStopCommand(String value) {
setStopCommand(value, b -> {});
}
/**
* Set the Command that Stops the Server
*
* @param value Value
* @param response Success Status
*/
public void setStopCommand(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("stop-cmd", value);
edit(edit, r -> {
if (r > 0) raw.set("stop-cmd", value);
response.run(r > 0);
});
}
/**
* Get the action the Server will take when it stops
*
* @return Stop Action
*/
public StopAction getStopAction() {
return Util.getDespiteException(() -> StopAction.valueOf(raw.getRawString("stop-action").toUpperCase().replace('-', '_').replace(' ', '_')), StopAction.NONE);
}
/**
* Set the action the Server will take when it stops
*
* @param action Stop Action
*/
public void setStopAction(StopAction action) {
setStopAction(action, b -> {});
}
/**
* Set the action the Server will take when it stops
*
* @param action Stop Action
* @param response Success Status
*/
public void setStopAction(StopAction action, Callback<Boolean> response) {
if (Util.isNull(action, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("stop-action", action.toString());
edit(edit, r -> {
if (r > 0) raw.set("stop-action", action.toString());
response.run(r > 0);
});
}
/**
* Toggles compatibility with other Servers
*
* @param server SubServer to toggle
*/
public void toggleCompatibility(String server) {
toggleCompatibility(server, b -> {});
}
/**
* Toggles compatibility with other Servers
*
* @param server SubServer to toggle
*/
public void toggleCompatibility(String server, Callback<Boolean> response) {
if (Util.isNull(server, response)) throw new NullPointerException();
ArrayList<String> value = new ArrayList<String>();
value.addAll(getIncompatibilities());
if (!value.contains(server)) value.add(server);
else value.remove(server);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("incompatible", value);
edit(edit, r -> {
if (r > 0) raw.set("incompatible", value);
response.run(r > 0);
});
}
/**
* Checks if a Server is compatible
*
* @param server Server name to check
* @return Compatible Status
*/
public boolean isCompatible(String server) {
LinkedList<String> lowercaseIncompatibilities = new LinkedList<String>();
for (String key : getIncompatibilities()) {
lowercaseIncompatibilities.add(key.toLowerCase());
}
return lowercaseIncompatibilities.contains(server.toLowerCase());
}
/**
* Get all listed incompatibilities for this Server
*
* @return Incompatibility List
*/
public List<String> getIncompatibilities() {
return new LinkedList<String>(raw.getRawStringList("incompatible-list"));
}
/**
* Get all listed incompatibilities for this Server
*
* @param callback Incompatibility List
*/
public void getIncompatibilities(Callback<List<SubServer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(incompatibilities);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (incompatibilities == null) {
LinkedList<String> incompatible = new LinkedList<String>();
for (String subserver : raw.getRawStringList("incompatible-list")) incompatible.add(subserver.toLowerCase());
client().sendPacket(new PacketDownloadServerInfo(incompatible, data -> {
LinkedList<SubServer> incompatibilities = new LinkedList<SubServer>();
for (String server : data.getKeys()) {
if (data.getMap(server).getRawString("type", "Server").equals("SubServer")) incompatibilities.add(new SubServer(data.getMap(server)));
}
this.incompatibilities = incompatibilities;
run.run();
}));
} else {
run.run();
}
}
/**
* Get incompatibility issues this server currently has
*
* @return Current Incompatibility List
*/
public List<String> getCurrentIncompatibilities() {
return new LinkedList<String>(raw.getRawStringList("incompatible"));
}
/**
* Get incompatibility issues this server currently has
*
* @param callback Current Incompatibility List
*/
public void getCurrentIncompatibilities(Callback<List<SubServer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(currentIncompatibilities);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (currentIncompatibilities == null) {
LinkedList<String> incompatible = new LinkedList<String>();
for (String subserver : raw.getRawStringList("incompatible")) incompatible.add(subserver.toLowerCase());
client().sendPacket(new PacketDownloadServerInfo(incompatible, data -> {
LinkedList<SubServer> incompatibilities = new LinkedList<SubServer>();
for (String server : data.getKeys()) {
if (data.getMap(server).getRawString("type", "Server").equals("SubServer")) incompatibilities.add(new SubServer(data.getMap(server)));
}
this.currentIncompatibilities = incompatibilities;
run.run();
}));
} else {
run.run();
}
}
/**
* Sets the Display Name for this Server
*
* @param value Value (or null to reset)
*/
public void setDisplayName(String value) {
setMotd(value, b -> {});
}
/**
* Sets the Display Name for this Server
*
* @param value Value (or null to reset)
* @param response Success Status
*/
public void setDisplayName(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("display", (value == null)?"":value);
edit(edit, r -> {
if (r > 0) raw.set("display", (value == null)?getName():value);
response.run(r > 0);
});
}
/**
* Add this Server to a Group
*
* @param value Group name
*/
public void addGroup(String value) {
addGroup(value, b -> {});
}
/**
* Add this Server to a Group
*
* @param value Group name
* @param response Success Status
*/
public void addGroup(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ArrayList<String> v = new ArrayList<String>();
v.addAll(getGroups());
if (!v.contains(value)) v.add(value);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("group", v);
edit(edit, r -> {
if (r > 0) raw.set("group", v);
response.run(r > 0);
});
}
/**
* Remove this Server from a Group
*
* @param value value Group name
*/
public void removeGroup(String value) {
removeGroup(value, b -> {});
}
/**
* Remove this Server from a Group
*
* @param value value Group name
* @param response Success Status
*/
public void removeGroup(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ArrayList<UUID> v = new ArrayList<UUID>();
v.addAll(getWhitelist());
v.remove(value);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("group", v);
edit(edit, r -> {
if (r > 0) raw.set("group", v);
response.run(r > 0);
});
}
/**
* Set if the server is hidden from players
*
* @param value Value
*/
public void setHidden(boolean value) {
setHidden(value, b -> {});
}
/**
* Set if the server is hidden from players
*
* @param value Value
* @param response Success Status
*/
public void setHidden(boolean value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("restricted", value);
edit(edit, r -> {
if (r > 0) raw.set("restricted", value);
response.run(r > 0);
});
}
/**
* Sets the MOTD of the Server
*
* @param value Value
*/
public void setMotd(String value) {
setMotd(value, b -> {});
}
/**
* Sets the MOTD of the Server
*
* @param value Value
* @param response Success Status
*/
public void setMotd(String value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("motd", value);
edit(edit, r -> {
if (r > 0) raw.set("motd", value);
response.run(r > 0);
});
}
/**
* Sets if the Server is Restricted
*
* @param value Value
*/
public void setRestricted(boolean value) {
setRestricted(value, b -> {});
}
/**
* Sets if the Server is Restricted
*
* @param value Value
* @param response Success Status
*/
public void setRestricted(boolean value, Callback<Boolean> response) {
if (Util.isNull(value, response)) throw new NullPointerException();
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("restricted", value);
edit(edit, r -> {
if (r > 0) raw.set("restricted", value);
response.run(r > 0);
});
}
/**
* Add a player to the whitelist (for use with restricted servers)
*
* @param player Player to add
*/
public void whitelist(UUID player) {
whitelist(player, b -> {});
}
/**
* Add a player to the whitelist (for use with restricted servers)
*
* @param player Player to add
* @param response Success Status
*/
public void whitelist(UUID player, Callback<Boolean> response) {
if (Util.isNull(player, response)) throw new NullPointerException();
ArrayList<UUID> value = new ArrayList<UUID>();
value.addAll(getWhitelist());
if (!value.contains(player)) value.add(player);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("whitelist", value);
edit(edit, r -> {
if (r > 0) raw.set("whitelist", value);
response.run(r > 0);
});
}
/**
* Remove a player to the whitelist
*
* @param player Player to remove
*/
public void unwhitelist(UUID player) {
unwhitelist(player, b -> {});
}
/**
* Remove a player to the whitelist
*
* @param player Player to remove
* @param response Success Status
*/
public void unwhitelist(UUID player, Callback<Boolean> response) {
if (Util.isNull(player, response)) throw new NullPointerException();
ArrayList<UUID> value = new ArrayList<UUID>();
value.addAll(getWhitelist());
value.remove(player);
ObjectMap<String> edit = new ObjectMap<String>();
edit.set("whitelist", value);
edit(edit, r -> {
if (r > 0) raw.set("whitelist", value);
response.run(r > 0);
});
}
}

123
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketAddServer.java
View File

@ -1,123 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.net.InetAddress;
import java.util.HashMap;
import java.util.UUID;
/**
* Add Server Packet
*/
public class PacketAddServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String name;
private ObjectMap<String> opt;
private boolean subserver;
private UUID tracker;
/**
* New PacketAddServer (In)
*/
public PacketAddServer() {}
/**
* New PacketCreateServer [Server] (Out)
*
* @param player Player who added
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden If the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param callback Callbacks
*/
@SafeVarargs
public PacketAddServer(UUID player, String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(name, ip, port, motd, hidden, restricted)) throw new NullPointerException();
this.player = player;
this.name = name;
this.subserver = false;
ObjectMap<String> opt = new ObjectMap<String>();
opt.set("address", ip.getHostAddress() + ':' + port);
opt.set("motd", motd);
opt.set("restricted", restricted);
opt.set("hidden", hidden);
this.opt = opt;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
/**
* New PacketAddServer [SubServer] (Out)
*
* @param player Player who Added
* @param name Name of Server
* @param enabled Enabled Status
* @param host Host of Server
* @param port Port Number
* @param motd Motd of the Server
* @param log Logging Status
* @param directory Directory
* @param executable Executable String
* @param stopcmd Command to Stop the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param callback Callbacks
*/
@SafeVarargs
public PacketAddServer(UUID player, String name, boolean enabled, String host, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(host, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted)) throw new NullPointerException();
this.player = player;
this.name = name;
this.subserver = true;
ObjectMap<String> opt = new ObjectMap<String>();
opt.set("enabled", enabled);
opt.set("host", host);
opt.set("port", port);
opt.set("motd", motd);
opt.set("log", log);
opt.set("dir", directory);
opt.set("exec", executable);
opt.set("stop-cmd", stopcmd);
opt.set("restricted", restricted);
opt.set("hidden", hidden);
this.opt = opt;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, name);
data.set(0x0002, subserver);
data.set(0x0003, opt);
if (player != null) data.set(0x0004, player);
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

66
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketCommandServer.java
View File

@ -1,66 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Command Server Packet
*/
public class PacketCommandServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private String command;
private UUID tracker;
/**
* New PacketCommandServer (In)
*/
public PacketCommandServer() {}
/**
* New PacketCommandServer (Out)
*
* @param player Player Sending
* @param server Server to send to
* @param command Command to send
* @param callback Callbacks
*/
@SafeVarargs
public PacketCommandServer(UUID player, String server, String command, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, command, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.command = command;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, command);
if (player != null) data.set(0x0003, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

135
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketCreateServer.java
View File

@ -1,135 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Client.Sponge.Graphic.UIRenderer;
import java.util.HashMap;
import java.util.UUID;
/**
* Create Server Packet
*/
public class PacketCreateServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String name;
private String host;
private String template;
private Version version;
private Integer port;
private boolean waitfor;
private UUID tracker;
/**
* New PacketCreateServer (In)
*/
public PacketCreateServer() {}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param name Server Name
* @param host Host to use
* @param template Server Template
* @param version Server Version
* @param port Server Port
* @param callback Callbacks
*/
@SafeVarargs
public PacketCreateServer(UUID player, String name, String host, String template, Version version, Integer port, Callback<ObjectMap<Integer>>... callback) {
this(player, name, host, template, version, port, false, callback);
}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param name Server Name
* @param host Host to use
* @param template Server Template
* @param version Server Version
* @param port Server Port
* @param waitfor Wait until completion to send callback
* @param callback Callbacks
*/
@SafeVarargs
public PacketCreateServer(UUID player, String name, String host, String template, Version version, Integer port, boolean waitfor, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(name, host, template, callback)) throw new NullPointerException();
this.player = player;
this.name = name;
this.host = host;
this.template = template;
this.version = version;
this.port = port;
this.waitfor = waitfor;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param options Creator UI Options
* @param callback Callbacks
*/
@SafeVarargs
public PacketCreateServer(UUID player, UIRenderer.CreatorOptions options, Callback<ObjectMap<Integer>>... callback) {
this(player, options, false, callback);
}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param options Creator UI Options
* @param waitfor Wait until completion to send callback
* @param callback Callbacks
*/
@SafeVarargs
public PacketCreateServer(UUID player, UIRenderer.CreatorOptions options, boolean waitfor, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(options, callback)) throw new NullPointerException();
this.player = player;
this.name = options.getName();
this.host = options.getHost();
this.template = options.getTemplate();
this.version = options.getVersion();
this.port = options.getPort();
this.waitfor = waitfor;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, name);
data.set(0x0002, host);
data.set(0x0003, template);
if (version != null) data.set(0x0004, version);
if (port != null) data.set(0x0005, port);
if (player != null) data.set(0x0006, player);
if (waitfor) data.set(0x0007, true);
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

61
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketDownloadGroupInfo.java
View File

@ -1,61 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Download Group Info Packet
*/
public class PacketDownloadGroupInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private List<String> groups;
private UUID tracker;
/**
* New PacketDownloadGroupInfo (In)
*/
public PacketDownloadGroupInfo() {}
/**
* New PacketDownloadGroupInfo (Out)
*
* @param groups Group names (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadGroupInfo(List<String> groups, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.groups = groups;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (groups != null) json.set(0x0001, groups);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

50
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketDownloadPlatformInfo.java
View File

@ -1,50 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* Download Proxy Info Packet
*/
public class PacketDownloadPlatformInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private UUID tracker;
/**
* New PacketDownloadPlatformInfo
*
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadPlatformInfo(Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
return data;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

74
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketDownloadPlayerInfo.java
View File

@ -1,74 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.*;
/**
* Download Player Info Packet
*/
public class PacketDownloadPlayerInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private Collection<String> names;
private Collection<UUID> ids;
private UUID tracker;
/**
* New PacketDownloadPlayerInfo (In)
*/
public PacketDownloadPlayerInfo() {}
/**
* New PacketDownloadPlayerInfo (Out)
*
* @param players Player Names (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadPlayerInfo(Collection<String> players, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.names = players;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
/**
* New PacketDownloadPlayerInfo (Out)
*
* @param players Player IDs (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadPlayerInfo(List<UUID> players, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.ids = players;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (names != null) json.set(0x0001, names);
if (ids != null) json.set(0x0002, ids);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

67
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketDownloadProxyInfo.java
View File

@ -1,67 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Download Proxy Info Packet
*/
public class PacketDownloadProxyInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private List<String> proxies;
private UUID tracker;
/**
* New PacketDownloadProxyInfo (In)
*/
public PacketDownloadProxyInfo() {}
/**
* New PacketDownloadProxyInfo (Out)
*
* @param proxies Proxies name (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadProxyInfo(List<String> proxies, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.proxies = proxies;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (proxies != null) json.set(0x0001, proxies);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) {
ObjectMap<String> map = new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001));
ObjectMap<String> master = (data.contains(0x0002))?new ObjectMap<String>((Map<String, ?>) data.getObject(0x0002)):null;
if (master != null) map.set(master.getString("name"), master);
callback.run(map);
}
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

61
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketDownloadServerInfo.java
View File

@ -1,61 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Download Server Info Packet
*/
public class PacketDownloadServerInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private List<String> servers;
private UUID tracker;
/**
* New PacketDownloadServerInfo (In)
*/
public PacketDownloadServerInfo() {}
/**
* New PacketDownloadServerInfo (Out)
*
* @param servers Server names (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadServerInfo(List<String> servers, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.servers = servers;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (servers != null) json.set(0x0001, servers);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

70
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketEditServer.java
View File

@ -1,70 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Edit Server Packet
*/
public class PacketEditServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private ObjectMap<String> edit;
private boolean perma;
private UUID tracker;
/**
* New PacketEditServer (In)
*/
public PacketEditServer() {}
/**
* New PacketEditServer (Out)
*
* @param player Player Editing
* @param server Server
* @param edit Edits
* @param perma Save Changes
* @param callback Callbacks
*/
@SafeVarargs
public PacketEditServer(UUID player, String server, ObjectMap<String> edit, boolean perma, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.edit = edit;
this.perma = perma;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, edit);
data.set(0x0003, perma);
if (player != null) data.set(0x0004, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

65
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketRemoveServer.java
View File

@ -1,65 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Remove Server Packet
*/
public class PacketRemoveServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private boolean force;
private UUID tracker;
/**
* New PacketRemoveServer (In)
*/
public PacketRemoveServer() {}
/**
* New PacketRemoveServer (Out)
*
* @param player Player Removing
* @param server Server
* @param callback Callbacks
*/
@SafeVarargs
public PacketRemoveServer(UUID player, String server, boolean force, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.force = force;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, force);
if (player != null) data.set(0x0003, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

62
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketRestartServer.java
View File

@ -1,62 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Restart Server Packet
*/
public class PacketRestartServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private UUID tracker;
/**
* New PacketRestartServer (In)
*/
public PacketRestartServer() {}
/**
* New PacketRestartServer (Out)
*
* @param player Player Starting
* @param server Server
* @param callback Callbacks
*/
@SafeVarargs
public PacketRestartServer(UUID player, String server, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
if (player != null) data.set(0x0002, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

62
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketStartServer.java
View File

@ -1,62 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Start Server Packet
*/
public class PacketStartServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private UUID tracker;
/**
* New PacketStartServer (In)
*/
public PacketStartServer() {}
/**
* New PacketStartServer (Out)
*
* @param player Player Starting
* @param server Server
* @param callback Callbacks
*/
@SafeVarargs
public PacketStartServer(UUID player, String server, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
if (player != null) data.set(0x0002, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

66
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketStopServer.java
View File

@ -1,66 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Stop Server Packet
*/
public class PacketStopServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private boolean force;
private String server;
private UUID id;
/**
* New PacketStopServer (In)
*/
public PacketStopServer() {}
/**
* New PacketStopServer (Out)
*
* @param player Player Starting
* @param server Server
* @param force Force Stop
* @param callback Callbacks
*/
@SafeVarargs
public PacketStopServer(UUID player, String server, boolean force, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, force, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.force = force;
this.id = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(id, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, id);
data.set(0x0001, server);
data.set(0x0002, force);
if (player != null) data.set(0x0003, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

89
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/Packet/PacketUpdateServer.java
View File

@ -1,89 +0,0 @@
package net.ME1312.SubServers.Client.Sponge.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Create Server Packet
*/
public class PacketUpdateServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String name;
private String template;
private Version version;
private boolean waitfor;
private UUID tracker;
/**
* New PacketCreateServer (In)
*/
public PacketUpdateServer() {}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param name Server Name
* @param template Server Template
* @param version Server Version
* @param callback Callbacks
*/
@SafeVarargs
public PacketUpdateServer(UUID player, String name, String template, Version version, Callback<ObjectMap<Integer>>... callback) {
this(player, name, template, version, false, callback);
}
/**
* New PacketCreateServer (Out)
*
* @param player Player Creating
* @param name Server Name
* @param template Server Template
* @param version Server Version
* @param waitfor Wait until completion to send callback
* @param callback Callbacks
*/
@SafeVarargs
public PacketUpdateServer(UUID player, String name, String template, Version version, boolean waitfor, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(name, callback)) throw new NullPointerException();
this.player = player;
this.name = name;
this.template = template;
this.version = version;
this.waitfor = waitfor;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, name);
if (template != null) data.set(0x0002, template);
if (version != null) data.set(0x0003, version);
if (player != null) data.set(0x0004, player);
if (waitfor) data.set(0x0005, true);
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

1
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/Network/SubProtocol.java
View File

@ -7,6 +7,7 @@ import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataProtocol;
import net.ME1312.SubServers.Client.Common.Network.Packet.*;
import net.ME1312.SubServers.Client.Sponge.Event.SubNetworkConnectEvent;
import net.ME1312.SubServers.Client.Sponge.Event.SubNetworkDisconnectEvent;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.*;

333
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/SubAPI.java
View File

@ -3,27 +3,20 @@ package net.ME1312.SubServers.Client.Sponge;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataProtocol;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Common.ClientAPI;
import net.ME1312.SubServers.Client.Sponge.Graphic.UIHandler;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Sponge.Network.API.*;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.*;
import org.spongepowered.api.Platform;
import org.spongepowered.api.Sponge;
import org.spongepowered.api.plugin.PluginContainer;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.util.*;
import static net.ME1312.SubServers.Client.Sponge.Network.API.SimplifiedData.*;
/**
* SubAPI Class
*/
public final class SubAPI {
public final class SubAPI extends ClientAPI {
LinkedList<Runnable> reloadListeners = new LinkedList<Runnable>();
private final SubPlugin plugin;
private static SubAPI api;
@ -73,316 +66,6 @@ public final class SubAPI {
return name;
}
/**
* Gets the Hosts
*
* @param callback Host Map
*/
public void getHosts(Callback<Map<String, Host>> callback) {
requestHosts(null, callback);
}
/**
* Gets a Host
*
* @param name Host name
* @param callback a Host
*/
public void getHost(String name, Callback<Host> callback) {
requestHost(null, name, callback);
}
/**
* Gets the Server Groups (Group names are case sensitive here)
*
* @param callback Group Map
*/
public void getGroups(Callback<Map<String, List<Server>>> callback) {
requestGroups(null, callback);
}
/**
* Gets the Server Groups (Group names are all lowercase here)
*
* @param callback Group Map
*/
public void getLowercaseGroups(Callback<Map<String, List<Server>>> callback) {
requestLowercaseGroups(null, callback);
}
/**
* Gets a Server Group (Group names are case insensitive here)
*
* @param name Group name
* @param callback a Server Group
*/
public void getGroup(String name, Callback<NamedContainer<String, List<Server>>> callback) {
requestGroup(null, name, callback);
}
/**
* Gets the Servers (including SubServers)
*
* @param callback Server Map
*/
public void getServers(Callback<Map<String, Server>> callback) {
requestServers(null, callback);
}
/**
* Gets a Server
*
* @param name Server name
* @param callback a Server
*/
public void getServer(String name, Callback<Server> callback) {
requestServer(null, name, callback);
}
/**
* Adds a Server to the Network
*
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
*/
public void addServer(String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted, Callback<Integer> response) {
addServer(null, name, ip, port, motd, hidden, restricted, response);
}
/**
* Adds a Server to the Network
*
* @param player Player who added
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden If the server should be hidden from players
* @param restricted Players will need a permission to join if true
* @param response Response Code
*/
public void addServer(UUID player, String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketAddServer(player, name, ip, port, motd, hidden, restricted, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Adds a Server to the Network
*
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden if the server should be hidden from players
* @param restricted Players will need a permission to join if true
*/
public void addServer(String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted) {
addServer(null, name, ip, port, motd, hidden, restricted);
}
/**
* Adds a Server to the Network
*
* @param player Player who added
* @param name Name of the Server
* @param ip IP of the Server
* @param port Port of the Server
* @param motd MOTD of the Server
* @param hidden If the server should be hidden from players
* @param restricted Players will need a permission to join if true
*/
public void addServer(UUID player, String name, InetAddress ip, int port, String motd, boolean hidden, boolean restricted) {
addServer(player, name, ip, port, motd, hidden, restricted, i -> {});
}
/**
* Remove a Server from the Network
*
* @param name Name of the Server
* @param response Response Code
*/
public void removeServer(String name, Callback<Integer> response) {
removeServer(null, name, response);
}
/**
* Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
* @param response Response Code
*/
public void removeServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, false, response);
}
/**
* Remove a Server from the Network
*
* @param name Name of the Server
*/
public void removeServer(String name) {
removeServer(null, name);
}
/**
* Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
*/
public void removeServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, i -> {});
}
/**
* Force Remove a Server from the Network
*
* @param name Name of the Server
* @param response Response Code
*/
public void forceRemoveServer(String name, Callback<Integer> response) {
forceRemoveServer(null, name, response);
}
/**
* Force Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
* @param response Response Code
*/
public void forceRemoveServer(UUID player, String name, Callback<Integer> response) {
if (Util.isNull(name)) throw new NullPointerException();
removeServer(player, name, true, response);
}
/**
* Force Remove a Server from the Network
*
* @param name Name of the Server
*/
public void forceRemoveServer(String name) {
forceRemoveServer(null, name);
}
/**
* Force Remove a Server from the Network
*
* @param player Player Removing
* @param name Name of the Server
*/
public void forceRemoveServer(UUID player, String name) {
if (Util.isNull(name)) throw new NullPointerException();
forceRemoveServer(player, name, i -> {});
}
private void removeServer(UUID player, String name, boolean force, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketRemoveServer(player, name, force, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Gets the SubServers
*
* @param callback SubServer Map
*/
public void getSubServers(Callback<Map<String, SubServer>> callback) {
requestSubServers(null, callback);
}
/**
* Gets a SubServer
*
* @param name SubServer name
* @param callback a SubServer
*/
public void getSubServer(String name, Callback<SubServer> callback) {
requestSubServer(null, name, callback);
}
/**
* Gets the known Proxies
*
* @param callback Proxy Map
*/
public void getProxies(Callback<Map<String, Proxy>> callback) {
requestProxies(null, callback);
}
/**
* Gets a Proxy
*
* @param name Proxy name
* @param callback a Proxy
*/
public void getProxy(String name, Callback<Proxy> callback) {
requestProxy(null, name, callback);
}
/**
* Get the Master Proxy Container
*
* @param callback Master Proxy
*/
public void getMasterProxy(Callback<Proxy> callback) {
requestMasterProxy(null, callback);
}
/**
* Gets players on this network across all known proxies
*
* @param callback Remote Player Collection
*/
public void getGlobalPlayers(Callback<Map<UUID, RemotePlayer>> callback) {
requestGlobalPlayers(null, callback);
}
/**
* Gets a player on this network by searching across all known proxies
*
* @param name Player name
* @param callback Remote Player
*/
public void getGlobalPlayer(String name, Callback<RemotePlayer> callback) {
requestGlobalPlayer(null, name, callback);
}
/**
* Gets a player on this network by searching across all known proxies
*
* @param id Player UUID
* @param callback Remote Player
*/
public void getGlobalPlayer(UUID id, Callback<RemotePlayer> callback) {
requestGlobalPlayer(null, id, callback);
}
/**
* Gets the SubData Network Connections
*
@ -425,18 +108,6 @@ public final class SubAPI {
return new LinkedHashMap<>(plugin.lang.get().get(channel.toLowerCase()));
}
/**
* Gets a value from the SubServers Lang
*
* @param channel Lang Channel
* @param key Key
* @return Lang Values
*/
public String getLang(String channel, String key) {
if (Util.isNull(channel, key)) throw new NullPointerException();
return getLang(channel).get(key);
}
/**
* Gets the Graphics Handler
*

11
SubServers.Client/Sponge/src/net/ME1312/SubServers/Client/Sponge/SubCommand.java
View File

@ -14,7 +14,8 @@ import net.ME1312.Galaxi.Library.Container.Container;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Client.Sponge.Library.Compatibility.ListArgument;
import net.ME1312.SubServers.Client.Sponge.Network.API.*;
import net.ME1312.SubServers.Client.Common.Network.API.*;
import net.ME1312.SubServers.Client.Common.Network.Packet.*;
import net.ME1312.SubServers.Client.Sponge.Network.Packet.*;
import org.spongepowered.api.Sponge;
import org.spongepowered.api.command.CommandException;
@ -41,6 +42,8 @@ import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import static net.ME1312.SubServers.Client.Sponge.Library.ObjectPermission.*;
public final class SubCommand implements CommandExecutor {
private SubPlugin plugin;
@ -1139,11 +1142,11 @@ public final class SubCommand implements CommandExecutor {
String select = s.get();
plugin.api.getServer(select, server -> {
if (server != null) {
if (server.permits(sender, "subservers.server.%.*", "subservers.server.%.teleport")) {
if (permits(server, sender, "subservers.server.%.*", "subservers.server.%.teleport")) {
if (!(server instanceof SubServer) || ((SubServer) server).isRunning()) {
Container<Boolean> msg = new Container<>(false);
Callback<Player> action = target -> {
if (target == sender || server.permits(sender, "subservers.server.%.*", "subservers.server.%.teleport-others")) {
if (target == sender || permits(server, sender, "subservers.server.%.*", "subservers.server.%.teleport-others")) {
sender.sendMessage(ChatColor.convertColor(plugin.api.getLang("SubServers", "Command.Teleport").replace("$str$", target.getName())));
plugin.pmc(target, "Connect", server.getName());
} else if (!msg.get()) {
@ -1282,7 +1285,7 @@ public final class SubCommand implements CommandExecutor {
List<String>[] checks = permissions.toArray(new List[0]);
for (int p = 0; permitted && p < permissions.size(); p++) {
if (checks[p] == null || checks[p].size() <= 0) continue;
else permitted = server.permits(sender, checks[p].toArray(new String[0]));
else permitted = permits(server, sender, checks[p].toArray(new String[0]));
}
}

1
SubServers.Client/pom.xml
View File

@ -8,6 +8,7 @@
<packaging>pom</packaging>
<modules>
<module>Common</module>
<module>Bukkit</module>
<module>Sponge</module>
<module>Universal</module>

11
SubServers.Host/pom.xml
View File

@ -24,6 +24,13 @@
<scope>compile</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>net.ME1312.SubServers</groupId>
<artifactId>SubServers.Client.Common</artifactId>
<version>-PLACEHOLDER</version>
<scope>compile</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>net.ME1312.SubData</groupId>
<artifactId>Client</artifactId>
@ -142,6 +149,10 @@
<link>https://dev.me1312.net/jenkins/job/GalaxiEngine/javadoc/GalaxiEngine/</link>
<link>https://dev.me1312.net/jenkins/job/SubData/javadoc/Client/</link>
</links>
<includeDependencySources>true</includeDependencySources>
<dependencySourceIncludes>
<dependencySourceInclude>net.ME1312.SubServers:SubServers.Client.Common:*</dependencySourceInclude>
</dependencySourceIncludes>
</configuration>
</execution>
</executions>

2
SubServers.Host/src/net/ME1312/SubServers/Host/Event/SubCreateEvent.java
View File

@ -4,7 +4,7 @@ import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Event.Event;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Host.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Host.SubAPI;
import java.lang.reflect.InvocationTargetException;

2
SubServers.Host/src/net/ME1312/SubServers/Host/Event/SubCreatedEvent.java
View File

@ -4,7 +4,7 @@ import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Event.Event;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubServers.Host.Network.API.SubServer;
import net.ME1312.SubServers.Client.Common.Network.API.SubServer;
import net.ME1312.SubServers.Host.SubAPI;
import java.lang.reflect.InvocationTargetException;

5
SubServers.Host/src/net/ME1312/SubServers/Host/Executable/SubCreatorImpl.java
View File

@ -12,12 +12,13 @@ import net.ME1312.Galaxi.Library.UniversalFile;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Client.Common.Network.API.SubCreator;
import net.ME1312.SubServers.Client.Common.Network.API.SubCreator.ServerType;
import net.ME1312.SubServers.Host.ExHost;
import net.ME1312.SubServers.Host.Library.Exception.InvalidServerException;
import net.ME1312.SubServers.Host.Library.Exception.InvalidTemplateException;
import net.ME1312.SubServers.Host.Library.Exception.SubCreatorException;
import net.ME1312.SubServers.Host.Library.ReplacementScanner;
import net.ME1312.SubServers.Host.Network.API.SubCreator.ServerType;
import net.ME1312.SubServers.Host.Network.Packet.PacketExCreateServer;
import net.ME1312.SubServers.Host.Network.Packet.PacketOutExLogMessage;
import net.ME1312.SubServers.Host.SubAPI;
@ -39,7 +40,7 @@ public class SubCreatorImpl {
private ExHost host;
private TreeMap<String, CreatorTask> thread;
public static class ServerTemplate extends net.ME1312.SubServers.Host.Network.API.SubCreator.ServerTemplate {
public static class ServerTemplate extends SubCreator.ServerTemplate {
private String name;
private String nick = null;
private boolean enabled;

242
SubServers.Host/src/net/ME1312/SubServers/Host/Network/API/Server.java
View File

@ -1,242 +0,0 @@
package net.ME1312.SubServers.Host.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Container.NamedContainer;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.DataClient;
import net.ME1312.SubData.Client.DataSender;
import net.ME1312.SubData.Client.Library.ForwardedDataSender;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubData.Client.SubDataSender;
import net.ME1312.SubServers.Host.Network.Packet.PacketDownloadPlayerInfo;
import net.ME1312.SubServers.Host.Network.Packet.PacketDownloadServerInfo;
import net.ME1312.SubServers.Host.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
import java.util.*;
/**
* Simplified Server Data Class
*/
public class Server {
ObjectMap<String> raw;
private List<RemotePlayer> players = null;
DataClient client;
long timestamp;
/**
* Create an API representation of a Server
*
* @param raw Raw representation of the Server
*/
public Server(ObjectMap<String> raw) {
this(null, raw);
}
/**
* Create an API representation of a Server
*
* @param client SubData connection
* @param raw Raw representation of the Server
*/
Server(DataClient client, ObjectMap<String> raw) {
this.client = (SubDataClient) client;
load(raw);
}
@Override
public boolean equals(Object obj) {
return obj instanceof Server && getSignature().equals(((Server) obj).getSignature());
}
void load(ObjectMap<String> raw) {
this.raw = raw;
this.players = null;
this.timestamp = Calendar.getInstance().getTime().getTime();
}
SubDataClient client() {
return SimplifiedData.client(client);
}
/**
* Download a new copy of the data from SubData
*/
public void refresh() {
String name = getName();
client().sendPacket(new PacketDownloadServerInfo(Collections.singletonList(name), data -> load(data.getMap(name))));
}
/**
* Gets the SubData Client Channel IDs
*
* @return SubData Client Channel ID Array
*/
@SuppressWarnings("unchecked")
public DataSender[] getSubData() {
ObjectMap<Integer> subdata = new ObjectMap<Integer>((Map<Integer, ?>) raw.getObject("subdata"));
LinkedList<Integer> keys = new LinkedList<Integer>(subdata.getKeys());
LinkedList<SubDataSender> channels = new LinkedList<SubDataSender>();
Collections.sort(keys);
for (Integer channel : keys) channels.add((subdata.isNull(channel))?null:new ForwardedDataSender((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0], subdata.getUUID(channel)));
return channels.toArray(new SubDataSender[0]);
}
/**
* Get the Name of this Server
*
* @return Server Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Server
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Get the Address of this Server
*
* @return Server Address
*/
public InetSocketAddress getAddress() {
return new InetSocketAddress(raw.getRawString("address").split(":")[0], Integer.parseInt(raw.getRawString("address").split(":")[1]));
}
/**
* Get this Server's Groups
*
* @return Group names
*/
public List<String> getGroups() {
return new LinkedList<String>(raw.getRawStringList("group"));
}
/**
* Get players on this server across all known proxies
*
* @return Remote Player Collection
*/
public Collection<NamedContainer<String, UUID>> getGlobalPlayers() {
List<NamedContainer<String, UUID>> players = new ArrayList<NamedContainer<String, UUID>>();
for (String id : raw.getMap("players").getKeys()) {
players.add(new NamedContainer<String, UUID>(raw.getMap("players").getRawString(id), UUID.fromString(id)));
}
return players;
}
/**
* Get players on this server across all known proxies
*
* @param callback Remote Player Collection
*/
public void getGlobalPlayers(Callback<Collection<RemotePlayer>> callback) {
if (Util.isNull(callback)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
Runnable run = () -> {
try {
callback.run(players);
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
};
if (players == null) {
LinkedList<UUID> ids = new LinkedList<UUID>();
for (String id : raw.getMap("players").getKeys()) ids.add(UUID.fromString(id));
client().sendPacket(new PacketDownloadPlayerInfo(ids, data -> {
LinkedList<RemotePlayer> players = new LinkedList<RemotePlayer>();
for (String player : data.getKeys()) {
players.add(new RemotePlayer(data.getMap(player)));
}
this.players = players;
run.run();
}));
} else {
run.run();
}
}
/**
* If the server is hidden from players
*
* @return Hidden Status
*/
public boolean isHidden() {
return raw.getBoolean("hidden");
}
/**
* Gets the MOTD of the Server
*
* @return Server MOTD
*/
public String getMotd() {
return raw.getRawString("motd");
}
/**
* Gets if the Server is Restricted
*
* @return Restricted Status
*/
public boolean isRestricted() {
return raw.getBoolean("restricted");
}
/**
* Get a copy of the current whitelist
*
* @return Player Whitelist
*/
public Collection<UUID> getWhitelist() {
return raw.getUUIDList("whitelist");
}
/**
* See if a player is whitelisted
*
* @param player Player to check
* @return Whitelisted Status
*/
public boolean isWhitelisted(UUID player) {
return getWhitelist().contains(player);
}
/**
* Get the Signature of this Object
*
* @return Object Signature
*/
public String getSignature() {
return raw.getRawString("signature");
}
/**
* Get the Timestamp for when the data was last refreshed
*
* @return Data Timestamp
*/
public long getTimestamp() {
return timestamp;
}
/**
* Get the raw representation of the Server
*
* @return Raw Server
*/
public ObjectMap<String> getRaw() {
return raw.clone();
}
}

293
SubServers.Host/src/net/ME1312/SubServers/Host/Network/API/SubCreator.java
View File

@ -1,293 +0,0 @@
package net.ME1312.SubServers.Host.Network.API;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Client.SubDataClient;
import net.ME1312.SubServers.Host.Network.Packet.PacketCreateServer;
import net.ME1312.SubServers.Host.Network.Packet.PacketUpdateServer;
import net.ME1312.SubServers.Host.SubAPI;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.UUID;
/**
* Simplified SubCreator Data Class
*/
public class SubCreator {
HashMap<String, ServerTemplate> templates = new HashMap<String, ServerTemplate>();
Host host;
ObjectMap<String> raw;
SubCreator(Host host, ObjectMap<String> raw) {
this.host = host;
this.raw = raw;
for (String template : raw.getMap("templates").getKeys()) {
templates.put(template.toLowerCase(), new ServerTemplate(raw.getMap("templates").getMap(template)));
}
}
@Override
public boolean equals(Object obj) {
return obj instanceof SubCreator && host.getSignature().equals(((SubCreator) obj).host.getSignature());
}
public static class ServerTemplate {
private ObjectMap<String> raw;
private ServerType type;
public ServerTemplate(ObjectMap<String> raw) {
this.raw = raw;
this.type = Util.getDespiteException(() -> ServerType.valueOf(raw.getRawString("type").toUpperCase().replace('-', '_').replace(' ', '_')), ServerType.CUSTOM);
}
/**
* Get the Name of this Template
*
* @return Template Name
*/
public String getName() {
return raw.getRawString("name");
}
/**
* Get the Display Name of this Template
*
* @return Display Name
*/
public String getDisplayName() {
return raw.getRawString("display");
}
/**
* Get the Enabled Status of this Template
*
* @return Enabled Status
*/
public boolean isEnabled() {
return raw.getBoolean("enabled");
}
/**
* Get the Item Icon for this Template
*
* @return Item Icon Name/ID
*/
public String getIcon() {
return raw.getString("icon");
}
/**
* Get the Type of this Template
*
* @return Template Type
*/
public ServerType getType() {
return type;
}
/**
* Get whether this Template requires the Version argument
*
* @return Version Requirement
*/
public boolean requiresVersion() {
return raw.getBoolean("version-req");
}
/**
* Get whether this Template can be used to update it's servers
*
* @return Updatable Status
*/
public boolean canUpdate() {
return raw.getBoolean("can-update");
}
}
public enum ServerType {
SPIGOT,
VANILLA,
FORGE,
SPONGE,
CUSTOM;
@Override
public String toString() {
return super.toString().substring(0, 1).toUpperCase()+super.toString().substring(1).toLowerCase();
}
}
/**
* Create a SubServer
*
* @param player Player Creating
* @param name Server Name
* @param template Server Template
* @param version Server Version (may be null)
* @param port Server Port Number (null to auto-select)
* @param response Response Code
*/
public void create(UUID player, String name, ServerTemplate template, Version version, Integer port, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketCreateServer(player, name, host.getName(), template.getName(), version, port, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
}
/**
* Create a SubServer
*
* @param name Server Name
* @param template Server Template
* @param version Server Version (may be null)
* @param port Server Port Number (null to auto-select)
* @param response Response Code
*/
public void create(String name, ServerTemplate template, Version version, Integer port, Callback<Integer> response) {
create(null, name, template, version, port, response);
}
/**
* Create a SubServer
*
* @param player Player Creating
* @param name Server Name
* @param template Server Template
* @param version Server Version (may be null)
* @param port Server Port Number (null to auto-select)
*/
public void create(UUID player, String name, ServerTemplate template, Version version, Integer port) {
create(player, name, template, version, port, i -> {});
}
/**
* Create a SubServer
*
* @param name Server Name
* @param template Server Template
* @param version Server Version (may be null)
* @param port Server Port Number (null to auto-select)
*/
public void create(String name, ServerTemplate template, Version version, Integer port) {
create(name, template, version, port, i -> {});
}
/**
* Update a SubServer
*
* @param player Player Updating
* @param server Server to Update
* @param template Server Template
* @param version Server Version (may be null)
* @param response Response Code
*/
public void update(UUID player, SubServer server, ServerTemplate template, Version version, Callback<Integer> response) {
if (Util.isNull(response)) throw new NullPointerException();
StackTraceElement[] origin = new Exception().getStackTrace();
((SubDataClient) SubAPI.getInstance().getSubDataNetwork()[0]).sendPacket(new PacketUpdateServer(player, server.getName(), template.getName(), version, data -> {
try {
response.run(data.getInt(0x0001));
} catch (Throwable e) {
Throwable ew = new InvocationTargetException(e);
ew.setStackTrace(origin);
ew.printStackTrace();
}
}));
};
/**
* Update a SubServer
*
* @param player Player Updating
* @param server Server to Update
* @param template Server Template
* @param version Server Version (may be null)
*/
public void update(UUID player, SubServer server, ServerTemplate template, Version version) {
update(player, server, template, version, null);
}
/**
* Update a SubServer
*
* @param server Server to Update
* @param template Server Template
* @param version Server Version (may be null)
* @param response Response Code
*/
public void update(SubServer server, ServerTemplate template, Version version, Callback<Integer> response) {
update(null, server, template, version, response);
}
/**
* Update a SubServer
*
* @param server Server to Update
* @param template Server Template
* @param version Server Version (may be null)
*/
public void update(SubServer server, ServerTemplate template, Version version) {
update(null, server, template, version);
}
/**
* Update a SubServer
*
* @param player Player Updating
* @param server Server to Update
* @param version Server Version (may be null)
*/
public void update(UUID player, SubServer server, Version version) {
update(player, server, null, version);
}
/**
* Update a SubServer
*
* @param server Server to Update
* @param version Server Version (may be null)
*/
public void update(SubServer server, Version version) {
update(null, server, version);
}
/**
* Gets the host this creator belongs to
*
* @return Host
*/
public Host getHost() {
return host;
}
/**
* Gets the Templates that can be used in this SubCreator instance
*
* @return Template Map
*/
public Map<String, ServerTemplate> getTemplates() {
return new TreeMap<String, ServerTemplate>(templates);
}
/**
* Gets a SubCreator Template by name
*
* @param name Template Name
* @return Template
*/
public ServerTemplate getTemplate(String name) {
return getTemplates().get(name.toLowerCase());
}
}

66
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketCommandServer.java
View File

@ -1,66 +0,0 @@
package net.ME1312.SubServers.Host.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Command Server Packet
*/
public class PacketCommandServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private String command;
private UUID tracker;
/**
* New PacketCommandServer (In)
*/
public PacketCommandServer() {}
/**
* New PacketCommandServer (Out)
*
* @param player Player Sending
* @param server Server to send to
* @param command Command to send
* @param callback Callbacks
*/
@SafeVarargs
public PacketCommandServer(UUID player, String server, String command, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, command, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.command = command;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, command);
if (player != null) data.set(0x0003, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

68
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketDeleteServer.java
View File

@ -1,68 +0,0 @@
package net.ME1312.SubServers.Host.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Delete Server Packet
*/
public class PacketDeleteServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private boolean recycle;
private boolean force;
private UUID tracker;
/**
* New PacketDeleteServer (In)
*/
public PacketDeleteServer() {}
/**
* New PacketDeleteServer (Out)
*
* @param player Player Deleting
* @param server Server
* @param callback Callbacks
*/
@SafeVarargs
public PacketDeleteServer(UUID player, String server, boolean recycle, boolean force, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.recycle = recycle;
this.force = force;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, recycle);
data.set(0x0003, force);
if (player != null) data.set(0x0004, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

61
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketDownloadHostInfo.java
View File

@ -1,61 +0,0 @@
package net.ME1312.SubServers.Host.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Download Host Info Packet
*/
public class PacketDownloadHostInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private List<String> hosts;
private UUID tracker;
/**
* New PacketDownloadHostInfo (In)
*/
public PacketDownloadHostInfo() {}
/**
* New PacketDownloadHostInfo (Out)
*
* @param hosts Host names (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadHostInfo(List<String> hosts, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.hosts = hosts;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (hosts != null) json.set(0x0001, hosts);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

50
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketDownloadPlatformInfo.java
View File

@ -1,50 +0,0 @@
package net.ME1312.SubServers.Host.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* Download Proxy Info Packet
*/
public class PacketDownloadPlatformInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private UUID tracker;
/**
* New PacketDownloadPlatformInfo
*
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadPlatformInfo(Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
return data;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

74
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketDownloadPlayerInfo.java
View File

@ -1,74 +0,0 @@
package net.ME1312.SubServers.Host.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.*;
/**
* Download Player Info Packet
*/
public class PacketDownloadPlayerInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private Collection<String> names;
private Collection<UUID> ids;
private UUID tracker;
/**
* New PacketDownloadPlayerInfo (In)
*/
public PacketDownloadPlayerInfo() {}
/**
* New PacketDownloadPlayerInfo (Out)
*
* @param players Player Names (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadPlayerInfo(Collection<String> players, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.names = players;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
/**
* New PacketDownloadPlayerInfo (Out)
*
* @param players Player IDs (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadPlayerInfo(List<UUID> players, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.ids = players;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (names != null) json.set(0x0001, names);
if (ids != null) json.set(0x0002, ids);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

67
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketDownloadProxyInfo.java
View File

@ -1,67 +0,0 @@
package net.ME1312.SubServers.Host.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Download Proxy Info Packet
*/
public class PacketDownloadProxyInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private List<String> proxies;
private UUID tracker;
/**
* New PacketDownloadProxyInfo (In)
*/
public PacketDownloadProxyInfo() {}
/**
* New PacketDownloadProxyInfo (Out)
*
* @param proxies Proxies name (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadProxyInfo(List<String> proxies, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.proxies = proxies;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (proxies != null) json.set(0x0001, proxies);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) {
ObjectMap<String> map = new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001));
ObjectMap<String> master = (data.contains(0x0002))?new ObjectMap<String>((Map<String, ?>) data.getObject(0x0002)):null;
if (master != null) map.set(master.getString("name"), master);
callback.run(map);
}
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

61
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketDownloadServerInfo.java
View File

@ -1,61 +0,0 @@
package net.ME1312.SubServers.Host.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Download Server Info Packet
*/
public class PacketDownloadServerInfo implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<String>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<String>>[]>();
private List<String> servers;
private UUID tracker;
/**
* New PacketDownloadServerInfo (In)
*/
public PacketDownloadServerInfo() {}
/**
* New PacketDownloadServerInfo (Out)
*
* @param servers Server names (or null for all)
* @param callback Callbacks
*/
@SafeVarargs
public PacketDownloadServerInfo(List<String> servers, Callback<ObjectMap<String>>... callback) {
if (Util.isNull((Object) callback)) throw new NullPointerException();
this.servers = servers;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> json = new ObjectMap<Integer>();
json.set(0x0000, tracker);
if (servers != null) json.set(0x0001, servers);
return json;
}
@SuppressWarnings("unchecked")
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<String>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(new ObjectMap<String>((Map<String, ?>) data.getObject(0x0001)));
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

65
SubServers.Host/src/net/ME1312/SubServers/Host/Network/Packet/PacketRemoveServer.java
View File

@ -1,65 +0,0 @@
package net.ME1312.SubServers.Host.Network.Packet;
import net.ME1312.Galaxi.Library.Callback.Callback;
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.Util;
import net.ME1312.SubData.Client.Protocol.PacketObjectIn;
import net.ME1312.SubData.Client.Protocol.PacketObjectOut;
import net.ME1312.SubData.Client.SubDataSender;
import java.util.HashMap;
import java.util.UUID;
/**
* Remove Server Packet
*/
public class PacketRemoveServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
private UUID player;
private String server;
private boolean force;
private UUID tracker;
/**
* New PacketRemoveServer (In)
*/
public PacketRemoveServer() {}
/**
* New PacketRemoveServer (Out)
*
* @param player Player Removing
* @param server Server
* @param callback Callbacks
*/
@SafeVarargs
public PacketRemoveServer(UUID player, String server, boolean force, Callback<ObjectMap<Integer>>... callback) {
if (Util.isNull(server, callback)) throw new NullPointerException();
this.player = player;
this.server = server;
this.force = force;
this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
callbacks.put(tracker, callback);
}
@Override
public ObjectMap<Integer> send(SubDataSender client) {
ObjectMap<Integer> data = new ObjectMap<Integer>();
data.set(0x0000, tracker);
data.set(0x0001, server);
data.set(0x0002, force);
if (player != null) data.set(0x0003, player.toString());
return data;
}
@Override
public void receive(SubDataSender client, ObjectMap<Integer> data) {
for (Callback<ObjectMap<Integer>> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data);
callbacks.remove(data.getUUID(0x0000));
}
@Override
public int version() {
return 0x0001;
}
}

Some files were not shown because too many files have changed in this diff Show More