Reoptimize the recycle cleaners

If you have encountered this issue, know that the correct plugins folder is named `Plugins`.

.github/ISSUE_TEMPLATE/bug-report.md

@@ -11,7 +11,7 @@ Paste in the version information from the SubServers app in question here. To ge
 Here you can write about what happened that shouldn't have. If you have any errors in your console related to what happened, you should also paste those here.
 
 ### How It Happened
-Tell us step-by-step how to recreate the problem. This step is vital for us to determine whether or not the problem happens to everyone else too.
+Tell us step-by-step how to recreate the problem. This step is vital for us to determine whether the problem happens to everyone else too.
 
 ### Additional Information
 Here you can provide any extra details you may think useful for solving the problem.

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright (C) 2015-2019 ME1312
+   Copyright (C) 2015-2023 ME1312
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -18,16 +18,20 @@ These are some quick links for common resources of SubServers 2.
 > [https://dev.me1312.net/jenkins/job/SubServers Platform](https://dev.me1312.net/jenkins/job/SubServers%20Platform)
 
 ### Javadocs for Developers
-> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Bungee/](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Bungee/)<br>
-> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Host/](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Host/)<br>
-> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Sync/](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Sync/)<br>
-> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Client.Bukkit/](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Client.Bukkit/)<br>
-> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Client.Sponge/](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Client.Sponge/)
+> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Bungee](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Bungee)<br>
+> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Bungee.Common](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Bungee.Common)<br>
+> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Host](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Host)<br>
+> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Sync](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Sync)<br>
+> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Sync.Velocity](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Sync.Velocity)<br>
+> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Client.Bukkit](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Client.Bukkit)<br>
+> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Client.Common](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Client.Common)<br>
+> [https://dev.me1312.net/jenkins/job/SubServers Platform/javadoc/SubServers.Client.Sponge](https://dev.me1312.net/jenkins/job/SubServers%20Platform/javadoc/SubServers.Client.Sponge)
 
 ### Stats for nerds
 > [https://bstats.org/plugin/bungeecord/SubServers_Bungee](https://bstats.org/plugin/bungeecord/SubServers%202)<br>
 > [https://bstats.org/plugin/other/SubServers_Host](https://bstats.org/plugin/other/SubServers%20Host)<br>
 > [https://bstats.org/plugin/bungeecord/SubServers_Sync](https://bstats.org/plugin/bungeecord/SubServers%20Sync)<br>
+> [https://bstats.org/plugin/velocity/SubServers_Sync](https://bstats.org/plugin/velocity/SubServers%20Sync)<br>
 > [https://bstats.org/plugin/bungeecord/SubServers_Console](https://bstats.org/plugin/bungeecord/SubServers%20Console)<br>
 > [https://bstats.org/plugin/bukkit/SubServers_Client](https://bstats.org/plugin/bukkit/SubServers%20Client)<br>
 > [https://bstats.org/plugin/sponge/SubServers_Client](https://bstats.org/plugin/sponge/SubServers%20Client)

SubServers.Bungee/common/pom.xml

@@ -27,9 +27,9 @@
         </dependency>
         <dependency>
             <groupId>net.ME1312.Galaxi</groupId>
-            <artifactId>GalaxiUtil</artifactId>
-            <version>21w24a</version>
-            <scope>provided</scope>
+            <artifactId>GalaxiBase</artifactId>
+            <version>23w51a</version>
+            <scope>compile</scope>
         </dependency>
     </dependencies>
 
@@ -54,6 +54,59 @@
                     <target>1.8</target>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-antrun-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>process-resources</phase>
+                        <goals>
+                            <goal>run</goal>
+                        </goals>
+                        <configuration>
+                            <tasks>
+                                <mkdir dir="${project.build.directory}" />
+                                <copy file="${basedir}/../../LICENSE" todir="${project.build.directory}/classes" />
+                            </tasks>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.2.0</version>
+                <configuration>
+                    <finalName>SubServers.Bungee.Common</finalName>
+                    <outputDirectory>../../Artifacts/Maven</outputDirectory>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <version>3.0.0</version>
+                <executions>
+                    <execution>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>javadoc</goal>
+                        </goals>
+                        <configuration>
+                            <windowtitle>SubServers.Bungee.Common</windowtitle>
+                            <doctitle>SubServers.Bungee.Common ${project.version}</doctitle>
+                            <show>protected</show>
+                            <destDir>./</destDir>
+                            <outputDirectory>${basedir}/../../Javadoc/SubServers.Bungee.Common</outputDirectory>
+                            <reportOutputDirectory>${basedir}/../../Javadoc/SubServers.Bungee.Common</reportOutputDirectory>
+                            <additionalOptions>-Xdoclint:none</additionalOptions>
+                            <links>
+                                <link>https://dev.me1312.net/jenkins/job/GalaxiEngine/javadoc/GalaxiBase/</link>
+                                <link>https://ci.md-5.net/job/BungeeCord/ws/api/target/apidocs/</link>
+                            </links>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 </project>

SubServers.Bungee/common/src/net/ME1312/SubServers/Bungee/BungeeAPI.java

@@ -1,6 +1,5 @@
 package net.ME1312.SubServers.Bungee;
 
-import net.ME1312.Galaxi.Library.UniversalFile;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.Galaxi.Library.Version.Version;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer;
@@ -8,6 +7,7 @@ import net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer;
 import net.md_5.bungee.api.ProxyServer;
 import net.md_5.bungee.api.config.ServerInfo;
 
+import java.io.File;
 import java.util.Collection;
 import java.util.Map;
 import java.util.UUID;
@@ -23,9 +23,18 @@ public interface BungeeAPI {
      * @return SubAPI BungeeCord Common
      */
     static BungeeAPI getInstance() {
-        return ((BungeeCommon) ProxyServer.getInstance()).api.run();
+        return ((BungeeCommon) ProxyServer.getInstance()).api.get();
     }
 
+    /**
+     * Gets the BungeeCommon Internals
+     *
+     * @deprecated Use BungeeAPI Methods when available
+     * @return BungeeCommon Internals
+     */
+    @Deprecated
+    BungeeCommon getInternals();
+
     /**
      * Get the number of players on this network across all known proxies
      *
@@ -87,7 +96,7 @@ public interface BungeeAPI {
      * @return Lang Values
      */
     default String getLang(String channel, String key) {
-        if (Util.isNull(channel, key)) throw new NullPointerException();
+        Util.nullpo(channel, key);
         return getLang(channel).get(key);
     }
 
@@ -96,7 +105,7 @@ public interface BungeeAPI {
      *
      * @return Directory
      */
-    UniversalFile getRuntimeDirectory();
+    File getRuntimeDirectory();
 
     /**
      * Gets the SubServers Version

SubServers.Bungee/common/src/net/ME1312/SubServers/Bungee/BungeeCommon.java

@@ -1,21 +1,25 @@
 package net.ME1312.SubServers.Bungee;
 
-import net.ME1312.Galaxi.Library.Callback.ReturnRunnable;
+import net.ME1312.Galaxi.Library.Util;
 
+import io.netty.channel.Channel;
 import net.md_5.bungee.BungeeCord;
 import net.md_5.bungee.api.config.ServerInfo;
 
-import java.io.IOException;
+import java.util.Collection;
 import java.util.Map;
+import java.util.function.Supplier;
 
 /**
  * BungeeCord Common Layout Class
  */
 public abstract class BungeeCommon extends BungeeCord {
     private static BungeeCommon instance;
-    final ReturnRunnable<BungeeAPI> api;
+    final Supplier<BungeeAPI> api;
+    protected final Collection<Channel> listeners;
 
-    protected BungeeCommon(ReturnRunnable<BungeeAPI> api) throws IOException {
+    protected BungeeCommon(Supplier<BungeeAPI> api) throws Exception {
+        listeners= Util.reflect(BungeeCord.class.getDeclaredField("listeners"), this);
         this.api = api;
         instance = this;
     }

SubServers.Bungee/common/src/net/ME1312/SubServers/Bungee/Library/Compatibility/Logger.java

@@ -19,7 +19,7 @@ public class Logger {
      * @return Logger
      */
     public static java.util.logging.Logger get(String prefix) {
-        if (!existing.keySet().contains(prefix)) {
+        if (!existing.containsKey(prefix)) {
             java.util.logging.Logger log = java.util.logging.Logger.getAnonymousLogger();
                 log.setUseParentHandlers(false);
                 log.addHandler(new Handler() {

SubServers.Bungee/common/src/net/ME1312/SubServers/Bungee/Library/Compatibility/RPSI.java

@@ -0,0 +1,52 @@
+package net.ME1312.SubServers.Bungee.Library.Compatibility;
+
+import net.md_5.bungee.api.chat.BaseComponent;
+
+import java.util.UUID;
+import java.util.function.IntConsumer;
+
+/**
+ * RemotePlayer Static Implementation Layout Class
+ */
+public abstract class RPSI {
+    protected static RPSI instance;
+    protected RPSI() {
+        if (instance == null) instance = this;
+    }
+
+    /**
+     * Sends messages to this player
+     *
+     * @param players Players to send to
+     * @param messages Messages to send
+     * @param response Success Status
+     */
+    protected abstract void sendMessage(UUID[] players, String[] messages, IntConsumer response);
+
+    /**
+     * Sends messages to this player
+     *
+     * @param players Players to send to
+     * @param messages Messages to send
+     * @param response Success Status
+     */
+    protected abstract void sendMessage(UUID[] players, BaseComponent[][] messages, IntConsumer response);
+
+    /**
+     * Transfers this player to another server
+     *
+     * @param players Players to send to
+     * @param server Target server
+     * @param response Success Status
+     */
+    protected abstract void transfer(UUID[] players, String server, IntConsumer response);
+
+    /**
+     * Disconnects this player from the network
+     *
+     * @param players Players to send to
+     * @param reason Disconnect Reason
+     * @param response Success status
+     */
+    protected abstract void disconnect(UUID[] players, String reason, IntConsumer response);
+}

SubServers.Bungee/common/src/net/ME1312/SubServers/Bungee/Library/Compatibility/RemotePlayer.java

@@ -1,15 +1,27 @@
 package net.ME1312.SubServers.Bungee.Library.Compatibility;
 
+import net.md_5.bungee.api.chat.BaseComponent;
 import net.md_5.bungee.api.config.ServerInfo;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 import java.net.InetSocketAddress;
 import java.util.UUID;
+import java.util.function.IntConsumer;
+
+import static net.ME1312.SubServers.Bungee.Library.Compatibility.RPSI.instance;
 
 /**
  * RemotePlayer Layout Class
  */
 public interface RemotePlayer {
 
+    /**
+     * Get Local Player
+     *
+     * @return Local Player (or null when not local)
+     */
+    ProxiedPlayer get();
+
     /**
      * Get the UUID of this player.
      *
@@ -51,4 +63,398 @@ public interface RemotePlayer {
      * @return the server this player is connected to
      */
     ServerInfo getServer();
+
+    /**
+     * Sends messages to all players
+     *
+     * @param messages Messages to send
+     */
+    static void broadcastMessage(String... messages) {
+        broadcastMessage(messages, i -> {});
+    }
+
+    /**
+     * Sends a message to all players
+     *
+     * @param message Message to send
+     * @param response Success Status
+     */
+    static void broadcastMessage(String message, IntConsumer response) {
+        broadcastMessage(new String[]{ message }, response);
+    }
+
+    /**
+     * Sends messages to all players
+     *
+     * @param messages Messages to send
+     * @param response Success Status
+     */
+    static void broadcastMessage(String[] messages, IntConsumer response) {
+        sendMessage(null, messages, response);
+    }
+
+    /**
+     * Sends messages to this player
+     *
+     * @param messages Messages to send
+     */
+    default void sendMessage(String... messages) {
+        sendMessage(messages, i -> {});
+    }
+
+    /**
+     * Sends a message to this player
+     *
+     * @param message Message to send
+     * @param response Success Status
+     */
+    default void sendMessage(String message, IntConsumer response) {
+        sendMessage(new String[]{ message }, response);
+    }
+
+    /**
+     * Sends messages to this player
+     *
+     * @param messages Messages to send
+     * @param response Success Status
+     */
+    default void sendMessage(String[] messages, IntConsumer response) {
+        sendMessage(new UUID[]{ getUniqueId() }, messages, response);
+    }
+
+    /**
+     * Sends messages to these players
+     *
+     * @param players Players to select
+     * @param messages Messages to send
+     */
+    static void sendMessage(UUID[] players, String... messages) {
+        sendMessage(players, messages, i -> {});
+    }
+
+    /**
+     * Sends a message to these players
+     *
+     * @param players Players to select
+     * @param message Message to send
+     * @param response Success Status
+     */
+    static void sendMessage(UUID[] players, String message, IntConsumer response) {
+        sendMessage(players, new String[]{ message }, response);
+    }
+
+    /**
+     * Sends messages to these players
+     *
+     * @param players Players to select
+     * @param messages Messages to send
+     * @param response Success Status
+     */
+    static void sendMessage(UUID[] players, String[] messages, IntConsumer response) {
+        instance.sendMessage(players, messages, response);
+    }
+
+    /**
+     * Sends a message to all players
+     *
+     * @param message Message to send
+     */
+    static void broadcastMessage(BaseComponent... message) {
+        broadcastMessage(message, i -> {});
+    }
+
+    /**
+     * Sends a message to all players
+     *
+     * @param message Message to send
+     * @param response Success Status
+     */
+    static void broadcastMessage(BaseComponent message, IntConsumer response) {
+        broadcastMessage(new BaseComponent[]{ message }, response);
+    }
+
+    /**
+     * Sends a messages to all players
+     *
+     * @param message Message to send
+     * @param response Success Status
+     */
+    static void broadcastMessage(BaseComponent[] message, IntConsumer response) {
+        broadcastMessage(new BaseComponent[][]{ message }, response);
+    }
+
+    /**
+     * Sends messages to all players
+     *
+     * @param messages Messages to send
+     */
+    static void broadcastMessage(BaseComponent[]... messages) {
+        broadcastMessage(messages, i -> {});
+    }
+
+    /**
+     * Sends messages to all players
+     *
+     * @param messages Messages to send
+     * @param response Success Status
+     */
+    static void broadcastMessage(BaseComponent[][] messages, IntConsumer response) {
+        sendMessage(null, messages, response);
+    }
+
+    /**
+     * Sends a message to this player
+     *
+     * @param message Message to send
+     */
+    default void sendMessage(BaseComponent... message) {
+        sendMessage(message, i -> {});
+    }
+
+    /**
+     * Sends a message to this player
+     *
+     * @param message Message to send
+     * @param response Success Status
+     */
+    default void sendMessage(BaseComponent message, IntConsumer response) {
+        sendMessage(new BaseComponent[]{ message }, response);
+    }
+
+    /**
+     * Sends a message to this player
+     *
+     * @param message Message to send
+     * @param response Success Status
+     */
+    default void sendMessage(BaseComponent[] message, IntConsumer response) {
+        sendMessage(new BaseComponent[][]{ message }, response);
+    }
+
+    /**
+     * Sends messages to this player
+     *
+     * @param messages Messages to send
+     */
+    default void sendMessage(BaseComponent[]... messages) {
+        sendMessage(messages, i -> {});
+    }
+
+    /**
+     * Sends messages to this player
+     *
+     * @param messages Messages to send
+     * @param response Success Status
+     */
+    default void sendMessage(BaseComponent[][] messages, IntConsumer response) {
+        sendMessage(new UUID[]{ getUniqueId() }, messages, response);
+    }
+
+    /**
+     * Sends a message to these players
+     *
+     * @param players Players to select
+     * @param message Message to send
+     */
+    static void sendMessage(UUID[] players, BaseComponent... message) {
+        sendMessage(players, message, i -> {});
+    }
+
+    /**
+     * Sends a message to these players
+     *
+     * @param players Players to select
+     * @param message Message to send
+     * @param response Success Status
+     */
+    static void sendMessage(UUID[] players, BaseComponent message, IntConsumer response) {
+        sendMessage(players, new BaseComponent[]{ message }, response);
+    }
+
+    /**
+     * Sends a message to these players
+     *
+     * @param players Players to select
+     * @param message Message to send
+     * @param response Success Status
+     */
+    static void sendMessage(UUID[] players, BaseComponent[] message, IntConsumer response) {
+        sendMessage(players, new BaseComponent[][]{ message }, response);
+    }
+
+    /**
+     * Sends messages to these players
+     *
+     * @param players Players to select
+     * @param messages Messages to send
+     */
+    static void sendMessage(UUID[] players, BaseComponent[]... messages) {
+        sendMessage(players, messages, i -> {});
+    }
+
+    /**
+     * Sends messages to these players
+     *
+     * @param players Players to select
+     * @param messages Message to send
+     * @param response Success Status
+     */
+    static void sendMessage(UUID[] players, BaseComponent[][] messages, IntConsumer response) {
+        instance.sendMessage(players, messages, response);
+    }
+
+    /**
+     * Transfers this player to another server
+     *
+     * @param server Target server
+     */
+    default void transfer(String server) {
+        transfer(server, i -> {});
+    }
+
+    /**
+     * Transfers this player to another server
+     *
+     * @param server Target server
+     * @param response Success status
+     */
+    default void transfer(String server, IntConsumer response) {
+        transfer(new UUID[]{ getUniqueId() }, server, response);
+    }
+
+    /**
+     * Transfers these players to another server
+     *
+     * @param players Players to select
+     * @param server Target server
+     */
+    static void transfer(UUID[] players, String server) {
+        transfer(players, server, i -> {});
+    }
+
+    /**
+     * Transfers these players to another server
+     *
+     * @param players Players to select
+     * @param server Target server
+     * @param response Success status
+     */
+    static void transfer(UUID[] players, String server, IntConsumer response) {
+        instance.transfer(players, server, response);
+    }
+
+    /**
+     * Transfers this player to another server
+     *
+     * @param server Target server
+     */
+    default void transfer(ServerInfo server) {
+        transfer(server, i -> {});
+    }
+
+    /**
+     * Transfers this player to another server
+     *
+     * @param server Target server
+     * @param response Success status
+     */
+    default void transfer(ServerInfo server, IntConsumer response) {
+        transfer(new UUID[]{ getUniqueId() }, server, response);
+    }
+
+    /**
+     * Transfers these players to another server
+     *
+     * @param players Players to select
+     * @param server Target server
+     */
+    static void transfer(UUID[] players, ServerInfo server) {
+        transfer(players, server, i -> {});
+    }
+
+    /**
+     * Transfers these players to another server
+     *
+     * @param players Players to select
+     * @param server Target server
+     * @param response Success status
+     */
+    static void transfer(UUID[] players, ServerInfo server, IntConsumer response) {
+        instance.transfer(players, server.getName(), response);
+    }
+
+    /**
+     * Disconnects this player from the network
+     */
+    default void disconnect() {
+        disconnect((String) null);
+    }
+
+    /**
+     * Disconnects this player from the network
+     *
+     * @param response Success status
+     */
+    default void disconnect(IntConsumer response) {
+        disconnect((String) null, response);
+    }
+
+    /**
+     * Disconnects this player from the network
+     *
+     * @param reason Disconnect Reason
+     */
+    default void disconnect(String reason) {
+        disconnect(reason, i -> {});
+    }
+
+    /**
+     * Disconnects this player from the network
+     *
+     * @param reason Disconnect Reason
+     * @param response Success status
+     */
+    default void disconnect(String reason, IntConsumer response) {
+        disconnect(new UUID[]{ getUniqueId() }, reason, response);
+    }
+
+    /**
+     * Disconnects these players from the network
+     *
+     * @param players Players to select
+     */
+    static void disconnect(UUID... players) {
+        disconnect(players, (String) null);
+    }
+
+    /**
+     * Disconnects these players from the network
+     *
+     * @param players Players to select
+     * @param response Success status
+     */
+    static void disconnect(UUID[] players, IntConsumer response) {
+        disconnect(players, null, response);
+    }
+
+    /**
+     * Disconnects these players from the network
+     *
+     * @param players Players to select
+     * @param reason Disconnect Reason
+     */
+    static void disconnect(UUID[] players, String reason) {
+        disconnect(players, reason, i -> {});
+    }
+
+    /**
+     * Disconnects these players from the network
+     *
+     * @param players Players to select
+     * @param reason Disconnect Reason
+     * @param response Success status
+     */
+    static void disconnect(UUID[] players, String reason, IntConsumer response) {
+        instance.disconnect(players, reason, response);
+    }
 }

SubServers.Bungee/common/src/net/ME1312/SubServers/Bungee/Library/Fallback/SmartFallback.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Library.Fallback;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.BungeeCommon;
 
@@ -28,7 +29,7 @@ public class SmartFallback implements ReconnectHandler {
     public SmartFallback(ObjectMap<String> settings) {
         dns_forward = settings.getBoolean("DNS-Forward", false);
         if (reconnect == null && settings.getBoolean("Reconnect", false))
-            reconnect = Util.getDespiteException(() -> Util.reflect(ProxyServer.getInstance().getPluginManager().getPlugin("reconnect_yaml").getClass().getClassLoader().loadClass("net.md_5.bungee.module.reconnect.yaml.YamlReconnectHandler").getConstructor()), null);
+            reconnect = Try.all.get(() -> Util.reflect(ProxyServer.getInstance().getPluginManager().getPlugin("reconnect_yaml").getClass().getClassLoader().loadClass("net.md_5.bungee.module.reconnect.yaml.YamlReconnectHandler").getConstructor()));
     }
 
     @Override
@@ -152,7 +153,7 @@ public class SmartFallback implements ReconnectHandler {
                 }
 
                 if (valid) {
-                    List<ServerInfo> servers = (score.keySet().contains(confidence))?score.get(confidence):new LinkedList<ServerInfo>();
+                    List<ServerInfo> servers = (score.containsKey(confidence))?score.get(confidence):new LinkedList<ServerInfo>();
                     servers.add(server);
                     score.put(confidence, servers);
                 }
@@ -177,7 +178,7 @@ public class SmartFallback implements ReconnectHandler {
      * @param inspector Inspector
      */
     public static void addInspector(FallbackInspector inspector) {
-        if (Util.isNull(inspector)) throw new NullPointerException();
+        Util.nullpo(inspector);
         inspectors.add(inspector);
     }
 
@@ -187,8 +188,8 @@ public class SmartFallback implements ReconnectHandler {
      * @param inspector Inspector
      */
     public static void removeInspector(FallbackInspector inspector) {
-        if (Util.isNull(inspector)) throw new NullPointerException();
-        Util.isException(() -> inspectors.remove(inspector));
+        Util.nullpo(inspector);
+        Try.all.run(() -> inspectors.remove(inspector));
     }
 
     @Override

SubServers.Bungee/common/src/net/ME1312/SubServers/Bungee/Library/Metrics.java

@@ -0,0 +1,909 @@
+package net.ME1312.SubServers.Bungee.Library;
+
+import net.ME1312.SubServers.Bungee.BungeeAPI;
+import net.ME1312.SubServers.Bungee.BungeeCommon;
+
+import gnu.trove.map.hash.TIntObjectHashMap;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.plugin.Plugin;
+import net.md_5.bungee.config.Configuration;
+import net.md_5.bungee.config.ConfigurationProvider;
+import net.md_5.bungee.config.YamlConfiguration;
+import net.md_5.bungee.protocol.ProtocolConstants;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.*;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+import java.util.zip.GZIPOutputStream;
+
+/**
+ * SubServers BStats Metrics Implementation
+ */
+public class Metrics {
+
+    private final Plugin plugin;
+
+    private final MetricsBase metricsBase;
+
+    private boolean enabled;
+
+    private String serverUUID;
+
+    private boolean logErrors = false;
+
+    private boolean logSentData;
+
+    private boolean logResponseStatusText;
+
+    /**
+     * Creates a new Metrics instance.
+     *
+     * @param plugin Your plugin instance.
+     * @param serviceId The id of the service. It can be found at <a
+     *     href="https://bstats.org/what-is-my-plugin-id">What is my plugin id?</a>
+     */
+    public Metrics(Plugin plugin, int serviceId) {
+        this.plugin = plugin;
+        try {
+            loadConfig();
+        } catch (IOException e) {
+            // Failed to load configuration
+            plugin.getLogger().log(Level.WARNING, "Failed to load bStats config!", e);
+            metricsBase = null;
+            return;
+        }
+        metricsBase =
+                new MetricsBase(
+                        "bungeecord",
+                        serverUUID,
+                        serviceId,
+                        enabled,
+                        this::appendPlatformData,
+                        this::appendServiceData,
+                        null,
+                        () -> true,
+                        (message, error) -> this.plugin.getLogger().log(Level.WARNING, message, error),
+                        (message) -> this.plugin.getLogger().log(Level.INFO, message),
+                        logErrors,
+                        logSentData,
+                        logResponseStatusText);
+    }
+
+    /** Loads the bStats configuration. */
+    private void loadConfig() throws IOException {
+        File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+        bStatsFolder.mkdirs();
+        File configFile = new File(bStatsFolder, "config.yml");
+        if (!configFile.exists()) {
+            writeFile(
+                    configFile,
+                    "# bStats (https://bStats.org) collects some basic information for plugin authors, like how",
+                    "# many people use their plugin and their total player count. It's recommended to keep bStats",
+                    "# enabled, but if you're not comfortable with this, you can turn this setting off. There is no",
+                    "# performance penalty associated with having metrics enabled, and data sent to bStats is fully",
+                    "# anonymous.",
+                    "enabled: true",
+                    "serverUuid: \"" + UUID.randomUUID() + "\"",
+                    "logFailedRequests: false",
+                    "logSentData: false",
+                    "logResponseStatusText: false");
+        }
+        Configuration configuration =
+                ConfigurationProvider.getProvider(YamlConfiguration.class).load(configFile);
+        // Load configuration
+        enabled = configuration.getBoolean("enabled", true);
+        serverUUID = configuration.getString("serverUuid");
+        logErrors = configuration.getBoolean("logFailedRequests", false);
+        logSentData = configuration.getBoolean("logSentData", false);
+        logResponseStatusText = configuration.getBoolean("logResponseStatusText", false);
+    }
+
+    private void writeFile(File file, String... lines) throws IOException {
+        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file))) {
+            for (String line : lines) {
+                bufferedWriter.write(line);
+                bufferedWriter.newLine();
+            }
+        }
+    }
+
+    private static final AdvancedPie PLAYER_VERSIONS;
+    static {
+        final int[] PROTOCOL_VERSIONS;
+        final String[] PROTOCOL_NAMES;
+        {
+            TIntObjectHashMap<String> protocols = new TIntObjectHashMap<String>();
+            try {
+                for (Field f : ProtocolConstants.class.getDeclaredFields()) {
+                    int fm = f.getModifiers();
+                    if (Modifier.isPublic(fm) && Modifier.isStatic(fm) && Modifier.isFinal(fm) && f.getType() == int.class && f.getName().startsWith("MINECRAFT_")) {
+                        protocols.put(f.getInt(null), f.getName().substring(10).replace('_', '.'));
+                    }
+                }
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+            PROTOCOL_VERSIONS = protocols.keys();
+            PROTOCOL_NAMES = new String[PROTOCOL_VERSIONS.length];
+
+            Arrays.sort(PROTOCOL_VERSIONS);
+            for (int i = 0; i < PROTOCOL_VERSIONS.length; ++i) {
+                PROTOCOL_NAMES[i] = protocols.get(PROTOCOL_VERSIONS[i]);
+            }
+        }
+
+        PLAYER_VERSIONS = new AdvancedPie("player_versions", () -> {
+            int[] players = new int[PROTOCOL_VERSIONS.length];
+            for (ProxiedPlayer player : ProxyServer.getInstance().getPlayers()) {
+                int i = Arrays.binarySearch(PROTOCOL_VERSIONS, player.getPendingConnection().getVersion());
+                if (i != -1) {
+                    ++players[i];
+                }
+            }
+
+            HashMap<String, Integer> map = new HashMap<String, Integer>();
+            for (int i = 0; i < PROTOCOL_NAMES.length; ++i) if (players[i] != 0) {
+                map.put(PROTOCOL_NAMES[i], players[i]);
+            }
+            return map;
+        });
+    }
+
+    /**
+     * Add subservers platform information as custom charts
+     */
+    public Metrics addPlatformCharts() {
+        return addCustomChart(new SimplePie("subservers_version", () -> BungeeAPI.getInstance().getWrapperVersion().toString())).addCustomChart(PLAYER_VERSIONS);
+    }
+
+    /**
+     * Adds a custom chart.
+     *
+     * @param chart The chart to add.
+     */
+    public Metrics addCustomChart(CustomChart chart) {
+        metricsBase.addCustomChart(chart);
+        return this;
+    }
+
+    private void appendPlatformData(JsonObjectBuilder builder) {
+        builder.appendField("playerAmount", plugin.getProxy().getOnlineCount());
+        builder.appendField("managedServers", ((BungeeCommon) plugin.getProxy()).getServersCopy().size());
+        builder.appendField("onlineMode", plugin.getProxy().getConfig().isOnlineMode() ? 1 : 0);
+        builder.appendField("bungeecordVersion", plugin.getProxy().getVersion());
+        builder.appendField("javaVersion", System.getProperty("java.version"));
+        builder.appendField("osName", System.getProperty("os.name"));
+        builder.appendField("osArch", System.getProperty("os.arch"));
+        builder.appendField("osVersion", System.getProperty("os.version"));
+        builder.appendField("coreCount", Runtime.getRuntime().availableProcessors());
+    }
+
+    private void appendServiceData(JsonObjectBuilder builder) {
+        builder.appendField("pluginVersion", plugin.getDescription().getVersion());
+    }
+
+    public static class MetricsBase {
+
+        /** The version of the Metrics class. */
+        public static final String METRICS_VERSION = "3.0.0";
+
+        private static final ScheduledExecutorService scheduler =
+                Executors.newScheduledThreadPool(1, task -> new Thread(task, "bStats-Metrics"));
+
+        private static final String REPORT_URL = "https://bStats.org/api/v2/data/%s";
+
+        private final String platform;
+
+        private final String serverUuid;
+
+        private final int serviceId;
+
+        private final Consumer<JsonObjectBuilder> appendPlatformDataConsumer;
+
+        private final Consumer<JsonObjectBuilder> appendServiceDataConsumer;
+
+        private final Consumer<Runnable> submitTaskConsumer;
+
+        private final Supplier<Boolean> checkServiceEnabledSupplier;
+
+        private final BiConsumer<String, Throwable> errorLogger;
+
+        private final Consumer<String> infoLogger;
+
+        private final boolean logErrors;
+
+        private final boolean logSentData;
+
+        private final boolean logResponseStatusText;
+
+        private final Set<CustomChart> customCharts = new HashSet<>();
+
+        private final boolean enabled;
+
+        /**
+         * Creates a new MetricsBase class instance.
+         *
+         * @param platform The platform of the service.
+         * @param serviceId The id of the service.
+         * @param serverUuid The server uuid.
+         * @param enabled Whether or not data sending is enabled.
+         * @param appendPlatformDataConsumer A consumer that receives a {@code JsonObjectBuilder} and
+         *     appends all platform-specific data.
+         * @param appendServiceDataConsumer A consumer that receives a {@code JsonObjectBuilder} and
+         *     appends all service-specific data.
+         * @param submitTaskConsumer A consumer that takes a runnable with the submit task. This can be
+         *     used to delegate the data collection to a another thread to prevent errors caused by
+         *     concurrency. Can be {@code null}.
+         * @param checkServiceEnabledSupplier A supplier to check if the service is still enabled.
+         * @param errorLogger A consumer that accepts log message and an error.
+         * @param infoLogger A consumer that accepts info log messages.
+         * @param logErrors Whether or not errors should be logged.
+         * @param logSentData Whether or not the sent data should be logged.
+         * @param logResponseStatusText Whether or not the response status text should be logged.
+         */
+        public MetricsBase(
+                String platform,
+                String serverUuid,
+                int serviceId,
+                boolean enabled,
+                Consumer<JsonObjectBuilder> appendPlatformDataConsumer,
+                Consumer<JsonObjectBuilder> appendServiceDataConsumer,
+                Consumer<Runnable> submitTaskConsumer,
+                Supplier<Boolean> checkServiceEnabledSupplier,
+                BiConsumer<String, Throwable> errorLogger,
+                Consumer<String> infoLogger,
+                boolean logErrors,
+                boolean logSentData,
+                boolean logResponseStatusText) {
+            this.platform = platform;
+            this.serverUuid = serverUuid;
+            this.serviceId = serviceId;
+            this.enabled = enabled;
+            this.appendPlatformDataConsumer = appendPlatformDataConsumer;
+            this.appendServiceDataConsumer = appendServiceDataConsumer;
+            this.submitTaskConsumer = submitTaskConsumer;
+            this.checkServiceEnabledSupplier = checkServiceEnabledSupplier;
+            this.errorLogger = errorLogger;
+            this.infoLogger = infoLogger;
+            this.logErrors = logErrors;
+            this.logSentData = logSentData;
+            this.logResponseStatusText = logResponseStatusText;
+            checkRelocation();
+            if (enabled) {
+                // WARNING: Removing the option to opt-out will get your plugin banned from bStats
+                startSubmitting();
+            }
+        }
+
+        public void addCustomChart(CustomChart chart) {
+            this.customCharts.add(chart);
+        }
+
+        private void startSubmitting() {
+            final Runnable submitTask =
+                    () -> {
+                        if (!enabled || !checkServiceEnabledSupplier.get()) {
+                            // Submitting data or service is disabled
+                            scheduler.shutdown();
+                            return;
+                        }
+                        if (submitTaskConsumer != null) {
+                            submitTaskConsumer.accept(this::submitData);
+                        } else {
+                            this.submitData();
+                        }
+                    };
+            // Many servers tend to restart at a fixed time at xx:00 which causes an uneven distribution
+            // of requests on the
+            // bStats backend. To circumvent this problem, we introduce some randomness into the initial
+            // and second delay.
+            // WARNING: You must not modify and part of this Metrics class, including the submit delay or
+            // frequency!
+            // WARNING: Modifying this code will get your plugin banned on bStats. Just don't do it!
+            long initialDelay = (long) (1000 * 60 * (3 + Math.random() * 3));
+            long secondDelay = (long) (1000 * 60 * (Math.random() * 30));
+            scheduler.schedule(submitTask, initialDelay, TimeUnit.MILLISECONDS);
+            scheduler.scheduleAtFixedRate(
+                    submitTask, initialDelay + secondDelay, 1000 * 60 * 30, TimeUnit.MILLISECONDS);
+        }
+
+        private void submitData() {
+            final JsonObjectBuilder baseJsonBuilder = new JsonObjectBuilder();
+            appendPlatformDataConsumer.accept(baseJsonBuilder);
+            final JsonObjectBuilder serviceJsonBuilder = new JsonObjectBuilder();
+            appendServiceDataConsumer.accept(serviceJsonBuilder);
+            JsonObjectBuilder.JsonObject[] chartData =
+                    customCharts.stream()
+                            .map(customChart -> customChart.getRequestJsonObject(errorLogger, logErrors))
+                            .filter(Objects::nonNull)
+                            .toArray(JsonObjectBuilder.JsonObject[]::new);
+            serviceJsonBuilder.appendField("id", serviceId);
+            serviceJsonBuilder.appendField("customCharts", chartData);
+            baseJsonBuilder.appendField("service", serviceJsonBuilder.build());
+            baseJsonBuilder.appendField("serverUUID", serverUuid);
+            baseJsonBuilder.appendField("metricsVersion", METRICS_VERSION);
+            JsonObjectBuilder.JsonObject data = baseJsonBuilder.build();
+            scheduler.execute(
+                    () -> {
+                        try {
+                            // Send the data
+                            sendData(data);
+                        } catch (Exception e) {
+                            // Something went wrong! :(
+                            if (logErrors) {
+                                errorLogger.accept("Could not submit bStats metrics data", e);
+                            }
+                        }
+                    });
+        }
+
+        private void sendData(JsonObjectBuilder.JsonObject data) throws Exception {
+            if (logSentData) {
+                infoLogger.accept("Sent bStats metrics data: " + data.toString());
+            }
+            String url = String.format(REPORT_URL, platform);
+            HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
+            // Compress the data to save bandwidth
+            byte[] compressedData = compress(data.toString());
+            connection.setRequestMethod("POST");
+            connection.addRequestProperty("Accept", "application/json");
+            connection.addRequestProperty("Connection", "close");
+            connection.addRequestProperty("Content-Encoding", "gzip");
+            connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+            connection.setRequestProperty("Content-Type", "application/json");
+            connection.setRequestProperty("User-Agent", "Metrics-Service/1");
+            connection.setDoOutput(true);
+            try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
+                outputStream.write(compressedData);
+            }
+            StringBuilder builder = new StringBuilder();
+            try (BufferedReader bufferedReader =
+                         new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+                String line;
+                while ((line = bufferedReader.readLine()) != null) {
+                    builder.append(line);
+                }
+            }
+            if (logResponseStatusText) {
+                infoLogger.accept("Sent data to bStats and received response: " + builder);
+            }
+        }
+
+        /** Checks that the class was properly relocated. */
+        private void checkRelocation() {
+            // You can use the property to disable the check in your test environment
+            if (System.getProperty("bstats.relocatecheck") == null
+                    || !System.getProperty("bstats.relocatecheck").equals("false")) {
+                // Maven's Relocate is clever and changes strings, too. So we have to use this little
+                // "trick" ... :D
+                final String defaultPackage =
+                        new String(new byte[] {'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's'});
+                final String examplePackage =
+                        new String(new byte[] {'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
+                // We want to make sure no one just copy & pastes the example and uses the wrong package
+                // names
+                if (MetricsBase.class.getPackage().getName().startsWith(defaultPackage)
+                        || MetricsBase.class.getPackage().getName().startsWith(examplePackage)) {
+                    throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
+                }
+            }
+        }
+
+        /**
+         * Gzips the given string.
+         *
+         * @param str The string to gzip.
+         * @return The gzipped string.
+         */
+        private static byte[] compress(final String str) throws IOException {
+            if (str == null) {
+                return null;
+            }
+            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+            try (GZIPOutputStream gzip = new GZIPOutputStream(outputStream)) {
+                gzip.write(str.getBytes(StandardCharsets.UTF_8));
+            }
+            return outputStream.toByteArray();
+        }
+    }
+
+    public static class DrilldownPie extends CustomChart {
+
+        private final Callable<Map<String, Map<String, Integer>>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public DrilldownPie(String chartId, Callable<Map<String, Map<String, Integer>>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        public JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Map<String, Integer>> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean reallyAllSkipped = true;
+            for (Map.Entry<String, Map<String, Integer>> entryValues : map.entrySet()) {
+                JsonObjectBuilder valueBuilder = new JsonObjectBuilder();
+                boolean allSkipped = true;
+                for (Map.Entry<String, Integer> valueEntry : map.get(entryValues.getKey()).entrySet()) {
+                    valueBuilder.appendField(valueEntry.getKey(), valueEntry.getValue());
+                    allSkipped = false;
+                }
+                if (!allSkipped) {
+                    reallyAllSkipped = false;
+                    valuesBuilder.appendField(entryValues.getKey(), valueBuilder.build());
+                }
+            }
+            if (reallyAllSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class AdvancedPie extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public AdvancedPie(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class MultiLineChart extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public MultiLineChart(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class SimpleBarChart extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SimpleBarChart(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                valuesBuilder.appendField(entry.getKey(), new int[] {entry.getValue()});
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public abstract static class CustomChart {
+
+        private final String chartId;
+
+        protected CustomChart(String chartId) {
+            if (chartId == null) {
+                throw new IllegalArgumentException("chartId must not be null");
+            }
+            this.chartId = chartId;
+        }
+
+        public JsonObjectBuilder.JsonObject getRequestJsonObject(
+                BiConsumer<String, Throwable> errorLogger, boolean logErrors) {
+            JsonObjectBuilder builder = new JsonObjectBuilder();
+            builder.appendField("chartId", chartId);
+            try {
+                JsonObjectBuilder.JsonObject data = getChartData();
+                if (data == null) {
+                    // If the data is null we don't send the chart.
+                    return null;
+                }
+                builder.appendField("data", data);
+            } catch (Throwable t) {
+                if (logErrors) {
+                    errorLogger.accept("Failed to get data for custom chart with id " + chartId, t);
+                }
+                return null;
+            }
+            return builder.build();
+        }
+
+        protected abstract JsonObjectBuilder.JsonObject getChartData() throws Exception;
+    }
+
+    public static class SimplePie extends CustomChart {
+
+        private final Callable<String> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SimplePie(String chartId, Callable<String> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            String value = callable.call();
+            if (value == null || value.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("value", value).build();
+        }
+    }
+
+    public static class AdvancedBarChart extends CustomChart {
+
+        private final Callable<Map<String, int[]>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public AdvancedBarChart(String chartId, Callable<Map<String, int[]>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, int[]> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, int[]> entry : map.entrySet()) {
+                if (entry.getValue().length == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class SingleLineChart extends CustomChart {
+
+        private final Callable<Integer> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SingleLineChart(String chartId, Callable<Integer> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            int value = callable.call();
+            if (value == 0) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("value", value).build();
+        }
+    }
+
+    /**
+     * An extremely simple JSON builder.
+     *
+     * <p>While this class is neither feature-rich nor the most performant one, it's sufficient enough
+     * for its use-case.
+     */
+    public static class JsonObjectBuilder {
+
+        private StringBuilder builder = new StringBuilder();
+
+        private boolean hasAtLeastOneField = false;
+
+        public JsonObjectBuilder() {
+            builder.append("{");
+        }
+
+        /**
+         * Appends a null field to the JSON.
+         *
+         * @param key The key of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendNull(String key) {
+            appendFieldUnescaped(key, "null");
+            return this;
+        }
+
+        /**
+         * Appends a string field to the JSON.
+         *
+         * @param key The key of the field.
+         * @param value The value of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, String value) {
+            if (value == null) {
+                throw new IllegalArgumentException("JSON value must not be null");
+            }
+            appendFieldUnescaped(key, "\"" + escape(value) + "\"");
+            return this;
+        }
+
+        /**
+         * Appends an integer field to the JSON.
+         *
+         * @param key The key of the field.
+         * @param value The value of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, int value) {
+            appendFieldUnescaped(key, String.valueOf(value));
+            return this;
+        }
+
+        /**
+         * Appends an object to the JSON.
+         *
+         * @param key The key of the field.
+         * @param object The object.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, JsonObject object) {
+            if (object == null) {
+                throw new IllegalArgumentException("JSON object must not be null");
+            }
+            appendFieldUnescaped(key, object.toString());
+            return this;
+        }
+
+        /**
+         * Appends a string array to the JSON.
+         *
+         * @param key The key of the field.
+         * @param values The string array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, String[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values)
+                            .map(value -> "\"" + escape(value) + "\"")
+                            .collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends an integer array to the JSON.
+         *
+         * @param key The key of the field.
+         * @param values The integer array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, int[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values).mapToObj(String::valueOf).collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends an object array to the JSON.
+         *
+         * @param key The key of the field.
+         * @param values The integer array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, JsonObject[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values).map(JsonObject::toString).collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends a field to the object.
+         *
+         * @param key The key of the field.
+         * @param escapedValue The escaped value of the field.
+         */
+        private void appendFieldUnescaped(String key, String escapedValue) {
+            if (builder == null) {
+                throw new IllegalStateException("JSON has already been built");
+            }
+            if (key == null) {
+                throw new IllegalArgumentException("JSON key must not be null");
+            }
+            if (hasAtLeastOneField) {
+                builder.append(",");
+            }
+            builder.append("\"").append(escape(key)).append("\":").append(escapedValue);
+            hasAtLeastOneField = true;
+        }
+
+        /**
+         * Builds the JSON string and invalidates this builder.
+         *
+         * @return The built JSON string.
+         */
+        public JsonObject build() {
+            if (builder == null) {
+                throw new IllegalStateException("JSON has already been built");
+            }
+            JsonObject object = new JsonObject(builder.append("}").toString());
+            builder = null;
+            return object;
+        }
+
+        /**
+         * Escapes the given string like stated in https://www.ietf.org/rfc/rfc4627.txt.
+         *
+         * <p>This method escapes only the necessary characters '"', '\'. and '\u0000' - '\u001F'.
+         * Compact escapes are not used (e.g., '\n' is escaped as "\u000a" and not as "\n").
+         *
+         * @param value The value to escape.
+         * @return The escaped value.
+         */
+        private static String escape(String value) {
+            final StringBuilder builder = new StringBuilder();
+            for (int i = 0; i < value.length(); i++) {
+                char c = value.charAt(i);
+                if (c == '"') {
+                    builder.append("\\\"");
+                } else if (c == '\\') {
+                    builder.append("\\\\");
+                } else if (c <= '\u000F') {
+                    builder.append("\\u000").append(Integer.toHexString(c));
+                } else if (c <= '\u001F') {
+                    builder.append("\\u00").append(Integer.toHexString(c));
+                } else {
+                    builder.append(c);
+                }
+            }
+            return builder.toString();
+        }
+
+        /**
+         * A super simple representation of a JSON object.
+         *
+         * <p>This class only exists to make methods of the {@link JsonObjectBuilder} type-safe and not
+         * allow a raw string inputs for methods like {@link JsonObjectBuilder#appendField(String,
+         * JsonObject)}.
+         */
+        public static class JsonObject {
+
+            private final String value;
+
+            private JsonObject(String value) {
+                this.value = value;
+            }
+
+            @Override
+            public String toString() {
+                return value;
+            }
+        }
+    }
+}

SubServers.Bungee/pom.xml

@@ -25,33 +25,23 @@
             <version>1.15-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>net.ME1312.Galaxi</groupId>
-            <artifactId>GalaxiUtil</artifactId>
-            <version>21w24a</version>
-            <scope>compile</scope>
-            <optional>true</optional>
-        </dependency>
         <dependency>
             <groupId>net.ME1312.SubServers</groupId>
             <artifactId>SubServers.Bungee.Common</artifactId>
-            <version>-PLACEHOLDER</version>
+            <version>${project.version}</version>
             <scope>compile</scope>
-            <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>net.ME1312.SubData</groupId>
             <artifactId>Server</artifactId>
-            <version>21w08a</version>
+            <version>23w08b</version>
             <scope>compile</scope>
-            <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>com.dosse.upnp</groupId>
             <artifactId>WaifUPnP</artifactId>
             <version>1.1</version>
             <scope>compile</scope>
-            <optional>true</optional>
         </dependency>
     </dependencies>
 
@@ -94,7 +84,7 @@
                                 <copy file="${basedir}/../Artifacts/SubServers.Client.Universal.jar" tofile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/client.jar" />
                                 <mkdir dir="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates" />
                                 <zip basedir="${basedir}/../SubServers.Creator" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/forge.zip" includes="Forge/**" />
-                                <zip basedir="${basedir}/../SubServers.Creator" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/paper.zip" includes="Paper/**" />
+                                <zip basedir="${basedir}/../SubServers.Creator" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/purpur.zip" includes="Purpur/**" />
                                 <zip basedir="${basedir}/../SubServers.Creator" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/spigot.zip" includes="Spigot/**" />
                                 <zip basedir="${basedir}/../SubServers.Creator" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/sponge.zip" includes="Sponge/**" />
                                 <zip basedir="${basedir}/../SubServers.Creator" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/vanilla.zip" includes="Vanilla/**" />
@@ -117,6 +107,15 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.2.0</version>
+                <configuration>
+                    <finalName>SubServers.Bungee</finalName>
+                    <outputDirectory>../Artifacts/Maven</outputDirectory>
+                </configuration>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-assembly-plugin</artifactId>
@@ -127,9 +126,9 @@
                     <archive>
                         <manifestFile>src/META-INF/MANIFEST.MF</manifestFile>
                     </archive>
-                    <descriptorRefs>
-                        <descriptorRef>jar-with-dependencies</descriptorRef>
-                    </descriptorRefs>
+                    <descriptors>
+                        <descriptor>../SubServers.Client/Common/jar-with-some-dependencies.xml</descriptor>
+                    </descriptors>
                     <appendAssemblyId>false</appendAssemblyId>
                 </configuration>
                 <executions>
@@ -153,15 +152,15 @@
                             <goal>javadoc</goal>
                         </goals>
                         <configuration>
-                            <windowtitle>SubServers.Bungee Javadoc</windowtitle>
-                            <doctitle>SubServers.Bungee Javadoc</doctitle>
+                            <windowtitle>SubServers.Bungee</windowtitle>
+                            <doctitle>SubServers.Bungee ${project.version}</doctitle>
                             <show>protected</show>
                             <destDir>./</destDir>
                             <outputDirectory>${basedir}/../Javadoc/SubServers.Bungee</outputDirectory>
                             <reportOutputDirectory>${basedir}/../Javadoc/SubServers.Bungee</reportOutputDirectory>
                             <additionalOptions>-Xdoclint:none</additionalOptions>
                             <links>
-                                <link>https://dev.me1312.net/jenkins/job/GalaxiEngine/javadoc/GalaxiUtil/</link>
+                                <link>https://dev.me1312.net/jenkins/job/GalaxiEngine/javadoc/GalaxiBase/</link>
                                 <link>https://dev.me1312.net/jenkins/job/SubData/javadoc/Server/</link>
                                 <link>https://ci.md-5.net/job/BungeeCord/ws/api/target/apidocs/</link>
                             </links>

SubServers.Bungee/src/META-INF/MANIFEST.MOD.MF

@@ -1,4 +1,4 @@
 Manifest-Version: 1.0
-Class-Path: libraries/GalaxiEngine.jar libraries/SubDataServer.jar libraries/BungeeCord.jar
+Class-Path: libraries/GalaxiBase.jar libraries/SubDataServer.jar libraries/BungeeCord.jar
 Main-Class: net.ME1312.SubServers.Bungee.Launch
 Implementation-Title: SubServers.Bungee

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubAddHostEvent.java

@@ -24,7 +24,7 @@ public class SubAddHostEvent extends Event implements SubEvent, Cancellable {
      * @param host Host Being Added
      */
     public SubAddHostEvent(UUID player, Host host) {
-        if (Util.isNull(host)) throw new NullPointerException();
+        Util.nullpo(host);
         this.player = player;
         this.host = host;
     }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubAddProxyEvent.java

@@ -18,7 +18,7 @@ public class SubAddProxyEvent extends Event implements SubEvent {
      * @param proxy Host Being Added
      */
     public SubAddProxyEvent(Proxy proxy) {
-        if (Util.isNull(proxy)) throw new NullPointerException();
+        Util.nullpo(proxy);
         this.proxy = proxy;
     }
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubAddServerEvent.java

@@ -27,7 +27,7 @@ public class SubAddServerEvent extends Event implements SubEvent, Cancellable {
      * @param server Server Starting
      */
     public SubAddServerEvent(UUID player, Host host, Server server) {
-        if (Util.isNull(server)) throw new NullPointerException();
+        Util.nullpo(server);
         this.player = player;
         this.host = host;
         this.server = server;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubCreateEvent.java

@@ -36,7 +36,7 @@ public class SubCreateEvent extends Event implements SubEvent, Cancellable {
      * @param port Server Port Number
      */
     public SubCreateEvent(UUID player, Host host, String name, SubCreator.ServerTemplate template, Version version, int port) {
-        if (Util.isNull(host, name, template, port)) throw new NullPointerException();
+        Util.nullpo(host, name, template);
         this.player = player;
         this.host = host;
         this.name = name;
@@ -54,7 +54,7 @@ public class SubCreateEvent extends Event implements SubEvent, Cancellable {
      * @param version Server Version
      */
     public SubCreateEvent(UUID player, SubServer server, SubCreator.ServerTemplate template, Version version) {
-        if (Util.isNull(server)) throw new NullPointerException();
+        Util.nullpo(server);
         this.player = player;
         this.update = server;
         this.name = server.getName();

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubCreatedEvent.java

@@ -39,7 +39,7 @@ public class SubCreatedEvent extends Event implements SubEvent {
      * @param success Success Status
      */
     public SubCreatedEvent(UUID player, Host host, String name, SubCreator.ServerTemplate template, Version version, int port, SubServer server, boolean update, boolean success) {
-        if (Util.isNull(host, name, template, port)) throw new NullPointerException();
+        Util.nullpo(host, name, template);
         this.player = player;
         this.host = host;
         this.name = name;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubEditServerEvent.java

@@ -30,7 +30,7 @@ public class SubEditServerEvent extends Event implements SubEvent, Cancellable {
      * @param edit Edit to make
      */
     public SubEditServerEvent(UUID player, Server server, Pair<String, ?> edit) {
-        if (Util.isNull(server, edit)) throw new NullPointerException();
+        Util.nullpo(server, edit);
         ObjectMap<String> section = new ObjectMap<String>();
         section.set(".", edit.value());
         this.player = player;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubNetworkConnectEvent.java

@@ -20,7 +20,7 @@ public class SubNetworkConnectEvent extends Event implements SubEvent, Cancellab
      * SubData Network Connect Event
      */
     public SubNetworkConnectEvent(DataServer network, DataClient client) {
-        if (Util.isNull(network, client)) throw new NullPointerException();
+        Util.nullpo(network, client);
         this.network = network;
         this.client = client;
     }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubNetworkDisconnectEvent.java

@@ -20,7 +20,7 @@ public class SubNetworkDisconnectEvent extends Event implements SubEvent {
      * SubData Network Disconnect Event
      */
     public SubNetworkDisconnectEvent(DataServer network, DataClient client, DisconnectReason reason) {
-        if (Util.isNull(network, client, reason)) throw new NullPointerException();
+        Util.nullpo(network, client, reason);
         this.network = network;
         this.client = client;
         this.reason = reason;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubNetworkLoginEvent.java

@@ -18,7 +18,7 @@ public class SubNetworkLoginEvent extends Event implements SubEvent {
      * SubData Network Login Event
      */
     public SubNetworkLoginEvent(DataServer network, DataClient client) {
-        if (Util.isNull(network, client)) throw new NullPointerException();
+        Util.nullpo(network, client);
         this.network = network;
         this.client = client;
     }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubRemoveHostEvent.java

@@ -24,7 +24,7 @@ public class SubRemoveHostEvent extends Event implements SubEvent, Cancellable {
      * @param host Host to be added
      */
     public SubRemoveHostEvent(UUID player, Host host) {
-        if (Util.isNull(host)) throw new NullPointerException();
+        Util.nullpo(host);
         this.player = player;
         this.host = host;
     }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubRemoveProxyEvent.java

@@ -18,7 +18,7 @@ public class SubRemoveProxyEvent extends Event implements SubEvent {
      * @param proxy Host Being Added
      */
     public SubRemoveProxyEvent(Proxy proxy) {
-        if (Util.isNull(proxy)) throw new NullPointerException();
+        Util.nullpo(proxy);
         this.proxy = proxy;
     }
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubRemoveServerEvent.java

@@ -27,7 +27,7 @@ public class SubRemoveServerEvent extends Event implements SubEvent, Cancellable
      * @param server Server Starting
      */
     public SubRemoveServerEvent(UUID player, Host host, Server server) {
-        if (Util.isNull(server)) throw new NullPointerException();
+        Util.nullpo(server);
         this.player = player;
         this.host = host;
         this.server = server;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubSendCommandEvent.java

@@ -1,7 +1,7 @@
 package net.ME1312.SubServers.Bungee.Event;
 
 import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubServers.Bungee.Host.SubServer;
+import net.ME1312.SubServers.Bungee.Host.Server;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
 
 import net.md_5.bungee.api.plugin.Cancellable;
@@ -15,20 +15,24 @@ import java.util.UUID;
 public class SubSendCommandEvent extends Event implements SubEvent, Cancellable {
     private boolean cancelled = false;
     private UUID player;
-    private SubServer server;
+    private Server server;
     private String command;
+    private UUID target;
 
     /**
      * Server Command Event
      *
-     * @param player Player Commanding Server
-     * @param server Server being Commanded
+     * @param player Player Commanding
+     * @param server Target Server
+     * @param command Command to Send
+     * @param target Player that will send
      */
-    public SubSendCommandEvent(UUID player, SubServer server, String command) {
-        if (Util.isNull(server, command)) throw new NullPointerException();
+    public SubSendCommandEvent(UUID player, Server server, String command, UUID target) {
+        Util.nullpo(server, command);
         this.player = player;
         this.server = server;
         this.command = command;
+        this.target = target;
     }
 
     /**
@@ -36,7 +40,7 @@ public class SubSendCommandEvent extends Event implements SubEvent, Cancellable
      *
      * @return The Server Effected
      */
-    public SubServer getServer() { return server; }
+    public Server getServer() { return server; }
 
     /**
      * Gets the player that triggered the Event
@@ -63,6 +67,15 @@ public class SubSendCommandEvent extends Event implements SubEvent, Cancellable
         command = value;
     }
 
+    /**
+     * Gets the Player that will be forced to send the Command
+     *
+     * @return Target Player or null if Console
+     */
+    public UUID getTarget() {
+        return target;
+    }
+
     /**
      * Gets the Cancelled Status
      *

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubStartEvent.java

@@ -24,7 +24,7 @@ public class SubStartEvent extends Event implements SubEvent, Cancellable {
      * @param server Server Starting
      */
     public SubStartEvent(UUID player, SubServer server) {
-        if (Util.isNull(server)) throw new NullPointerException();
+        Util.nullpo(server);
         this.player = player;
         this.server = server;
     }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubStartedEvent.java

@@ -19,7 +19,7 @@ public class SubStartedEvent extends Event implements SubEvent {
      * @param server Server Starting
      */
     public SubStartedEvent(SubServer server) {
-        if (Util.isNull(server)) throw new NullPointerException();
+        Util.nullpo(server);
         this.server = server;
     }
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubStopEvent.java

@@ -26,7 +26,7 @@ public class SubStopEvent extends Event implements SubEvent, Cancellable {
      * @param force If it was a Forced Shutdown
      */
     public SubStopEvent(UUID player, SubServer server, boolean force) {
-        if (Util.isNull(server, force)) throw new NullPointerException();
+        Util.nullpo(server, force);
         this.player = player;
         this.server = server;
         this.force = force;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Event/SubStoppedEvent.java

@@ -18,7 +18,7 @@ public class SubStoppedEvent extends Event implements SubEvent {
      * @param server Server that Stopped
      */
     public SubStoppedEvent(SubServer server) {
-        if (Util.isNull(server)) throw new NullPointerException();
+        Util.nullpo(server);
         this.server = server;
     }
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/Executable.java

@@ -1,11 +1,12 @@
 package net.ME1312.SubServers.Bungee.Host;
 
 import net.ME1312.Galaxi.Library.Platform;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.JNA;
 
 import java.io.File;
-import java.io.IOException;
+import java.util.stream.Stream;
 
 /**
  * Executable Handler Class
@@ -40,7 +41,7 @@ public class Executable {
     }
 
     static {
-        USE_SESSION_TRACKING = Platform.getSystem() != Platform.WINDOWS && Util.getDespiteException(() -> {
+        USE_SESSION_TRACKING = Platform.getSystem() != Platform.WINDOWS && Try.all.get(() -> {
             Process test = Runtime.getRuntime().exec(new String[]{"setsid", "bash", "-c", "exit 0"});
             test.waitFor(); // The purpose of this block is to test for the 'setsid' command
             return test.exitValue() == 0;
@@ -93,18 +94,28 @@ public class Executable {
      */
     public static void terminate(Process process) {
         if (process.isAlive()) {
-            Long pid = pid(process);
-            if (pid != null) try {
-                if (Platform.getSystem() == Platform.WINDOWS) {
-                    Runtime.getRuntime().exec(new String[]{"taskkill.exe", "/T", "/F", "/PID", pid.toString()}).waitFor();
-                } else if (USE_SESSION_TRACKING) {
-                    Runtime.getRuntime().exec(new String[]{"bash", "-c", "kill -9 $(ps -s " + pid + " -o pid=)"}).waitFor();
-                }
-            } catch (IOException | InterruptedException e) {}
+            Long pid;
+            if (Platform.getSystem() == Platform.WINDOWS) {
+                if ((pid = pid(process)) != null) Try.all.run(() -> Runtime.getRuntime().exec(new String[]{"taskkill.exe", "/T", "/F", "/PID", pid.toString()}).waitFor());
+            } else if (USE_SESSION_TRACKING) {
+                if ((pid = pid(process)) != null) Try.all.run(() -> Runtime.getRuntime().exec(new String[]{"bash", "-c", "kill -9 $(ps -s " + pid + " -o pid=)"}).waitFor());
+            }
 
-            if (process.isAlive()) {
+            if (process.isAlive() && terminate9(process)) {
                 process.destroyForcibly();
             }
         }
     }
+
+    private static boolean terminate9(Object handle) {
+        try { // Attempt iteration over Java 9 ProcessHandle objects
+            Class<?> clazz = handle.getClass();
+            Stream<?> children = (Stream<?>) clazz.getMethod("children").invoke(handle);
+            clazz.getMethod("destroyForcibly").invoke(handle);
+            children.forEach(Executable::terminate9);
+            return false;
+        } catch (Throwable e) {
+            return true;
+        }
+    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/External/ExternalHost.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Host.External;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.ClientHandler;
 import net.ME1312.SubData.Server.DataClient;
@@ -78,8 +79,9 @@ public class ExternalHost extends Host implements ClientHandler {
 
     public void setSubData(DataClient client, int channel) {
         if (channel < 0) throw new IllegalArgumentException("Subchannel ID cannot be less than zero");
+        if (client == null && channel == 0) available = false;
         if (client != null || channel == 0) {
-            if (!subdata.keySet().contains(channel) || (channel == 0 && (client == null || subdata.get(channel) == null))) {
+            if (!subdata.containsKey(channel) || (channel == 0 && (client == null || subdata.get(channel) == null))) {
                 subdata.put(channel, (SubDataClient) client);
                 if (client != null && (client.getHandler() == null || !equals(client.getHandler()))) ((SubDataClient) client).setHandler(this);
             }
@@ -106,16 +108,27 @@ public class ExternalHost extends Host implements ClientHandler {
             client.sendPacket(new PacketOutExReset("Prevent Desync"));
             clean = true;
         }
+        HashSet<String> served = new HashSet<String>();
+        LinkedList<PacketOut> queue = this.queue; this.queue = new LinkedList<PacketOut>();
+        PacketOut[] payload = new PacketOut[queue.size()];
+        for (int i = 0; i < payload.length; ++i) {
+            PacketOut packet = queue.get(i);
+            if (packet instanceof PacketExAddServer) served.add(((PacketExAddServer) packet).peek());
+            payload[i] = packet;
+        }
         for (SubServer server : servers.values()) {
-            client.sendPacket(new PacketExAddServer((ExternalSubServer) server, (server.isRunning())?((ExternalSubLogger) server.getLogger()).getExternalAddress():null, data -> {
-                if (data.contains(0x0002)) ((ExternalSubServer) server).started(data.getUUID(0x0002));
-            }));
-        }
-        while (queue.size() != 0) {
-            client.sendPacket(queue.get(0));
-            queue.remove(0);
+            if (!served.contains(server.getName())) {
+                client.sendPacket(new PacketExAddServer((ExternalSubServer) server, (server.isRunning())?((ExternalSubLogger) server.getLogger()).getExternalAddress():null, data -> {
+                    if (data.contains(0x0002)) ((ExternalSubServer) server).started(data.getUUID(0x0002));
+                    else if (server.isRunning()) ((ExternalSubServer) server).stopped(false);
+                }));
+            }
         }
+        client.sendPacket(payload);
         available = true;
+        while (this.queue.size() != 0) {
+            client.sendPacket(this.queue.remove(0));
+        }
     }
 
     @Override
@@ -160,8 +173,8 @@ public class ExternalHost extends Host implements ClientHandler {
 
     @Override
     public SubServer getSubServer(String name) {
-        if (Util.isNull(name)) throw new NullPointerException();
-        return getSubServers().get(name.toLowerCase());
+        if (Util.isNull(name)) return null;
+        return servers.get(name.toLowerCase());
     }
 
     @Override
@@ -178,8 +191,8 @@ public class ExternalHost extends Host implements ClientHandler {
         if (!event.isCancelled()) {
             queue(new PacketExAddServer(((ExternalSubServer) server), (server.isRunning())?((ExternalSubLogger) server.getLogger()).getExternalAddress():null, data -> {
                 if (data.contains(0x0002)) ((ExternalSubServer) server).started(data.getUUID(0x0002));
+                ((ExternalSubServer) server).registered(true);
             }));
-            ((ExternalSubServer) server).registered(true);
             servers.put(server.getName().toLowerCase(), server);
             return true;
         } else {
@@ -189,7 +202,7 @@ public class ExternalHost extends Host implements ClientHandler {
 
     @Override
     protected boolean removeSubServer(UUID player, String name, boolean forced) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
+        Util.nullpo(name);
         ExternalSubServer server = (ExternalSubServer) servers.get(name.toLowerCase());
 
         SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, server);
@@ -214,7 +227,7 @@ public class ExternalHost extends Host implements ClientHandler {
 
     @Override
     protected boolean recycleSubServer(UUID player, String name, boolean forced) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
+        Util.nullpo(name);
         ExternalSubServer s = (ExternalSubServer) servers.get(name.toLowerCase());
         String server = s.getName();
 
@@ -256,7 +269,7 @@ public class ExternalHost extends Host implements ClientHandler {
 
     @Override
     protected boolean deleteSubServer(UUID player, String name, boolean forced) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
+        Util.nullpo(name);
         ExternalSubServer s = (ExternalSubServer) servers.get(name.toLowerCase());
         String server = s.getName();
 
@@ -298,7 +311,7 @@ public class ExternalHost extends Host implements ClientHandler {
 
     @Override
     public boolean destroy() {
-        if (Util.getDespiteException(() -> Util.reflect(SubProxy.class.getDeclaredField("running"), plugin), true)) {
+        if (Try.all.get(() -> Util.reflect(SubProxy.class.getDeclaredField("running"), plugin), true)) {
             return super.destroy();
         }
         return true;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/External/ExternalSubCreator.java

@@ -1,19 +1,21 @@
 package net.ME1312.SubServers.Bungee.Host.External;
 
-import net.ME1312.Galaxi.Library.Callback.Callback;
 import net.ME1312.Galaxi.Library.Config.YAMLConfig;
 import net.ME1312.Galaxi.Library.Container.ContainedPair;
 import net.ME1312.Galaxi.Library.Container.Container;
 import net.ME1312.Galaxi.Library.Container.Pair;
 import net.ME1312.Galaxi.Library.Container.Value;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.Galaxi.Library.UniversalFile;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.Galaxi.Library.Version.Version;
 import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.SubServers.Bungee.Event.SubCreateEvent;
 import net.ME1312.SubServers.Bungee.Event.SubCreatedEvent;
-import net.ME1312.SubServers.Bungee.Host.*;
+import net.ME1312.SubServers.Bungee.Host.Host;
+import net.ME1312.SubServers.Bungee.Host.SubCreator;
+import net.ME1312.SubServers.Bungee.Host.SubLogger;
+import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.Host.SubServer.StopAction;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.Network.Packet.PacketExConfigureHost;
@@ -30,6 +32,7 @@ import java.io.File;
 import java.lang.reflect.InvocationTargetException;
 import java.net.InetSocketAddress;
 import java.util.*;
+import java.util.function.Consumer;
 
 /**
  * External SubCreator Class
@@ -55,7 +58,7 @@ public class ExternalSubCreator extends SubCreator {
      */
     public ExternalSubCreator(ExternalHost host, Range<Integer> ports, boolean log, String gitBash) {
         if (!ports.hasLowerBound() || !ports.hasUpperBound()) throw new IllegalArgumentException("Port range is not bound");
-        if (Util.isNull(host, ports, log, gitBash)) throw new NullPointerException();
+        Util.nullpo(host, ports, log, gitBash);
         this.host = host;
         this.ports = ports;
         this.log = new Container<Boolean>(log);
@@ -67,32 +70,32 @@ public class ExternalSubCreator extends SubCreator {
     @Override
     public void reload() {
         templatesR.clear();
-        if (new UniversalFile(host.plugin.dir, "SubServers:Templates").exists()) for (File file : new UniversalFile(host.plugin.dir, "SubServers:Templates").listFiles()) {
+        if (new File(host.plugin.dir, "SubServers/Templates").exists()) for (File file : new File(host.plugin.dir, "SubServers/Templates").listFiles()) {
             try {
                 if (file.isDirectory() && !file.getName().endsWith(".x")) {
-                    ObjectMap<String> config = (new UniversalFile(file, "template.yml").exists())?new YAMLConfig(new UniversalFile(file, "template.yml")).get().getMap("Template", new ObjectMap<String>()):new ObjectMap<String>();
-                    ServerTemplate template = loadTemplate(file.getName(), config.getBoolean("Enabled", true), config.getRawString("Icon", "::NULL::"), file, config.getMap("Build", new ObjectMap<String>()), config.getMap("Settings", new ObjectMap<String>()));
+                    ObjectMap<String> config = (new File(file, "template.yml").exists())? new YAMLConfig(new File(file, "template.yml")).get().getMap("Template", new ObjectMap<String>()) : new ObjectMap<String>();
+                    ServerTemplate template = loadTemplate(file.getName(), config.getBoolean("Enabled", true), config.getBoolean("Internal", false), config.getString("Icon", "::NULL::"), file, config.getMap("Build", new ObjectMap<String>()), config.getMap("Settings", new ObjectMap<String>()));
                     templatesR.put(file.getName().toLowerCase(), template);
-                    if (config.getKeys().contains("Display")) template.setDisplayName(config.getString("Display"));
+                    if (config.getKeys().contains("Display")) template.setDisplayName(Util.unescapeJavaString(config.getString("Display")));
                 }
             } catch (Exception e) {
-                System.out.println(host.getName() + "/Creator > Couldn't load template: " + file.getName());
+                Logger.get(host.getName()).severe("Couldn't load template: " + file.getName());
                 e.printStackTrace();
             }
         }
 
-        if (host.available && !Util.getDespiteException(() -> Util.reflect(SubProxy.class.getDeclaredField("reloading"), host.plugin), false)) {
-            host.queue(new PacketExConfigureHost(host.plugin, host));
-            host.queue(new PacketExUploadTemplates(host.plugin));
-            if (enableRT == null || enableRT) host.queue(new PacketExDownloadTemplates(host.plugin, host));
+        if (host.available && !Try.all.get(() -> Util.reflect(SubProxy.class.getDeclaredField("reloading"), host.plugin), false)) {
+            host.queue(new PacketExConfigureHost(host.plugin, host), new PacketExUploadTemplates(host.plugin, () -> {
+                if (enableRT == null || enableRT) host.queue(new PacketExDownloadTemplates(host.plugin, host));
+            }));
         }
     }
 
     @Override
-    public boolean create(UUID player, String name, ServerTemplate template, Version version, Integer port, Callback<SubServer> callback) {
-        if (Util.isNull(name, template)) throw new NullPointerException();
-        if (host.isAvailable() && host.isEnabled() && template.isEnabled() && !SubAPI.getInstance().getSubServers().keySet().contains(name.toLowerCase()) && !SubCreator.isReserved(name) && (version != null || !template.requiresVersion())) {
-            StackTraceElement[] origin = new Exception().getStackTrace();
+    public boolean create(UUID player, String name, ServerTemplate template, Version version, Integer port, Consumer<SubServer> callback) {
+        Util.nullpo(name, template);
+        if (host.isAvailable() && host.isEnabled() && template.isEnabled() && !SubAPI.getInstance().getSubServers().containsKey(name.toLowerCase()) && !SubCreator.isReserved(name) && (version != null || !template.requiresVersion())) {
+            StackTraceElement[] origin = new Throwable().getStackTrace();
 
             if (port == null) {
                 Container<Integer> i = new Container<Integer>(ports.lowerEndpoint() - 1);
@@ -115,7 +118,6 @@ public class ExternalSubCreator extends SubCreator {
                 logger.start();
                 host.queue(new PacketExCreateServer(player, name, template, version, port, logger.getExternalAddress(), data -> {
                     finish(player, null, name, template, version, fport, prefix, origin, data, callback);
-                    logger.stop();
                     this.thread.remove(name.toLowerCase());
                 }));
                 return true;
@@ -124,9 +126,9 @@ public class ExternalSubCreator extends SubCreator {
                 return false;
             }
         } else return false;
-    } private <T> void callback(StackTraceElement[] origin, Callback<T> callback, T value) {
+    } private <T> void callback(StackTraceElement[] origin, Consumer<T> callback, T value) {
         if (callback != null) try {
-            callback.run(value);
+            callback.accept(value);
         } catch (Throwable e) {
             Throwable ew = new InvocationTargetException(e);
             ew.setStackTrace(origin);
@@ -135,11 +137,11 @@ public class ExternalSubCreator extends SubCreator {
     }
 
     @Override
-    public boolean update(UUID player, SubServer server, ServerTemplate template, Version version, Callback<Boolean> callback) {
-        if (Util.isNull(server)) throw new NullPointerException();
+    public boolean update(UUID player, SubServer server, ServerTemplate template, Version version, Consumer<Boolean> callback) {
+        Util.nullpo(server);
         final ServerTemplate ft = (template == null)?server.getTemplate():template;
         if (host.isAvailable() && host.isEnabled() && host == server.getHost() && server.isAvailable() && !server.isRunning() && ft != null && ft.isEnabled() && ft.canUpdate() && (version != null || !ft.requiresVersion())) {
-            StackTraceElement[] origin = new Exception().getStackTrace();
+            StackTraceElement[] origin = new Throwable().getStackTrace();
 
             String name = server.getName();
             String prefix = name + File.separator + "Updater";
@@ -154,9 +156,8 @@ public class ExternalSubCreator extends SubCreator {
                 host.queue(new PacketExCreateServer(player, server, ft, version, logger.getExternalAddress(), data -> {
                     finish(player, server, server.getName(), ft, version, server.getAddress().getPort(), prefix, origin, data, s -> {
                         ((ExternalSubServer) server).updating(false);
-                        if (callback != null) callback.run(s != null);
+                        if (callback != null) callback.accept(s != null);
                     });
-                    logger.stop();
                     this.thread.remove(name.toLowerCase());
                 }));
                 return true;
@@ -167,17 +168,18 @@ public class ExternalSubCreator extends SubCreator {
         } else return false;
     }
 
-    private void finish(UUID player, SubServer update, String name, ServerTemplate template, Version version, int port, String prefix, StackTraceElement[] origin, ObjectMap<Integer> data, Callback<SubServer> callback) {
+    private void finish(UUID player, SubServer update, String name, ServerTemplate template, Version version, int port, String prefix, StackTraceElement[] origin, ObjectMap<Integer> data, Consumer<SubServer> callback) {
         try {
             if (data.getInt(0x0001) == 0) {
                 Logger.get(prefix).info("Saving...");
                 SubServer subserver = update;
                 if (update == null || update.getTemplate() != template || template.getBuildOptions().getBoolean("Update-Settings", false)) {
-                    if (host.plugin.exServers.keySet().contains(name.toLowerCase()))
+                    if (host.plugin.exServers.containsKey(name.toLowerCase()))
                         host.plugin.exServers.remove(name.toLowerCase());
 
                     ObjectMap<String> server = new ObjectMap<String>();
                     ObjectMap<String> config = new ObjectMap<String>((Map<String, ?>) data.getObject(0x0002));
+                    if (config.contains("Directory") && (update != null || !template.getConfigOptions().contains("Directory"))) config.remove("Directory");
 
                     if (update == null) {
                         server.set("Enabled", true);
@@ -202,14 +204,14 @@ public class ExternalSubCreator extends SubCreator {
                     }
                     server.setAll(config);
 
-                    if (update != null) Util.isException(() -> update.getHost().forceRemoveSubServer(name));
-                    subserver = host.constructSubServer(name, server.getBoolean("Enabled"), port, ChatColor.translateAlternateColorCodes('&', server.getString("Motd")), server.getBoolean("Log"),
-                            server.getRawString("Directory"), server.getRawString("Executable"), server.getRawString("Stop-Command"), server.getBoolean("Hidden"), server.getBoolean("Restricted"));
+                    if (update != null) Try.all.run(() -> update.getHost().forceRemoveSubServer(name));
+                    subserver = host.constructSubServer(name, server.getBoolean("Enabled"), port, ChatColor.translateAlternateColorCodes('&', Util.unescapeJavaString(server.getString("Motd"))), server.getBoolean("Log"),
+                            server.getString("Directory"), server.getString("Executable"), server.getString("Stop-Command"), server.getBoolean("Hidden"), server.getBoolean("Restricted"));
 
-                    if (server.getString("Display").length() > 0) subserver.setDisplayName(server.getString("Display"));
-                    subserver.setTemplate(server.getRawString("Template"));
+                    if (server.getString("Display").length() > 0) subserver.setDisplayName(Util.unescapeJavaString(server.getString("Display")));
+                    subserver.setTemplate(server.getString("Template"));
                     for (String group : server.getStringList("Group")) subserver.addGroup(group);
-                    SubServer.StopAction action = Util.getDespiteException(() -> SubServer.StopAction.valueOf(server.getRawString("Stop-Action").toUpperCase().replace('-', '_').replace(' ', '_')), null);
+                    SubServer.StopAction action = Try.all.get(() -> SubServer.StopAction.valueOf(server.getString("Stop-Action").toUpperCase().replace('-', '_').replace(' ', '_')));
                     if (action != null) subserver.setStopAction(action);
                     if (server.contains("Extra")) for (String extra : server.getMap("Extra").getKeys())
                         subserver.addExtra(extra, server.getMap("Extra").getObject(extra));
@@ -221,8 +223,14 @@ public class ExternalSubCreator extends SubCreator {
                     }
 
                     host.addSubServer(subserver);
-                    if (update == null && template.getBuildOptions().getBoolean("Run-On-Finish", true))
-                        subserver.start();
+                    if (update == null && template.getBuildOptions().getBoolean("Run-On-Finish", true)) {
+                        while (!subserver.isAvailable() && host.isAvailable()) {
+                            Thread.sleep(250);
+                        }
+                        if (subserver.isAvailable()) {
+                            subserver.start();
+                        }
+                    }
                 }
 
                 host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, port, subserver, update != null, true));
@@ -249,7 +257,7 @@ public class ExternalSubCreator extends SubCreator {
 
     @Override
     public void terminate(String name) {
-        if (this.thread.keySet().contains(name.toLowerCase())) {
+        if (this.thread.containsKey(name.toLowerCase())) {
             ((SubDataClient) host.getSubData()[0]).sendPacket(new PacketExCreateServer(name.toLowerCase()));
             thread.remove(name.toLowerCase());
         }
@@ -266,7 +274,7 @@ public class ExternalSubCreator extends SubCreator {
 
     @Override
     public void waitFor(String name) throws InterruptedException {
-        while (this.thread.keySet().contains(name.toLowerCase()) && host.getSubData()[0] != null) {
+        while (this.thread.containsKey(name.toLowerCase()) && host.getSubData()[0] != null) {
             Thread.sleep(250);
         }
     }
@@ -315,7 +323,7 @@ public class ExternalSubCreator extends SubCreator {
 
     @Override
     public void setLogging(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         log.value(value);
     }
 
@@ -334,14 +342,26 @@ public class ExternalSubCreator extends SubCreator {
     @Override
     public Map<String, ServerTemplate> getTemplates() {
         TreeMap<String, ServerTemplate> map = new TreeMap<String, ServerTemplate>();
-        if (enableRT != null && enableRT) map.putAll(templatesR);
-        map.putAll(templates);
+        if (enableRT != null && enableRT) for (Map.Entry<String, ServerTemplate> template : templatesR.entrySet()) {
+            if (!template.getValue().isInternal()) map.put(template.getKey(), template.getValue());
+        }
+        for (Map.Entry<String, ServerTemplate> template : templates.entrySet()) {
+            if (!template.getValue().isInternal()) map.put(template.getKey(), template.getValue());
+        }
         return map;
     }
 
     @Override
     public ServerTemplate getTemplate(String name) {
-        if (Util.isNull(name)) throw new NullPointerException();
-        return getTemplates().get(name.toLowerCase());
+        Util.nullpo(name);
+        name = name.toLowerCase();
+
+        ServerTemplate template = templates.getOrDefault(name, null);
+        if (template == null && enableRT != null && enableRT) template = templatesR.getOrDefault(name, null);
+        if (template == null || template.isInternal()) {
+            return null;
+        } else {
+            return template;
+        }
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/External/ExternalSubLogger.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Host.External;
 
 import net.ME1312.Galaxi.Library.Container.Value;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.SubLogFilter;
 import net.ME1312.SubServers.Bungee.Host.SubLogger;
@@ -13,13 +14,13 @@ import java.io.FileNotFoundException;
 import java.io.PrintWriter;
 import java.io.UnsupportedEncodingException;
 import java.lang.reflect.InvocationTargetException;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Calendar;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.logging.Level;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 /**
  * External Process Logger Class
@@ -72,29 +73,20 @@ public class ExternalSubLogger extends SubLogger {
     }
 
     @SuppressWarnings("deprecation")
-    private void log(String line) {
+    private void log(int type, String msg) {
         if (started) {
-            String msg = line;
             Level level;
 
-            // REGEX Formatting
-            String type = "";
-            Matcher matcher = Pattern.compile("^((?:\\s*\\[?([0-9]{2}:[0-9]{2}:[0-9]{2})]?)?[\\s\\/\\\\\\|]*(?:\\[|\\[.*\\/)?(MESSAGE|INFO|WARNING|WARN|ERROR|ERR|SEVERE)\\]?:?(?:\\s*>)?\\s*)").matcher(msg.replaceAll("\u001B\\[[;\\d]*m", ""));
-            while (matcher.find()) {
-                type = matcher.group(3).toUpperCase();
-            }
-
-            msg = msg.substring(msg.length() - msg.replaceAll("^((?:\\s*\\[?([0-9]{2}:[0-9]{2}:[0-9]{2})]?)?[\\s\\/\\\\\\|]*(?:\\[|\\[.*\\/)?(MESSAGE|INFO|WARNING|WARN|ERROR|ERR|SEVERE)\\]?:?(?:\\s*>)?\\s*)", "").length());
-
             // Determine LOG LEVEL
             switch (type) {
-                case "WARNING":
-                case "WARN":
+                case 80:
+                    level = Level.FINE;
+                    break;
+                case 40:
                     level = Level.WARNING;
                     break;
-                case "SEVERE":
-                case "ERROR":
-                case "ERR":
+                case 30:
+                case 20:
                     level = Level.SEVERE;
                     break;
                 default:
@@ -117,7 +109,7 @@ public class ExternalSubLogger extends SubLogger {
 
             // Log to FILE
             if (writer != null) {
-                writer.println(line);
+                writer.println('[' + new SimpleDateFormat("HH:mm:ss").format(Calendar.getInstance().getTime()) + "] [" + level + "] > " + msg);
                 writer.flush();
             }
         }
@@ -134,20 +126,19 @@ public class ExternalSubLogger extends SubLogger {
 
     @Override
     public void registerFilter(SubLogFilter filter) {
-        if (Util.isNull(filter)) throw new NullPointerException();
+        Util.nullpo(filter);
         filters.add(filter);
     }
 
     @Override
     public void unregisterFilter(SubLogFilter filter) {
-        if (Util.isNull(filter)) throw new NullPointerException();
-        Util.isException(() -> filters.remove(filter));
+        Util.nullpo(filter);
+        Try.all.run(() -> filters.remove(filter));
     }
 
     @Override
     public void stop() {
         if (started) {
-            PacketInExLogMessage.unregister(id);
             id = null;
             started = false;
             List<SubLogFilter> filters = new ArrayList<SubLogFilter>();
@@ -160,7 +151,7 @@ public class ExternalSubLogger extends SubLogger {
             if (writer != null) {
                 PrintWriter writer = this.writer;
                 this.writer = null;
-                int l = (int) Math.floor((("---------- LOG START \u2014 " + name + " ----------").length() - 9) / 2);
+                int l = (("---------- LOG START \u2014 " + name + " ----------").length() - 9) / 2;
                 String s = "";
                 while (s.length() < l) s += '-';
                 writer.println(s + " LOG END " + s);

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/External/ExternalSubServer.java

@@ -1,27 +1,31 @@
 package net.ME1312.SubServers.Bungee.Host.External;
 
-import net.ME1312.Galaxi.Library.Callback.ReturnRunnable;
 import net.ME1312.Galaxi.Library.Container.ContainedPair;
 import net.ME1312.Galaxi.Library.Container.Container;
 import net.ME1312.Galaxi.Library.Container.Value;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.SubServers.Bungee.Event.*;
 import net.ME1312.SubServers.Bungee.Host.*;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
-import net.ME1312.SubServers.Bungee.Network.Packet.PacketExEditServer;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketExControlServer;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketExControlServer.Action;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExEditServer;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExEditServer.Edit;
+import net.ME1312.SubServers.Bungee.SubAPI;
 
-import net.md_5.bungee.BungeeServerInfo;
 import net.md_5.bungee.api.ChatColor;
 
 import java.io.IOException;
-import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.UUID;
+import java.util.function.Supplier;
 
 /**
  * External SubServer Class
@@ -82,7 +86,7 @@ public class ExternalSubServer extends SubServerImpl {
     }
 
     private void init(ExternalHost host, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException {
-        if (Util.isNull(host, name, enabled, port, motd, log, stopcmd, hidden, restricted)) throw new NullPointerException();
+        Util.nullpo(host, name, enabled, port, motd, log, stopcmd, hidden, restricted);
         this.host = host;
         this.enabled = enabled;
         this.log = new Container<Boolean>(log);
@@ -114,7 +118,7 @@ public class ExternalSubServer extends SubServerImpl {
             if (!event.isCancelled()) {
                 Logger.get("SubServers").info("Now starting " + getName());
                 started(null);
-                host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.START, logger.getExternalAddress().toString()));
+                host.queue(new PacketExControlServer(this, Action.START, logger.getExternalAddress().toString()));
                 return true;
             } else {
                 lock = false;
@@ -124,12 +128,13 @@ public class ExternalSubServer extends SubServerImpl {
     }
     void started(UUID address) {
         if (!running) {
+            stopping = false;
             started = false;
             running = true;
             lock = false;
             logger.start();
             if (address != null) {
-                if (address != logger.getExternalAddress()) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_LOGGING_ADDRESS, logger.getExternalAddress().toString()));
+                if (address != logger.getExternalAddress()) host.queue(new PacketExControlServer(this, Action.SET_LOGGING_ADDRESS, logger.getExternalAddress().toString()));
                 host.plugin.getPluginManager().callEvent(new SubStartEvent(null, this));
             }
         }
@@ -147,15 +152,18 @@ public class ExternalSubServer extends SubServerImpl {
             host.plugin.getPluginManager().callEvent(event);
             if (!event.isCancelled()) {
                 history.add(new LoggedCommand(player, stopcmd));
-                host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.STOP));
+                host.queue(new PacketExControlServer(this, Action.STOP));
+                stopping = true;
                 return true;
             } else return false;
         } else return false;
     }
-    private void stopped(Boolean allowrestart) {
+    void stopped(Boolean allowrestart) {
         logger.stop();
         history.clear();
+        started = false;
         running = false;
+        stopping = false;
         SubStoppedEvent event = new SubStoppedEvent(this);
         host.plugin.getPluginManager().callEvent(event);
         Logger.get("SubServers").info(getName() + " has stopped");
@@ -200,7 +208,8 @@ public class ExternalSubServer extends SubServerImpl {
             SubStopEvent event = new SubStopEvent(player, this, true);
             host.plugin.getPluginManager().callEvent(event);
             if (!event.isCancelled()) {
-                host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.TERMINATE));
+                host.queue(new PacketExControlServer(this, Action.TERMINATE));
+                stopping = true;
                 return true;
             } else return false;
         } else return false;
@@ -208,16 +217,17 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public boolean command(UUID player, String command) {
-        if (Util.isNull(command)) throw new NullPointerException();
+        Util.nullpo(command);
         if (running) {
-            SubSendCommandEvent event = new SubSendCommandEvent(player, this, command);
+            SubSendCommandEvent event = new SubSendCommandEvent(player, this, command, null);
             host.plugin.getPluginManager().callEvent(event);
-            if (!event.isCancelled()) {
+            if (!event.isCancelled() && (player == null || !DISALLOWED_COMMANDS.matcher(command).find())) {
                 history.add(new LoggedCommand(player, event.getCommand()));
                 if (event.getCommand().equalsIgnoreCase(stopcmd)) {
-                    host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.STOP));
+                    host.queue(new PacketExControlServer(this, Action.STOP));
+                    stopping = true;
                 } else {
-                    host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.COMMAND, event.getCommand()));
+                    host.queue(new PacketExControlServer(this, Action.COMMAND, event.getCommand()));
                 }
                 return true;
             } else return false;
@@ -246,7 +256,7 @@ public class ExternalSubServer extends SubServerImpl {
                         switch (key.toLowerCase()) {
                             case "name":
                                 if (value.isString() && host.removeSubServer(player, getName())) {
-                                    SubServer server = host.constructSubServer(value.asRawString(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
+                                    SubServer server = host.constructSubServer(value.asString(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
                                     if (server != null) {
                                         if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                             ObjectMap<String> config = this.host.plugin.servers.get().getMap("Servers").getMap(getName());
@@ -261,14 +271,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "display":
                                 if (value.isString()) {
-                                    Field f = ServerImpl.class.getDeclaredField("nick");
-                                    f.setAccessible(true);
-                                    if (value.isNull() || value.asString().length() == 0 || getName().equals(value.asString())) {
-                                        f.set(this, null);
-                                    } else {
-                                        f.set(this, value.asString());
-                                    }
-                                    f.setAccessible(false);
+                                    setDisplayName(value.asString());
                                     logger.name = getDisplayName();
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         if (getName().equals(getDisplayName())) {
@@ -283,7 +286,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "enabled":
                                 if (value.isBoolean()) {
-                                    if (enabled != value.asBoolean()) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_ENABLED, (Boolean) value.asBoolean()));
+                                    if (enabled != value.asBoolean()) host.queue(new PacketExControlServer(this, Action.SET_ENABLED, (Boolean) value.asBoolean()));
                                     enabled = value.asBoolean();
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Enabled", isEnabled());
@@ -305,7 +308,7 @@ public class ExternalSubServer extends SubServerImpl {
                             case "host":
                                 if (value.isString() && host.removeSubServer(player, getName())) {
                                     waitFor(() -> host.getSubServer(getName()), null);
-                                    SubServer server = this.host.plugin.api.getHost(value.asRawString()).constructSubServer(getName(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
+                                    SubServer server = this.host.plugin.api.getHost(value.asString()).constructSubServer(getName(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
                                     if (server != null) {
                                         if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                             this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Host", server.getHost().getName());
@@ -318,7 +321,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "template":
                                 if (value.isString()) {
-                                    setTemplate(value.asRawString());
+                                    setTemplate(value.asString());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Template", value.asString());
                                         this.host.plugin.servers.save();
@@ -342,7 +345,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "motd":
                                 if (value.isString()) {
-                                    setMotd(ChatColor.translateAlternateColorCodes('&', value.asString()));
+                                    setMotd(ChatColor.translateAlternateColorCodes('&', Util.unescapeJavaString(value.asString())));
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Motd", value.asString());
                                         this.host.plugin.servers.save();
@@ -352,7 +355,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "log":
                                 if (value.isBoolean()) {
-                                    if (log.value() != value.asBoolean()) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_LOGGING, (Boolean) value.asBoolean()));
+                                    if (log.value() != value.asBoolean()) host.queue(new PacketExControlServer(this, Action.SET_LOGGING, (Boolean) value.asBoolean()));
                                     log.value(value.asBoolean());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Log", isLogging());
@@ -365,7 +368,7 @@ public class ExternalSubServer extends SubServerImpl {
                             case "directory":
                                 if (value.isString() && host.removeSubServer(player, getName())) {
                                     waitFor(() -> host.getSubServer(getName()), null);
-                                    SubServer server = host.constructSubServer(getName(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), value.asRawString(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
+                                    SubServer server = host.constructSubServer(getName(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), value.asString(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
                                     if (server != null) {
                                         if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                             this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Directory", server.getPath());
@@ -380,10 +383,10 @@ public class ExternalSubServer extends SubServerImpl {
                             case "executable":
                                 if (value.isString() && host.removeSubServer(player, getName())) {
                                     waitFor(() -> host.getSubServer(getName()), null);
-                                    SubServer server = host.constructSubServer(getName(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), value.asRawString(), getStopCommand(), isHidden(), isRestricted());
+                                    SubServer server = host.constructSubServer(getName(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), value.asString(), getStopCommand(), isHidden(), isRestricted());
                                     if (server != null) {
                                         if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
-                                            this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Executable", value.asRawString());
+                                            this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Executable", value.asString());
                                             this.host.plugin.servers.save();
                                         }
                                         forward = server;
@@ -399,8 +402,8 @@ public class ExternalSubServer extends SubServerImpl {
                             case "stop-cmd":
                             case "stop-command":
                                 if (value.isString()) {
-                                    if (!stopcmd.equals(value)) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_STOP_COMMAND, value.asRawString()));
-                                    stopcmd = value.asRawString();
+                                    if (!stopcmd.equals(value.asString())) host.queue(new PacketExControlServer(this, Action.SET_STOP_COMMAND, value.asString()));
+                                    stopcmd = value.asString();
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Stop-Command", getStopCommand());
                                         this.host.plugin.servers.save();
@@ -410,7 +413,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "stop-action":
                                 if (value.isString()) {
-                                    StopAction action = Util.getDespiteException(() -> StopAction.valueOf(value.asRawString().toUpperCase().replace('-', '_').replace(' ', '_')), null);
+                                    StopAction action = Try.all.get(() -> StopAction.valueOf(value.asString().toUpperCase().replace('-', '_').replace(' ', '_')));
                                     if (action != null) {
                                         stopaction = action;
                                         if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
@@ -468,6 +471,9 @@ public class ExternalSubServer extends SubServerImpl {
                             case "whitelist":
                                 if (value.isList()) {
                                     Util.reflect(ServerImpl.class.getDeclaredField("whitelist"), this, value.asUUIDList());
+                                    if (isRegistered()) for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+                                        ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.WHITELIST_SET, value.asUUIDList()));
+                                    }
                                     c++;
                                 }
                                 break;
@@ -500,8 +506,8 @@ public class ExternalSubServer extends SubServerImpl {
             if (!isRunning() && forward == null && state) start(player);
             return c;
         } else return -1;
-    } private <V> void waitFor(ReturnRunnable<V> method, V value) throws InterruptedException {
-        while (method.run() != value) {
+    } private <V> void waitFor(Supplier<V> method, V value) throws InterruptedException {
+        while (method.get() != value) {
             Thread.sleep(250);
         }
     }
@@ -536,8 +542,8 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public void setEnabled(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        if (enabled != value) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_ENABLED, (Boolean) value));
+        Util.nullpo(value);
+        if (enabled != value) host.queue(new PacketExControlServer(this, Action.SET_ENABLED, (Boolean) value));
         enabled = value;
     }
 
@@ -548,8 +554,8 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public void setLogging(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        if (log.value() != value) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_LOGGING, (Boolean) value));
+        Util.nullpo(value);
+        if (log.value() != value) host.queue(new PacketExControlServer(this, Action.SET_LOGGING, (Boolean) value));
         log.value(value);
     }
 
@@ -580,8 +586,8 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public void setStopCommand(String value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        if (!stopcmd.equals(value)) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_STOP_COMMAND, value));
+        Util.nullpo(value);
+        if (!stopcmd.equals(value)) host.queue(new PacketExControlServer(this, Action.SET_STOP_COMMAND, value));
         stopcmd = value;
     }
 
@@ -592,7 +598,7 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public void setStopAction(StopAction action) {
-        if (Util.isNull(action)) throw new NullPointerException();
+        Util.nullpo(action);
         stopaction = action;
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/Host.java

@@ -14,13 +14,16 @@ import com.google.common.collect.Range;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 import java.net.InetAddress;
-import java.util.*;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.UUID;
 
 /**
  * Host Layout Class
  */
-public abstract class Host implements ExtraDataHandler {
-    private ObjectMap<String> extra = new ObjectMap<String>();
+public abstract class Host implements ExtraDataHandler<String> {
+    private final ObjectMap<String> extra = new ObjectMap<String>();
     private final String signature;
     private String nick = null;
 
@@ -40,7 +43,7 @@ public abstract class Host implements ExtraDataHandler {
     public Host(SubProxy plugin, String name, boolean enabled, Range<Integer> ports, boolean log, InetAddress address, String directory, String gitBash) {
         if (name.contains(" ")) throw new InvalidHostException("Host names cannot have spaces: " + name);
         if (!ports.hasLowerBound() || !ports.hasUpperBound()) throw new InvalidHostException("Port range is not bound");
-        if (Util.isNull(plugin, name, enabled, ports, log, address, directory, gitBash)) throw new NullPointerException();
+        Util.nullpo(plugin, name, enabled, ports, log, address, directory, gitBash);
         signature = plugin.api.signAnonymousObject();
         SubAPI.getInstance().getInternals().subprotocol.whitelist(address.getHostAddress());
     }
@@ -531,21 +534,26 @@ public abstract class Host implements ExtraDataHandler {
         return signature;
     }
 
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof Host && signature.equals(((Host) obj).signature);
+    }
+
     @Override
     public void addExtra(String handle, Object value) {
-        if (Util.isNull(handle, value)) throw new NullPointerException();
+        Util.nullpo(handle, value);
         extra.set(handle, value);
     }
 
     @Override
     public boolean hasExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         return extra.getKeys().contains(handle);
     }
 
     @Override
     public ObjectMapValue getExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         return extra.get(handle);
     }
 
@@ -556,7 +564,7 @@ public abstract class Host implements ExtraDataHandler {
 
     @Override
     public void removeExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         extra.remove(handle);
     }
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/Internal/InternalHost.java

@@ -1,8 +1,8 @@
 package net.ME1312.SubServers.Bungee.Host.Internal;
 
 import net.ME1312.Galaxi.Library.Config.YAMLSection;
+import net.ME1312.Galaxi.Library.Directories;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.Galaxi.Library.UniversalFile;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Event.SubAddServerEvent;
 import net.ME1312.SubServers.Bungee.Event.SubRemoveServerEvent;
@@ -15,6 +15,7 @@ import net.ME1312.SubServers.Bungee.SubProxy;
 
 import com.dosse.upnp.UPnP;
 import com.google.common.collect.Range;
+import com.google.gson.Gson;
 
 import java.io.File;
 import java.io.FileWriter;
@@ -94,8 +95,8 @@ public class InternalHost extends Host {
 
     @Override
     public SubServer getSubServer(String name) {
-        if (Util.isNull(name)) throw new NullPointerException();
-        return getSubServers().get(name.toLowerCase());
+        if (Util.isNull(name)) return null;
+        return servers.get(name.toLowerCase());
     }
 
     @Override
@@ -121,7 +122,7 @@ public class InternalHost extends Host {
 
     @Override
     protected boolean removeSubServer(UUID player, String name, boolean forced) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
+        Util.nullpo(name);
         InternalSubServer server = (InternalSubServer) servers.get(name.toLowerCase());
         SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, server);
         plugin.getPluginManager().callEvent(event);
@@ -153,22 +154,22 @@ public class InternalHost extends Host {
      * @return Success Status
      */
     protected boolean recycleSubServer(UUID player, String name, boolean forced, boolean multithreading) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
+        Util.nullpo(name);
         String server = servers.get(name.toLowerCase()).getName();
         File from = new File(getPath(), servers.get(server.toLowerCase()).getPath());
         if (removeSubServer(player, server, forced)) {
             Runnable method = () -> {
-                UniversalFile to = new UniversalFile(plugin.dir, "SubServers:Recently Deleted:" + server.toLowerCase());
+                File to = new File(plugin.dir, "SubServers/Recently Deleted/" + server.toLowerCase());
                 try {
                     if (from.exists()) {
                         Logger.get("SubServers").info("Moving Files...");
                         if (to.exists()) {
-                            if (to.isDirectory()) Util.deleteDirectory(to);
+                            if (to.isDirectory()) Directories.delete(to);
                             else to.delete();
                         }
                         to.mkdirs();
-                        Util.copyDirectory(from, to);
-                        Util.deleteDirectory(from);
+                        Directories.copy(from, to);
+                        Directories.delete(from);
                     }
                 } catch (Exception e) {
                     e.printStackTrace();
@@ -185,7 +186,7 @@ public class InternalHost extends Host {
                     }
                     if (!to.exists()) to.mkdirs();
                     FileWriter writer = new FileWriter(new File(to, "info.json"), false);
-                    writer.write(info.toJSON().toString());
+                    writer.write(new Gson().toJson(info.get()));
                     writer.close();
                 } catch (Exception e) {
                     e.printStackTrace();
@@ -215,7 +216,7 @@ public class InternalHost extends Host {
      * @return Success Status
      */
     protected boolean deleteSubServer(UUID player, String name, boolean forced, boolean multithreading) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
+        Util.nullpo(name);
         String server = servers.get(name.toLowerCase()).getName();
         File from = new File(getPath(), servers.get(server.toLowerCase()).getPath());
         if (removeSubServer(player, server, forced)) {
@@ -223,7 +224,7 @@ public class InternalHost extends Host {
                 try {
                     if (from.exists()) {
                         Logger.get("SubServers").info("Removing Files...");
-                        Util.deleteDirectory(from);
+                        Directories.delete(from);
                     }
                 } catch (Exception e) {
                     e.printStackTrace();

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/Internal/InternalSubCreator.java

@@ -1,15 +1,15 @@
 package net.ME1312.SubServers.Bungee.Host.Internal;
 
-import net.ME1312.Galaxi.Library.Callback.Callback;
 import net.ME1312.Galaxi.Library.Config.YAMLConfig;
 import net.ME1312.Galaxi.Library.Config.YAMLSection;
 import net.ME1312.Galaxi.Library.Container.ContainedPair;
 import net.ME1312.Galaxi.Library.Container.Container;
 import net.ME1312.Galaxi.Library.Container.Pair;
 import net.ME1312.Galaxi.Library.Container.Value;
+import net.ME1312.Galaxi.Library.Directories;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
-import net.ME1312.Galaxi.Library.UniversalFile;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.Galaxi.Library.Version.Version;
 import net.ME1312.SubServers.Bungee.Event.SubCreateEvent;
@@ -37,8 +37,12 @@ import java.nio.file.LinkOption;
 import java.nio.file.StandardCopyOption;
 import java.security.MessageDigest;
 import java.util.*;
+import java.util.function.Consumer;
 import java.util.regex.Pattern;
 
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+
 /**
  * Internal SubCreator Class
  */
@@ -60,11 +64,13 @@ public class InternalSubCreator extends SubCreator {
         private final int port;
         private final String prefix;
         private final InternalSubLogger log;
+        private final LinkedList<String> replace;
         private final HashMap<String, String> replacements;
-        private final Callback<SubServer> callback;
+        private final Consumer<SubServer> callback;
+        private boolean install;
         private Process process;
 
-        private CreatorTask(UUID player, String name, ServerTemplate template, Version version, int port, Callback<SubServer> callback) {
+        private CreatorTask(UUID player, String name, ServerTemplate template, Version version, int port, Consumer<SubServer> callback) {
             super("SubServers.Bungee::Internal_SubCreator_Process_Handler(" + name + ')');
             this.player = player;
             this.update = null;
@@ -73,11 +79,13 @@ public class InternalSubCreator extends SubCreator {
             this.version = version;
             this.port = port;
             this.log = new InternalSubLogger(null, this, prefix = name + File.separator + "Creator", InternalSubCreator.this.log, null);
+           (this.replace = new LinkedList<String>()).add("/server.properties");
             this.replacements = new HashMap<String, String>();
             this.callback = callback;
+            this.install = true;
         }
 
-        private CreatorTask(UUID player, SubServer server, ServerTemplate template, Version version, Callback<SubServer> callback) {
+        private CreatorTask(UUID player, SubServer server, ServerTemplate template, Version version, Consumer<SubServer> callback) {
             super("SubServers.Bungee::Internal_SubCreator_Process_Handler(" + server.getName() + ')');
             this.player = player;
             this.update = server;
@@ -86,49 +94,54 @@ public class InternalSubCreator extends SubCreator {
             this.version = version;
             this.port = server.getAddress().getPort();
             this.log = new InternalSubLogger(null, this, prefix = name + File.separator + "Updater", InternalSubCreator.this.log, null);
+           (this.replace = new LinkedList<String>()).add("/server.properties");
             this.replacements = new HashMap<String, String>();
             this.callback = callback;
+            this.install = true;
         }
 
-        private ObjectMap<String> build(File dir, ServerTemplate template, List<ServerTemplate> history) throws SubCreatorException {
+        private ObjectMap<String> build(File dir, ServerTemplate template, List<ServerTemplate> history, List<ServerTemplate> stack) throws SubCreatorException {
             ObjectMap<String> server = new ObjectMap<String>();
             Version version = this.version;
             HashMap<String, String> var = new HashMap<String, String>();
             boolean error = false;
-            if (history.contains(template)) throw new IllegalStateException("Template import loop detected");
-            history.add(template);
+            if (stack.contains(template)) throw new IllegalStateException("Infinite template import loop detected");
+            stack.add(template);
             for (String other : template.getBuildOptions().getStringList("Import", new ArrayList<String>())) {
-                if (templates.keySet().contains(other.toLowerCase())) {
-                    if (templates.get(other.toLowerCase()).isEnabled()) {
-                        if (version != null || !templates.get(other.toLowerCase()).requiresVersion()) {
-                            if (update == null || templates.get(other.toLowerCase()).canUpdate()) {
-                                ObjectMap<String> config = build(dir, templates.get(other.toLowerCase()), history);
-                                if (config == null) {
-                                    throw new SubCreatorException();
+                if (templates.containsKey(other.toLowerCase())) {
+                    final ServerTemplate ot = templates.get(other.toLowerCase());
+                    if (ot.isEnabled()) {
+                        if (version != null || !ot.requiresVersion()) {
+                            if (update == null || ot.canUpdate()) {
+                                if (!history.contains(ot)) {
+                                    server.setAll(this.build(dir, ot, history, stack));
                                 } else {
-                                    server.setAll(config);
+                                    log.log(WARNING, "Skipping template that is already loaded: " + other);
                                 }
                             } else {
-                                Logger.get(prefix).info("Skipping template that cannot be run in update mode: " + other);
+                                log.log(WARNING, "Skipping template that cannot be run in update mode: " + other);
                             }
                         } else {
-                            Logger.get(prefix).info("Skipping template that requires extra versioning information: " + other);
+                            log.log(WARNING, "Skipping template that requires extra versioning information: " + other);
                         }
                     } else {
-                        Logger.get(prefix).info("Skipping disabled template: " + other);
+                        log.log(WARNING, "Skipping disabled template: " + other);
                     }
                 } else {
-                    Logger.get(prefix).info("Skipping missing template: " + other);
+                    log.log(WARNING, "Skipping missing template: " + other);
                 }
             }
+            history.add(template);
+            stack.remove(template);
             server.setAll(template.getConfigOptions());
             try {
-                Logger.get(prefix).info("Loading" + ((template.isDynamic())?" Dynamic":"") + " Template: " + template.getDisplayName());
-                if (template.getBuildOptions().getBoolean("Update-Files", false)) updateDirectory(template.getDirectory(), dir);
-                else Util.copyDirectory(template.getDirectory(), dir);
+                log.log(INFO, "Loading" + ((template.isDynamic())?" Dynamic":"") + " Template: " + template.getDisplayName());
+                updateDirectory(template.getDirectory(), dir, template.getBuildOptions().getBoolean("Update-Files", false));
 
+                install = template.getBuildOptions().getBoolean("Install-Client", install);
+                replace.addAll(template.getBuildOptions().getStringList("Replace", Collections.emptyList()));
                 for (ObjectMapValue<String> replacement : template.getBuildOptions().getMap("Replacements", new ObjectMap<>()).getValues()) if (!replacement.isNull()) {
-                    replacements.put(replacement.getHandle().toLowerCase().replace('-', '_').replace(' ', '_'), replacement.asRawString());
+                    replacements.put(replacement.getHandle().toLowerCase().replace('-', '_').replace(' ', '_'), replacement.asString());
                 }
 
                 var.putAll(replacements);
@@ -148,24 +161,24 @@ public class InternalSubCreator extends SubCreator {
                     case SPONGE:
                     case FORGE:
                         if (version != null) {
-                            Logger.get(prefix).info("Searching Versions...");
+                            log.log(INFO, "Searching Versions...");
                             ObjectMap<String> spversionmanifest = new ObjectMap<String>(new Gson().fromJson("{\"versions\":" + Util.readAll(new BufferedReader(new InputStreamReader(new URL("https://dl-api.spongepowered.org/v1/org.spongepowered/sponge" + ((template.getType() == ServerType.FORGE)?"forge":"vanilla") + "/downloads?type=stable&minecraft=" + version).openStream(), Charset.forName("UTF-8")))) + '}', Map.class));
 
                             ObjectMap<String> spprofile = null;
                             Version spversion = null;
                             for (ObjectMap<String> profile : spversionmanifest.getMapList("versions")) {
-                                if (profile.getMap("dependencies").getRawString("minecraft").equalsIgnoreCase(version.toString()) && (spversion == null || new Version(profile.getRawString("version")).compareTo(spversion) >= 0)) {
+                                if (profile.getMap("dependencies").getString("minecraft").equalsIgnoreCase(version.toString()) && (spversion == null || new Version(profile.getString("version")).compareTo(spversion) >= 0)) {
                                     spprofile = profile;
-                                    spversion = new Version(profile.getRawString("version"));
+                                    spversion = new Version(profile.getString("version"));
                                 }
                             }
                             if (spversion == null)
                                 throw new InvalidServerException("Cannot find Sponge version for Minecraft " + version.toString());
-                            Logger.get(prefix).info("Found \"sponge" + ((template.getType() == ServerType.FORGE)?"forge":"vanilla") + "-" + spversion.toString() + '"');
+                            log.log(INFO, "Found \"sponge" + ((template.getType() == ServerType.FORGE)?"forge":"vanilla") + "-" + spversion.toString() + '"');
 
                             if (template.getType() == ServerType.FORGE) {
-                                Version mcfversion = new Version(((spprofile.getMap("dependencies").getRawString("forge").contains("-"))?"":spprofile.getMap("dependencies").getRawString("minecraft") + '-') + spprofile.getMap("dependencies").getRawString("forge"));
-                                Logger.get(prefix).info("Found \"forge-" + mcfversion.toString() + '"');
+                                Version mcfversion = new Version(((spprofile.getMap("dependencies").getString("forge").contains("-"))?"":spprofile.getMap("dependencies").getString("minecraft") + '-') + spprofile.getMap("dependencies").getString("forge"));
+                                log.log(INFO, "Found \"forge-" + mcfversion.toString() + '"');
 
                                 var.put("mcf_version", mcfversion.toString());
                             }
@@ -178,29 +191,25 @@ public class InternalSubCreator extends SubCreator {
             }
 
             if (template.getBuildOptions().contains("Executable")) {
-                File cache;
+                File cache = null;
                 if (template.getBuildOptions().getBoolean("Use-Cache", true)) {
-                    cache = new UniversalFile(host.plugin.dir, "SubServers:Cache:Templates:" + template.getName());
+                    cache = new File(host.plugin.dir, "SubServers/Cache/Templates/" + template.getName());
                     cache.mkdirs();
-                    String c = cache.toString();
-                    if (System.getProperty("os.name").toLowerCase().startsWith("windows") &&
-                            (template.getBuildOptions().getRawString("Executable").toLowerCase().startsWith("bash ") || template.getBuildOptions().getRawString("Executable").toLowerCase().startsWith("sh "))) c = c.replace(File.separatorChar, '/');
-                    var.put("cache", c);
-                } else {
-                    cache = null;
+                    var.put("cache", cache.getAbsolutePath());
                 }
+                var.put("source", dir.getAbsolutePath());
 
                 try {
-                    Logger.get(prefix).info("Launching Build Script...");
-                    ProcessBuilder pb = new ProcessBuilder().command(Executable.parse(gitBash, template.getBuildOptions().getRawString("Executable"))).directory(dir);
+                    log.log(INFO, "Launching Build Script...");
+                    ProcessBuilder pb = new ProcessBuilder().command(Executable.parse(gitBash, template.getBuildOptions().getString("Executable"))).directory(dir);
                     pb.environment().putAll(var);
-                    process = pb.start();
                     log.file = new File(dir, "SubCreator-" + template.getName() + ((version != null)?"-"+version.toString():"") + ".log");
+                    process = pb.start();
                     log.process = process;
                     log.start();
 
                     process.waitFor();
-                    Thread.sleep(500);
+                    Thread.sleep(250);
 
                     if (process.exitValue() != 0) error = true;
                 } catch (InterruptedException e) {
@@ -212,14 +221,14 @@ public class InternalSubCreator extends SubCreator {
 
                 if (cache != null) {
                     if (cache.isDirectory() && cache.listFiles().length == 0) cache.delete();
-                    cache = new UniversalFile(host.plugin.dir, "SubServers:Cache:Templates");
+                    cache = new File(host.plugin.dir, "SubServers/Cache/Templates");
                     if (cache.isDirectory() && cache.listFiles().length == 0) cache.delete();
-                    cache = new UniversalFile(host.plugin.dir, "SubServers:Cache");
+                    cache = new File(host.plugin.dir, "SubServers/Cache");
                     if (cache.isDirectory() && cache.listFiles().length == 0) cache.delete();
                 }
             }
 
-            new UniversalFile(dir, "template.yml").delete();
+            new File(dir, "template.yml").delete();
             if (error) throw new SubCreatorException();
             return server;
         }
@@ -238,30 +247,28 @@ public class InternalSubCreator extends SubCreator {
 
             declaration.run();
             File dir = (update != null)?new File(update.getFullPath()):new File(host.getPath(),
-                    (template.getConfigOptions().contains("Directory"))?new ReplacementScanner(replacements).replace(template.getConfigOptions().getRawString("Directory")).toString():name);
-            dir.mkdirs();
+                    (template.getConfigOptions().contains("Directory"))?new ReplacementScanner(replacements).replace(template.getConfigOptions().getString("Directory")).toString():name);
 
             ObjectMap<String> server = new ObjectMap<String>();
             ObjectMap<String> config;
             try {
-                config = build(dir, template, new LinkedList<>());
+                log.init();
+                config = build(dir, template, new LinkedList<>(), new LinkedList<>());
             } catch (SubCreatorException e) {
                 config = null;
             } catch (Exception e) {
                 config = null;
                 e.printStackTrace();
+            } finally {
+                log.destroy();
             }
 
             declaration.run();
             ReplacementScanner replacements = new ReplacementScanner(this.replacements);
             if (config != null) {
                 try {
-                    if (template.getBuildOptions().getBoolean("Install-Client", true)) generateClient(dir, template.getType(), name);
-
-                    LinkedList<String> masks = new LinkedList<>();
-                    masks.add("/server.properties");
-                    masks.addAll(template.getBuildOptions().getRawStringList("Replace", Collections.emptyList()));
-                    replacements.replace(dir, masks.toArray(new String[0]));
+                    if (install) generateClient(dir, template.getType(), name);
+                    replacements.replace(dir, replace.toArray(new String[0]));
                 } catch (Exception e) {
                     config = null;
                     e.printStackTrace();
@@ -273,10 +280,11 @@ public class InternalSubCreator extends SubCreator {
                     Logger.get(prefix).info("Saving...");
                     SubServer subserver = update;
                     if (update == null || update.getTemplate() != template || template.getBuildOptions().getBoolean("Update-Settings", false)) {
-                        if (host.plugin.exServers.keySet().contains(name.toLowerCase()))
+                        if (host.plugin.exServers.containsKey(name.toLowerCase()))
                             host.plugin.exServers.remove(name.toLowerCase());
 
                         config = new ObjectMap<String>((Map<String, ?>) replacements.replace(config.get()));
+                        if (config.contains("Directory") && (update != null || !template.getConfigOptions().contains("Directory"))) config.remove("Directory");
 
                         if (update == null) {
                             server.set("Enabled", true);
@@ -301,14 +309,14 @@ public class InternalSubCreator extends SubCreator {
                         }
                         server.setAll(config);
 
-                        if (update != null) Util.isException(() -> update.getHost().forceRemoveSubServer(name));
-                        subserver = host.constructSubServer(name, server.getBoolean("Enabled"), port, ChatColor.translateAlternateColorCodes('&', server.getString("Motd")), server.getBoolean("Log"),
-                                server.getRawString("Directory"), server.getRawString("Executable"), server.getRawString("Stop-Command"), server.getBoolean("Hidden"), server.getBoolean("Restricted"));
+                        if (update != null) Try.all.run(() -> update.getHost().forceRemoveSubServer(name));
+                        subserver = host.constructSubServer(name, server.getBoolean("Enabled"), port, ChatColor.translateAlternateColorCodes('&', Util.unescapeJavaString(server.getString("Motd"))), server.getBoolean("Log"),
+                                server.getString("Directory"), server.getString("Executable"), server.getString("Stop-Command"), server.getBoolean("Hidden"), server.getBoolean("Restricted"));
 
-                        if (server.getString("Display").length() > 0) subserver.setDisplayName(server.getString("Display"));
-                        subserver.setTemplate(server.getRawString("Template"));
+                        if (server.getString("Display").length() > 0) subserver.setDisplayName(Util.unescapeJavaString(server.getString("Display")));
+                        subserver.setTemplate(server.getString("Template"));
                         for (String group : server.getStringList("Group")) subserver.addGroup(group);
-                        SubServer.StopAction action = Util.getDespiteException(() -> SubServer.StopAction.valueOf(server.getRawString("Stop-Action").toUpperCase().replace('-', '_').replace(' ', '_')), null);
+                        SubServer.StopAction action = Try.all.get(() -> SubServer.StopAction.valueOf(server.getString("Stop-Action").toUpperCase().replace('-', '_').replace(' ', '_')));
                         if (action != null) subserver.setStopAction(action);
                         if (server.contains("Extra")) for (String extra : server.getMap("Extra").getKeys())
                             subserver.addExtra(extra, server.getMap("Extra").getObject(extra));
@@ -327,16 +335,16 @@ public class InternalSubCreator extends SubCreator {
                     InternalSubCreator.this.thread.remove(name.toLowerCase());
 
                     host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, port, subserver, update != null, true));
-                    callback.run(subserver);
+                    callback.accept(subserver);
                 } catch (Exception e) {
                     e.printStackTrace();
                     host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, port, update, update != null, false));
-                    callback.run(null);
+                    callback.accept(null);
                 }
             } else {
                 Logger.get(prefix).info("Couldn't build the server jar. Check the SubCreator logs for more detail.");
                 host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, port, update, update != null, false));
-                callback.run(null);
+                callback.accept(null);
             }
             InternalSubCreator.this.thread.remove(name.toLowerCase());
         }
@@ -352,7 +360,7 @@ public class InternalSubCreator extends SubCreator {
      */
     public InternalSubCreator(InternalHost host, Range<Integer> ports, boolean log, String gitBash) {
         if (!ports.hasLowerBound() || !ports.hasUpperBound()) throw new IllegalArgumentException("Port range is not bound");
-        if (Util.isNull(host, ports, log, gitBash)) throw new NullPointerException();
+        Util.nullpo(host, ports, log, gitBash);
         this.host = host;
         this.ports = ports;
         this.log = new Container<Boolean>(log);
@@ -365,17 +373,17 @@ public class InternalSubCreator extends SubCreator {
     @Override
     public void reload() {
         templates.clear();
-        if (new UniversalFile(host.plugin.dir, "SubServers:Templates").exists())
-            for (File file : new UniversalFile(host.plugin.dir, "SubServers:Templates").listFiles()) {
+        if (new File(host.plugin.dir, "SubServers/Templates").exists())
+            for (File file : new File(host.plugin.dir, "SubServers/Templates").listFiles()) {
                 try {
                     if (file.isDirectory() && !file.getName().endsWith(".x")) {
-                        ObjectMap<String> config = (new UniversalFile(file, "template.yml").exists()) ? new YAMLConfig(new UniversalFile(file, "template.yml")).get().getMap("Template", new ObjectMap<String>()) : new ObjectMap<String>();
-                        ServerTemplate template = loadTemplate(file.getName(), config.getBoolean("Enabled", true), config.getRawString("Icon", "::NULL::"), file, config.getMap("Build", new ObjectMap<String>()), config.getMap("Settings", new ObjectMap<String>()));
+                        ObjectMap<String> config = (new File(file, "template.yml").exists())? new YAMLConfig(new File(file, "template.yml")).get().getMap("Template", new ObjectMap<String>()) : new ObjectMap<String>();
+                        ServerTemplate template = loadTemplate(file.getName(), config.getBoolean("Enabled", true), config.getBoolean("Internal", false), config.getString("Icon", "::NULL::"), file, config.getMap("Build", new ObjectMap<String>()), config.getMap("Settings", new ObjectMap<String>()));
                         templates.put(file.getName().toLowerCase(), template);
-                        if (config.getKeys().contains("Display")) template.setDisplayName(config.getString("Display"));
+                        if (config.getKeys().contains("Display")) template.setDisplayName(Util.unescapeJavaString(config.getString("Display")));
                     }
                 } catch (Exception e) {
-                    Logger.get(host.getName() + File.separator + "Creator").info("Couldn't load template: " + file.getName());
+                    Logger.get(host.getName()).severe("Couldn't load template: " + file.getName());
                     e.printStackTrace();
                 }
             }
@@ -383,10 +391,10 @@ public class InternalSubCreator extends SubCreator {
 
     @SuppressWarnings("deprecation")
     @Override
-    public boolean create(UUID player, String name, ServerTemplate template, Version version, Integer port, Callback<SubServer> callback) {
-        if (Util.isNull(name, template)) throw new NullPointerException();
-        if (host.isAvailable() && host.isEnabled() && template.isEnabled() && !SubAPI.getInstance().getSubServers().keySet().contains(name.toLowerCase()) && !SubCreator.isReserved(name) && (version != null || !template.requiresVersion())) {
-            StackTraceElement[] origin = new Exception().getStackTrace();
+    public boolean create(UUID player, String name, ServerTemplate template, Version version, Integer port, Consumer<SubServer> callback) {
+        Util.nullpo(name, template);
+        if (host.isAvailable() && host.isEnabled() && template.isEnabled() && !SubAPI.getInstance().getSubServers().containsKey(name.toLowerCase()) && !SubCreator.isReserved(name) && (version != null || !template.requiresVersion())) {
+            StackTraceElement[] origin = new Throwable().getStackTrace();
 
             if (port == null) {
                 Value<Integer> i = new Container<Integer>(ports.lowerEndpoint() - 1);
@@ -401,7 +409,7 @@ public class InternalSubCreator extends SubCreator {
 
             CreatorTask task = new CreatorTask(player, name, template, version, port, server -> {
                 if (callback != null) try {
-                    callback.run(server);
+                    callback.accept(server);
                 } catch (Throwable e) {
                     Throwable ew = new InvocationTargetException(e);
                     ew.setStackTrace(origin);
@@ -424,17 +432,17 @@ public class InternalSubCreator extends SubCreator {
 
     @SuppressWarnings("deprecation")
     @Override
-    public boolean update(UUID player, SubServer server, ServerTemplate template, Version version, Callback<Boolean> callback) {
-        if (Util.isNull(server)) throw new NullPointerException();
+    public boolean update(UUID player, SubServer server, ServerTemplate template, Version version, Consumer<Boolean> callback) {
+        Util.nullpo(server);
         final ServerTemplate ft = (template == null)?server.getTemplate():template;
         if (host.isAvailable() && host.isEnabled() && host == server.getHost() && server.isAvailable() && !server.isRunning() && ft != null && ft.isEnabled() && ft.canUpdate() && (version != null || !ft.requiresVersion())) {
-            StackTraceElement[] origin = new Exception().getStackTrace();
+            StackTraceElement[] origin = new Throwable().getStackTrace();
 
             ((InternalSubServer) server).updating(true);
             CreatorTask task = new CreatorTask(player, server, ft, version, x -> {
                 ((InternalSubServer) server).updating(false);
                 if (callback != null) try {
-                    callback.run(x != null);
+                    callback.accept(x != null);
                 } catch (Throwable e) {
                     Throwable ew = new InvocationTargetException(e);
                     ew.setStackTrace(origin);
@@ -466,7 +474,7 @@ public class InternalSubCreator extends SubCreator {
 
     @Override
     public void terminate(String name) {
-        if (this.thread.keySet().contains(name.toLowerCase())) {
+        if (this.thread.containsKey(name.toLowerCase())) {
             if (this.thread.get(name.toLowerCase()).process != null && this.thread.get(name.toLowerCase()).process.isAlive()) {
                 Executable.terminate(this.thread.get(name.toLowerCase()).process);
             } else if (this.thread.get(name.toLowerCase()).isAlive()) {
@@ -487,7 +495,7 @@ public class InternalSubCreator extends SubCreator {
 
     @Override
     public void waitFor(String name) throws InterruptedException {
-        while (this.thread.keySet().contains(name.toLowerCase()) && this.thread.get(name.toLowerCase()).isAlive()) {
+        while (this.thread.containsKey(name.toLowerCase()) && this.thread.get(name.toLowerCase()).isAlive()) {
             Thread.sleep(250);
         }
     }
@@ -536,7 +544,7 @@ public class InternalSubCreator extends SubCreator {
 
     @Override
     public void setLogging(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         log.value(value);
     }
 
@@ -554,21 +562,31 @@ public class InternalSubCreator extends SubCreator {
 
     @Override
     public Map<String, ServerTemplate> getTemplates() {
-        return new TreeMap<String, ServerTemplate>(templates);
+        TreeMap<String, ServerTemplate> map = new TreeMap<String, ServerTemplate>();
+        for (Map.Entry<String, ServerTemplate> template : templates.entrySet()) {
+            if (!template.getValue().isInternal()) map.put(template.getKey(), template.getValue());
+        }
+        return map;
     }
 
     @Override
     public ServerTemplate getTemplate(String name) {
-        if (Util.isNull(name)) throw new NullPointerException();
-        return getTemplates().get(name.toLowerCase());
+        Util.nullpo(name);
+
+        ServerTemplate template = templates.getOrDefault(name.toLowerCase(), null);
+        if (template == null || template.isInternal()) {
+            return null;
+        } else {
+            return template;
+        }
     }
 
     private static Pair<YAMLSection, Map<String, Object>> subdata = null;
     private Map<String, Object> getSubData() {
         if (subdata == null || host.plugin.config.get() != subdata.key()) {
             Map<String, Object> map = new HashMap<String, Object>();
-            map.put("Address", host.plugin.config.get().getMap("Settings").getMap("SubData").getRawString("Address", "127.0.0.1").replace("0.0.0.0", "127.0.0.1"));
-            if (host.plugin.config.get().getMap("Settings").getMap("SubData").getRawString("Password", "").length() > 0) map.put("Password", host.plugin.config.get().getMap("Settings").getMap("SubData").getRawString("Password"));
+            map.put("Address", host.plugin.config.get().getMap("Settings").getMap("SubData").getString("Address", "127.0.0.1").replace("0.0.0.0", "127.0.0.1"));
+            if (host.plugin.config.get().getMap("Settings").getMap("SubData").getString("Password", "").length() > 0) map.put("Password", host.plugin.config.get().getMap("Settings").getMap("SubData").getString("Password"));
             subdata = new ContainedPair<>(host.plugin.config.get(), map);
         }
         return subdata.value();
@@ -578,49 +596,46 @@ public class InternalSubCreator extends SubCreator {
         boolean installed = false;
         if (type == ServerType.SPIGOT) {
             installed = true;
-            if (!new UniversalFile(dir, "plugins").exists()) new UniversalFile(dir, "plugins").mkdirs();
-            if (!new UniversalFile(dir, "plugins:SubServers.Client.jar").exists())
-                Util.copyFromJar(SubProxy.class.getClassLoader(), "net/ME1312/SubServers/Bungee/Library/Files/client.jar", new UniversalFile(dir, "plugins:SubServers.Client.jar").getPath());
+            if (!new File(dir, "plugins").exists()) new File(dir, "plugins").mkdirs();
+            if (!new File(dir, "plugins/SubServers.Client.jar").exists())
+                Util.copyFromJar(SubProxy.class.getClassLoader(), "net/ME1312/SubServers/Bungee/Library/Files/client.jar", new File(dir, "plugins/SubServers.Client.jar").getPath());
         } else if (type == ServerType.FORGE || type == ServerType.SPONGE) {
             installed = true;
-            if (!new UniversalFile(dir, "mods").exists()) new UniversalFile(dir, "mods").mkdirs();
-            if (!new UniversalFile(dir, "mods:SubServers.Client.jar").exists())
-                Util.copyFromJar(SubProxy.class.getClassLoader(), "net/ME1312/SubServers/Bungee/Library/Files/client.jar", new UniversalFile(dir, "mods:SubServers.Client.jar").getPath());
+            if (!new File(dir, "mods").exists()) new File(dir, "mods").mkdirs();
+            if (!new File(dir, "mods/SubServers.Client.jar").exists())
+                Util.copyFromJar(SubProxy.class.getClassLoader(), "net/ME1312/SubServers/Bungee/Library/Files/client.jar", new File(dir, "mods/SubServers.Client.jar").getPath());
         }
 
         if (installed) {
             YAMLSection config = new YAMLSection();
-            FileWriter writer = new FileWriter(new UniversalFile(dir, "subdata.json"), false);
-            config.set("Name", name);
+            FileWriter writer = new FileWriter(new File(dir, "subdata.json"), false);
             config.setAll(getSubData());
-            writer.write(config.toJSON().toString());
+            writer.write(new Gson().toJson(config.get()));
             writer.close();
 
-            if (!new UniversalFile(dir, "subdata.rsa.key").exists() && new UniversalFile("SubServers:subdata.rsa.key").exists()) {
-                Files.copy(new UniversalFile("SubServers:subdata.rsa.key").toPath(), new UniversalFile(dir, "subdata.rsa.key").toPath());
+            if (!new File(dir, "subdata.rsa.key").exists() && new File("SubServers/subdata.rsa.key").exists()) {
+                Files.copy(new File("SubServers/subdata.rsa.key").toPath(), new File(dir, "subdata.rsa.key").toPath());
             }
         }
     }
 
-    private void updateDirectory(File from, File to) {
-        if (from.isDirectory() && !Files.isSymbolicLink(from.toPath())) {
-            if (!to.exists()) {
-                to.mkdirs();
-            }
-
+    private void updateDirectory(File from, File to, boolean overwrite) {
+        if (!to.exists()) {
+            Directories.copy(from, to);
+        } else if (from.isDirectory() && !Files.isSymbolicLink(from.toPath())) {
             String files[] = from.list();
 
             for (String file : files) {
                 File srcFile = new File(from, file);
                 File destFile = new File(to, file);
 
-                updateDirectory(srcFile, destFile);
+                updateDirectory(srcFile, destFile, overwrite);
             }
         } else {
             try {
-                if (!to.exists() || from.length() != to.length() || !Arrays.equals(generateSHA256(to), generateSHA256(from))) {
+                if (overwrite && (from.length() != to.length() || !Arrays.equals(generateSHA256(to), generateSHA256(from)))) {
                     if (to.exists()) {
-                        if (to.isDirectory()) Util.deleteDirectory(to);
+                        if (to.isDirectory()) Directories.delete(to);
                         else to.delete();
                     }
                     Files.copy(from.toPath(), to.toPath(), LinkOption.NOFOLLOW_LINKS, StandardCopyOption.REPLACE_EXISTING);
@@ -632,7 +647,7 @@ public class InternalSubCreator extends SubCreator {
     } private byte[] generateSHA256(File file) throws Exception {
         MessageDigest md = MessageDigest.getInstance("SHA-256");
         FileInputStream fis = new FileInputStream(file);
-        byte[] dataBytes = new byte[1024];
+        byte[] dataBytes = new byte[4096];
 
         int nread;
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/Internal/InternalSubLogger.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Host.Internal;
 
 import net.ME1312.Galaxi.Library.Container.Value;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.SubLogFilter;
 import net.ME1312.SubServers.Bungee.Host.SubLogger;
@@ -48,6 +49,16 @@ public class InternalSubLogger extends SubLogger {
         this.file = file;
     }
 
+    void init() {
+        List<SubLogFilter> filters = new ArrayList<SubLogFilter>();
+        filters.addAll(this.filters);
+        for (SubLogFilter filter : filters) try {
+            filter.start();
+        } catch (Throwable e) {
+            new InvocationTargetException(e, "Exception while running SubLogger Event").printStackTrace();
+        }
+    }
+
     @Override
     public void start() {
         started = true;
@@ -62,13 +73,6 @@ public class InternalSubLogger extends SubLogger {
         }
         if (out == null) (out = new Thread(() -> start(process.getInputStream(), false), "SubServers.Bungee::Internal_Log_Spooler(" + name + ')')).start();
         if (err == null) (err = new Thread(() -> start(process.getErrorStream(), true), "SubServers.Bungee::Internal_Error_Spooler(" + name + ')')).start();
-        List<SubLogFilter> filters = new ArrayList<SubLogFilter>();
-        filters.addAll(this.filters);
-        for (SubLogFilter filter : filters) try {
-            filter.start();
-        } catch (Throwable e) {
-            new InvocationTargetException(e, "Exception while running SubLogger Event").printStackTrace();
-        }
     }
 
     @SuppressWarnings("deprecation")
@@ -90,48 +94,46 @@ public class InternalSubLogger extends SubLogger {
         }
     }
 
+    private Level level = Level.INFO;
+    private static final String PATTERN = "^((?:\\s*\\[?([0-9]{2}:[0-9]{2}:[0-9]{2})]?)?[\\s\\/\\\\\\|]*(?:\\[|\\[.*\\/)?(DEBUG|MESSAGE|MSG|" + Pattern.quote(Level.INFO.getLocalizedName()) + "|INFO|" + Pattern.quote(Level.WARNING.getLocalizedName()) + "|WARNING|WARN|ERROR|ERR|" + Pattern.quote(Level.SEVERE.getLocalizedName()) + "|SEVERE)\\]?(?::|\\s*>)?\\s*)";
     private void log(String line) {
         if (!line.startsWith(">")) {
             String msg = line;
-            Level level;
 
             // REGEX Formatting
-            String type = "";
-            Matcher matcher = Pattern.compile("^((?:\\s*\\[?([0-9]{2}:[0-9]{2}:[0-9]{2})]?)?[\\s\\/\\\\\\|]*(?:\\[|\\[.*\\/)?(MESSAGE|INFO|WARNING|WARN|ERROR|ERR|SEVERE)\\]?:?(?:\\s*>)?\\s*)").matcher(msg.replaceAll("\u001B\\[[;\\d]*m", ""));
-            while (matcher.find()) {
+            String type = null;
+            Matcher matcher = Pattern.compile(PATTERN).matcher(msg.replaceAll("\u001B\\[[;\\d]*m", ""));
+            if (matcher.find()) {
                 type = matcher.group(3).toUpperCase();
             }
 
-            msg = msg.replaceAll("^((?:\\s*\\[?([0-9]{2}:[0-9]{2}:[0-9]{2})]?)?[\\s\\/\\\\\\|]*(?:\\[|\\[.*\\/)?(MESSAGE|INFO|WARNING|WARN|ERROR|ERR|SEVERE)\\]?:?(?:\\s*>)?\\s*)", "");
+            msg = msg.replaceAll(PATTERN, "");
 
             // Determine LOG LEVEL
-            switch (type) {
-                case "WARNING":
-                case "WARN":
-                    level = Level.WARNING;
-                    break;
-                case "SEVERE":
-                case "ERROR":
-                case "ERR":
-                    level = Level.SEVERE;
-                    break;
-                default:
+            if (type != null) {
+                if (type.equalsIgnoreCase(Level.INFO.getLocalizedName())) {
                     level = Level.INFO;
+                } else if (type.equalsIgnoreCase(Level.WARNING.getLocalizedName())) {
+                    level = Level.WARNING;
+                } else if (type.equalsIgnoreCase(Level.SEVERE.getLocalizedName())) {
+                    level = Level.SEVERE;
+                } else switch (type) {
+                    case "WARNING":
+                    case "WARN":
+                        level = Level.WARNING;
+                        break;
+                    case "SEVERE":
+                    case "ERROR":
+                    case "ERR":
+                        level = Level.SEVERE;
+                        break;
+                    default:
+                        level = Level.INFO;
+                }
             }
 
-            // Filter Message
-            boolean allow = (SubAPI.getInstance().getInternals().sudo == getHandler() && SubAPI.getInstance().getInternals().canSudo) || (log.value() && (SubAPI.getInstance().getInternals().sudo == null || !SubAPI.getInstance().getInternals().canSudo));
-            List<SubLogFilter> filters = new ArrayList<SubLogFilter>();
-            filters.addAll(this.filters);
-            for (SubLogFilter filter : filters)
-                try {
-                    allow = (filter.log(level, msg) && allow);
-                } catch (Throwable e) {
-                    new InvocationTargetException(e, "Exception while running SubLogger Event").printStackTrace();
-                }
-
-            // Log to CONSOLE
-            if (allow) Logger.get(name).log(level, msg);
+            // Log to FILTER
+            log(level, msg);
 
             // Log to FILE
             if (writer != null) {
@@ -141,49 +143,68 @@ public class InternalSubLogger extends SubLogger {
         }
     }
 
+    void log(Level level, String message) {
+        // Filter Message
+        boolean allow = (SubAPI.getInstance().getInternals().sudo == getHandler() && SubAPI.getInstance().getInternals().canSudo) || (log.value() && (SubAPI.getInstance().getInternals().sudo == null || !SubAPI.getInstance().getInternals().canSudo));
+        List<SubLogFilter> filters = new ArrayList<SubLogFilter>();
+        filters.addAll(this.filters);
+        for (SubLogFilter filter : filters) {
+            try {
+                allow = (filter.log(level, message) && allow);
+            } catch (Throwable e) {
+                new InvocationTargetException(e, "Exception while running SubLogger Event").printStackTrace();
+            }
+        }
+
+        // Log to CONSOLE
+        if (allow || !started) {
+            Logger.get(name).log(level, message);
+        }
+    }
+
     @Override
     public void stop() {
         try {
             if (out != null) out.interrupt();
             if (err != null) err.interrupt();
-            destroy();
+            level = Level.INFO;
+
+            if (started) {
+                started = false;
+                if (writer != null) {
+                    PrintWriter writer = this.writer;
+                    this.writer = null;
+                    int l = (("---------- LOG START \u2014 " + name + " ----------").length() - 9) / 2;
+                    String s = "";
+                    while (s.length() < l) s += '-';
+                    if (writer != null) {
+                        writer.println(s + " LOG END " + s);
+                        writer.close();
+                    }
+                }
+            }
         } catch (NullPointerException e) {}
     }
 
+    void destroy() {
+        filters.addAll(this.filters);
+        for (SubLogFilter filter : filters) try {
+            filter.stop();
+        } catch (Throwable e) {
+            new InvocationTargetException(e, "Exception while running SubLogger Event").printStackTrace();
+        }
+    }
+
     @Override
     public void registerFilter(SubLogFilter filter) {
-        if (Util.isNull(filter)) throw new NullPointerException();
+        Util.nullpo(filter);
         filters.add(filter);
     }
 
     @Override
     public void unregisterFilter(SubLogFilter filter) {
-        if (Util.isNull(filter)) throw new NullPointerException();
-        Util.isException(() -> filters.remove(filter));
-    }
-
-    private void destroy() {
-        if (started) {
-            started = false;
-            List<SubLogFilter> filters = new ArrayList<SubLogFilter>();
-            filters.addAll(this.filters);
-            for (SubLogFilter filter : filters) try {
-                filter.stop();
-            } catch (Throwable e) {
-                new InvocationTargetException(e, "Exception while running SubLogger Event").printStackTrace();
-            }
-            if (writer != null) {
-                PrintWriter writer = this.writer;
-                this.writer = null;
-                int l = (int) Math.floor((("---------- LOG START \u2014 " + name + " ----------").length() - 9) / 2);
-                String s = "";
-                while (s.length() < l) s += '-';
-                if (writer != null) {
-                    writer.println(s + " LOG END " + s);
-                    writer.close();
-                }
-            }
-        }
+        Util.nullpo(filter);
+        Try.all.run(() -> filters.remove(filter));
     }
 
     @Override

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/Internal/InternalSubServer.java

@@ -5,23 +5,25 @@ import net.ME1312.Galaxi.Library.Container.Container;
 import net.ME1312.Galaxi.Library.Container.Value;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
-import net.ME1312.Galaxi.Library.UniversalFile;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.Galaxi.Library.Version.Version;
+import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.SubServers.Bungee.Event.*;
 import net.ME1312.SubServers.Bungee.Host.*;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExEditServer;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExEditServer.Edit;
+import net.ME1312.SubServers.Bungee.SubAPI;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
-import net.md_5.bungee.BungeeServerInfo;
 import net.md_5.bungee.api.ChatColor;
 
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
-import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
@@ -92,7 +94,7 @@ public class InternalSubServer extends SubServerImpl {
     }
 
     private void init(InternalHost host, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException {
-        if (Util.isNull(host, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted)) throw new NullPointerException();
+        Util.nullpo(host, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
         this.host = host;
         this.enabled = enabled;
         this.log = new Container<Boolean>(log);
@@ -106,12 +108,12 @@ public class InternalSubServer extends SubServerImpl {
         this.logger = new InternalSubLogger(null, this, getName(), this.log, null);
         this.thread = null;
         this.command = null;
-        final UniversalFile[] locations = new UniversalFile[] {
-                new UniversalFile(this.directory, "plugins:SubServers.Client.jar"),
-                new UniversalFile(this.directory, "mods:SubServers.Client.jar")
+        final File[] locations = new File[] {
+                new File(this.directory, "plugins/SubServers.Client.jar"),
+                new File(this.directory, "mods/SubServers.Client.jar")
         };
 
-        for (UniversalFile location : locations) {
+        for (File location : locations) {
             if (location.exists()) {
                 try {
                     JarInputStream updated = new JarInputStream(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/client.jar"));
@@ -147,6 +149,7 @@ public class InternalSubServer extends SubServerImpl {
     private void run() {
         boolean locked = lock;
         allowrestart = true;
+        stopping = false;
         started = false;
         try {
             ProcessBuilder pb = new ProcessBuilder().command(Executable.parse(host.getCreator().getBashDirectory(), executable)).directory(directory);
@@ -155,6 +158,7 @@ public class InternalSubServer extends SubServerImpl {
             pb.environment().put("host", host.getName());
             pb.environment().put("address", host.getAddress().getHostAddress());
             pb.environment().put("port", Integer.toString(getAddress().getPort()));
+            logger.init();
             process = pb.start();
             Logger.get("SubServers").info("Now starting " + getName());
             logger.process = process;
@@ -174,9 +178,12 @@ public class InternalSubServer extends SubServerImpl {
             allowrestart = false;
         }
 
+        logger.destroy();
         Logger.get("SubServers").info(getName() + " has stopped");
         process = null;
         command = null;
+        started = false;
+        stopping = false;
         history.clear();
 
         SubStoppedEvent event = new SubStoppedEvent(this);
@@ -241,6 +248,7 @@ public class InternalSubServer extends SubServerImpl {
             host.plugin.getPluginManager().callEvent(event);
             if (!event.isCancelled()) {
                 try {
+                    stopping = true;
                     allowrestart = false;
                     history.add(new LoggedCommand(player, stopcmd));
                     if (process != null && process.isAlive()) {
@@ -263,6 +271,7 @@ public class InternalSubServer extends SubServerImpl {
             SubStopEvent event = new SubStopEvent(player, this, true);
             host.plugin.getPluginManager().callEvent(event);
             if (!event.isCancelled()) {
+                stopping = true;
                 allowrestart = false;
                 if (process != null && process.isAlive()) Executable.terminate(process);
                 return true;
@@ -272,13 +281,16 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public boolean command(UUID player, String command) {
-        if (Util.isNull(command)) throw new NullPointerException();
+        Util.nullpo(command);
         if (thread != null && thread.isAlive()) {
-            SubSendCommandEvent event = new SubSendCommandEvent(player, this, command);
+            SubSendCommandEvent event = new SubSendCommandEvent(player, this, command, null);
             host.plugin.getPluginManager().callEvent(event);
-            if (!event.isCancelled()) {
+            if (!event.isCancelled() && (player == null || !DISALLOWED_COMMANDS.matcher(command).find())) {
                 try {
-                    if (event.getCommand().equalsIgnoreCase(stopcmd)) allowrestart = false;
+                    if (event.getCommand().equalsIgnoreCase(stopcmd)) {
+                        stopping = true;
+                        allowrestart = false;
+                    }
                     history.add(new LoggedCommand(player, event.getCommand()));
                     if (process != null && process.isAlive()) {
                         this.command.write(event.getCommand());
@@ -316,7 +328,7 @@ public class InternalSubServer extends SubServerImpl {
                         switch (key.toLowerCase()) {
                             case "name":
                                 if (value.isString() && host.removeSubServer(player, getName())) {
-                                    SubServer server = host.constructSubServer(value.asRawString(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
+                                    SubServer server = host.constructSubServer(value.asString(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
                                     if (server != null) {
                                         if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                             ObjectMap<String> config = this.host.plugin.servers.get().getMap("Servers").getMap(getName());
@@ -331,14 +343,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "display":
                                 if (value.isString()) {
-                                    Field f = ServerImpl.class.getDeclaredField("nick");
-                                    f.setAccessible(true);
-                                    if (value.isNull() || value.asString().length() == 0 || getName().equals(value.asString())) {
-                                        f.set(this, null);
-                                    } else {
-                                        f.set(this, value.asString());
-                                    }
-                                    f.setAccessible(false);
+                                    setDisplayName(value.asString());
                                     logger.name = getDisplayName();
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         if (getName().equals(getDisplayName())) {
@@ -363,9 +368,9 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "group":
                                 if (value.isList()) {
-                                    Util.reflect(ServerImpl.class.getDeclaredField("groups"), this, value.asRawStringList());
+                                    Util.reflect(ServerImpl.class.getDeclaredField("groups"), this, value.asStringList());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
-                                        this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Group", value.asRawStringList());
+                                        this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Group", value.asStringList());
                                         this.host.plugin.servers.save();
                                     }
                                     c++;
@@ -373,7 +378,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "host":
                                 if (value.isString() && host.removeSubServer(player, getName())) {
-                                    SubServer server = this.host.plugin.api.getHost(value.asRawString()).constructSubServer(getName(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
+                                    SubServer server = this.host.plugin.api.getHost(value.asString()).constructSubServer(getName(), isEnabled(), getAddress().getPort(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
                                     if (server != null) {
                                         if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                             this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Host", server.getHost().getName());
@@ -386,9 +391,9 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "template":
                                 if (value.isString()) {
-                                    setTemplate(value.asRawString());
+                                    setTemplate(value.asString());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
-                                        this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Template", value.asRawString());
+                                        this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Template", value.asString());
                                         this.host.plugin.servers.save();
                                     }
                                     c++;
@@ -409,7 +414,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "motd":
                                 if (value.isString()) {
-                                    setMotd(ChatColor.translateAlternateColorCodes('&', value.asString()));
+                                    setMotd(ChatColor.translateAlternateColorCodes('&', Util.unescapeJavaString(value.asString())));
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Motd", value.asString());
                                         this.host.plugin.servers.save();
@@ -434,8 +439,8 @@ public class InternalSubServer extends SubServerImpl {
                                         stop(player);
                                         waitFor();
                                     }
-                                    dir = value.asRawString();
-                                    directory = new File(getHost().getPath(), value.asRawString());
+                                    dir = value.asString();
+                                    directory = new File(getHost().getPath(), value.asString());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Directory", getPath());
                                         this.host.plugin.servers.save();
@@ -450,9 +455,9 @@ public class InternalSubServer extends SubServerImpl {
                                         stop(player);
                                         waitFor();
                                     }
-                                    executable = value.asRawString();
+                                    executable = value.asString();
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
-                                        this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Executable", value.asRawString());
+                                        this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Executable", value.asString());
                                         this.host.plugin.servers.save();
                                     }
                                     c++;
@@ -461,7 +466,7 @@ public class InternalSubServer extends SubServerImpl {
                             case "stop-cmd":
                             case "stop-command":
                                 if (value.isString()) {
-                                    stopcmd = value.asRawString();
+                                    stopcmd = value.asString();
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Stop-Command", getStopCommand());
                                         this.host.plugin.servers.save();
@@ -471,7 +476,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "stop-action":
                                 if (value.isString()) {
-                                    StopAction action = Util.getDespiteException(() -> StopAction.valueOf(value.asRawString().toUpperCase().replace('-', '_').replace(' ', '_')), null);
+                                    StopAction action = Try.all.get(() -> StopAction.valueOf(value.asString().toUpperCase().replace('-', '_').replace(' ', '_')));
                                     if (action != null) {
                                         stopaction = action;
                                         if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
@@ -534,6 +539,9 @@ public class InternalSubServer extends SubServerImpl {
                             case "whitelist":
                                 if (value.isList()) {
                                     Util.reflect(ServerImpl.class.getDeclaredField("whitelist"), this, value.asUUIDList());
+                                    if (isRegistered()) for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+                                        ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.WHITELIST_SET, value.asUUIDList()));
+                                    }
                                     c++;
                                 }
                                 break;
@@ -599,7 +607,7 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public void setEnabled(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         enabled = value;
     }
 
@@ -610,7 +618,7 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public void setLogging(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         log.value(value);
     }
 
@@ -641,7 +649,7 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public void setStopCommand(String value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         stopcmd = value;
     }
 
@@ -652,7 +660,7 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public void setStopAction(StopAction action) {
-        if (Util.isNull(action)) throw new NullPointerException();
+        Util.nullpo(action);
         stopaction = action;
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/Proxy.java

@@ -19,24 +19,18 @@ import java.util.*;
 /**
  * Proxy Class
  */
-public class Proxy implements ClientHandler, ExtraDataHandler {
-    private HashMap<Integer, SubDataClient> subdata = new HashMap<Integer, SubDataClient>();
-    private ObjectMap<String> extra = new ObjectMap<String>();
+public class Proxy implements ClientHandler, ExtraDataHandler<String> {
+    private final HashMap<Integer, SubDataClient> subdata = new HashMap<Integer, SubDataClient>();
+    private final ObjectMap<String> extra = new ObjectMap<String>();
     private final String signature;
-    private boolean persistent;
+    private boolean persistent = false;
     private String nick = null;
     private final String name;
 
     public Proxy(String name) throws IllegalArgumentException {
-        this(name, name != null);
-    }
-
-    @SuppressWarnings("deprecation")
-    public Proxy(String name, boolean persistent) throws IllegalArgumentException {
         if (name == null) name = Util.getNew(SubAPI.getInstance().getInternals().proxies.keySet(), () -> UUID.randomUUID().toString());
         if (name.contains(" ")) throw new IllegalArgumentException("Proxy names cannot have spaces: " + name);
         this.name = name;
-        this.persistent = persistent;
         this.signature = SubAPI.getInstance().signAnonymousObject();
 
         subdata.put(0, null);
@@ -56,7 +50,7 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
         boolean update = false;
         if (channel < 0) throw new IllegalArgumentException("Subchannel ID cannot be less than zero");
         if (client != null || channel == 0) {
-            if (!subdata.keySet().contains(channel) || (channel == 0 && (client == null || subdata.get(channel) == null))) {
+            if (!subdata.containsKey(channel) || (channel == 0 && (client == null || subdata.get(channel) == null))) {
                 update = true;
                 subdata.put(channel, client);
                 if (client != null && (client.getHandler() == null || !equals(client.getHandler()))) client.setHandler(this);
@@ -146,6 +140,13 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
         return players;
     }
 
+    /**
+     * Makes it so the proxy object will still exist within the server manager even if it is disconnected
+     */
+    public final void persist() {
+        persistent = true;
+    }
+
     /**
      * Get the Signature of this Object
      *
@@ -155,21 +156,26 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
         return signature;
     }
 
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof Proxy && signature.equals(((Proxy) obj).signature);
+    }
+
     @Override
     public void addExtra(String handle, Object value) {
-        if (Util.isNull(handle, value)) throw new NullPointerException();
+        Util.nullpo(handle, value);
         extra.set(handle, value);
     }
 
     @Override
     public boolean hasExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         return extra.getKeys().contains(handle);
     }
 
     @Override
     public ObjectMapValue getExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         return extra.get(handle);
     }
 
@@ -180,7 +186,7 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
 
     @Override
     public void removeExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         extra.remove(handle);
     }
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/RemotePlayer.java

@@ -1,14 +1,26 @@
 package net.ME1312.SubServers.Bungee.Host;
 
+import net.ME1312.Galaxi.Library.Container.ContainedPair;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.SubData.Server.SubDataSerializable;
+import net.ME1312.SubServers.Bungee.Library.Compatibility.RPSI;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketDisconnectPlayer;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketMessagePlayer;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketTransferPlayer;
 import net.ME1312.SubServers.Bungee.SubAPI;
 
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.api.config.ServerInfo;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
+import java.lang.reflect.InvocationTargetException;
 import java.net.InetSocketAddress;
+import java.util.Arrays;
 import java.util.UUID;
+import java.util.function.IntConsumer;
 
 /**
  * Remote Player Class
@@ -27,9 +39,21 @@ public class RemotePlayer implements net.ME1312.SubServers.Bungee.Library.Compat
      * @param player Local Player
      */
     public RemotePlayer(ProxiedPlayer player) {
-        if (Util.isNull(player)) throw new NullPointerException();
+        this(player, player.getServer().getInfo());
+    }
+
+
+    /**
+     * Translate a Local Player to a Remote Player
+     *
+     * @param player Local Player
+     * @param server Server the player is on
+     */
+    public RemotePlayer(ProxiedPlayer player, ServerInfo server) {
+        Util.nullpo(player);
         this.local = player;
         this.id = player.getUniqueId();
+        this.server = (server instanceof Server)? (Server) server : null;
     }
 
     /**
@@ -41,24 +65,24 @@ public class RemotePlayer implements net.ME1312.SubServers.Bungee.Library.Compat
      * @param server Server the player is on
      * @param ip Player IP Address
      */
-    public RemotePlayer(String name, UUID id, Proxy proxy, Server server, InetSocketAddress ip) {
-        if (Util.isNull(name, id, proxy, ip)) throw new NullPointerException();
+    public RemotePlayer(String name, UUID id, Proxy proxy, ServerInfo server, InetSocketAddress ip) {
+        Util.nullpo(name, id, proxy, ip);
         this.id = id;
         this.name = name;
         this.ip = ip;
         this.proxy = proxy;
-        this.server = server;
+        this.server = (server instanceof Server)? (Server) server : null;
     }
 
-    /**
-     * Get Local Player
-     *
-     * @return Local Player (or null when not local)
-     */
+    @Override
     public ProxiedPlayer get() {
         return local;
     }
 
+    private static ProxiedPlayer get(UUID player) {
+        return ProxyServer.getInstance().getPlayer(player);
+    }
+
     @Override
     public UUID getUniqueId() {
         if (local != null) {
@@ -98,11 +122,14 @@ public class RemotePlayer implements net.ME1312.SubServers.Bungee.Library.Compat
         return (proxy == null)? null : proxy.getName();
     }
 
+    private SubDataClient getProxyConnection() {
+        Proxy proxy = getProxy();
+        return (proxy == null)? null : (SubDataClient) proxy.getSubData()[0];
+    }
+
     @Override
     public Server getServer() {
-        if (local != null) {
-            return (Server) local.getServer().getInfo();
-        } else return server;
+        return server;
     }
 
     @Override
@@ -126,4 +153,162 @@ public class RemotePlayer implements net.ME1312.SubServers.Bungee.Library.Compat
         if (getProxy() != null) pinfo.set("proxy", getProxy().getName());
         return pinfo;
     }
+
+    static {
+        // These overrides provide for the static methods in BungeeCommon
+        new RPSI() {
+            @Override
+            protected void sendMessage(UUID[] players, String[] messages, IntConsumer response) {
+                StackTraceElement[] origin = new Throwable().getStackTrace();
+                PacketMessagePlayer.run(Arrays.asList(players), new ContainedPair<>(messages, null), null, i -> {
+                    try {
+                        response.accept(i);
+                    } catch (Throwable e) {
+                        Throwable ew = new InvocationTargetException(e);
+                        ew.setStackTrace(origin);
+                        ew.printStackTrace();
+                    }
+                });
+            }
+
+            @Override
+            protected void sendMessage(UUID[] players, BaseComponent[][] messages, IntConsumer response) {
+                StackTraceElement[] origin = new Throwable().getStackTrace();
+                PacketMessagePlayer.run(Arrays.asList(players), new ContainedPair<>(null, messages), null, i -> {
+                    try {
+                        response.accept(i);
+                    } catch (Throwable e) {
+                        Throwable ew = new InvocationTargetException(e);
+                        ew.setStackTrace(origin);
+                        ew.printStackTrace();
+                    }
+                });
+            }
+
+            @Override
+            protected void transfer(UUID[] players, String server, IntConsumer response) {
+                StackTraceElement[] origin = new Throwable().getStackTrace();
+                PacketTransferPlayer.run(Arrays.asList(players), server, i -> {
+                    try {
+                        response.accept(i);
+                    } catch (Throwable e) {
+                        Throwable ew = new InvocationTargetException(e);
+                        ew.setStackTrace(origin);
+                        ew.printStackTrace();
+                    }
+                });
+            }
+
+            @Override
+            protected void disconnect(UUID[] players, String reason, IntConsumer response) {
+                StackTraceElement[] origin = new Throwable().getStackTrace();
+                PacketDisconnectPlayer.run(Arrays.asList(players), reason, i -> {
+                    try {
+                        response.accept(i);
+                    } catch (Throwable e) {
+                        Throwable ew = new InvocationTargetException(e);
+                        ew.setStackTrace(origin);
+                        ew.printStackTrace();
+                    }
+                });
+            }
+        };
+    }
+
+    // The following methods all redirect to their BungeeCommon counterparts
+    public static void broadcastMessage(String... messages) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.broadcastMessage(messages);
+    }
+
+    public static void broadcastMessage(String message, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.broadcastMessage(message, response);
+    }
+
+    public static void broadcastMessage(String[] messages, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.broadcastMessage(messages, response);
+    }
+
+    public static void sendMessage(UUID[] players, String... messages) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.sendMessage(players, messages);
+    }
+
+    public static void sendMessage(UUID[] players, String message, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.sendMessage(players, message, response);
+    }
+
+    public static void sendMessage(UUID[] players, String[] messages, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.sendMessage(players, messages, response);
+    }
+
+    public static void broadcastMessage(BaseComponent... message) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.broadcastMessage(message);
+    }
+
+    public static void broadcastMessage(BaseComponent message, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.broadcastMessage(message, response);
+    }
+
+    public static void broadcastMessage(BaseComponent[] message, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.broadcastMessage(message, response);
+    }
+
+    public static void broadcastMessage(BaseComponent[]... messages) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.broadcastMessage(messages);
+    }
+
+    public static void broadcastMessage(BaseComponent[][] messages, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.broadcastMessage(messages, response);
+    }
+
+    public static void sendMessage(UUID[] players, BaseComponent... message) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.sendMessage(players, message);
+    }
+
+    public static void sendMessage(UUID[] players, BaseComponent message, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.sendMessage(players, message, response);
+    }
+
+    public static void sendMessage(UUID[] players, BaseComponent[] message, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.sendMessage(players, message, response);
+    }
+
+    public static void sendMessage(UUID[] players, BaseComponent[]... messages) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.sendMessage(players, messages);
+    }
+
+    public static void sendMessage(UUID[] players, BaseComponent[][] messages, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.sendMessage(players, messages, response);
+    }
+
+    public static void transfer(UUID[] players, String server) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.transfer(players, server);
+    }
+
+    public static void transfer(UUID[] players, String server, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.transfer(players, server, response);
+    }
+
+    public static void transfer(UUID[] players, ServerInfo server) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.transfer(players, server);
+    }
+
+    public static void transfer(UUID[] players, ServerInfo server, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.transfer(players, server, response);
+    }
+
+    public static void disconnect(UUID... players) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.disconnect(players);
+    }
+
+    public static void disconnect(UUID[] players, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.disconnect(players, response);
+    }
+
+    public static void disconnect(UUID[] players, String reason) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.disconnect(players, reason);
+    }
+
+    public static void disconnect(UUID[] players, String reason, IntConsumer response) {
+        net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer.disconnect(players, reason, response);
+    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/Server.java

@@ -13,7 +13,7 @@ import java.util.UUID;
 /**
  * Server Interface
  */
-public interface Server extends ServerInfo, ClientHandler, ExtraDataHandler {
+public interface Server extends ServerInfo, ClientHandler, ExtraDataHandler<String> {
 
     /**
      * Link a SubData Client to this Object
@@ -58,6 +58,34 @@ public interface Server extends ServerInfo, ClientHandler, ExtraDataHandler {
      */
     void removeGroup(String value);
 
+    /**
+     * Commands the Server
+     *
+     * @param player Player who's Commanding
+     * @param target Player who will Send
+     * @param command Command to Send
+     */
+    boolean command(UUID player, UUID target, String command);
+
+    /**
+     * Commands the Server
+     *
+     * @param player Player who's Commanding
+     * @param command Command to Send
+     */
+    default boolean command(UUID player, String command) {
+        return command(player, null, command);
+    }
+
+    /**
+     * Commands the Server
+     *
+     * @param command Command to Send
+     */
+    default boolean command(String command) {
+        return command(null, command);
+    }
+
     /**
      * Get players on this server across all known proxies
      *
@@ -136,6 +164,11 @@ public interface Server extends ServerInfo, ClientHandler, ExtraDataHandler {
      */
     void unwhitelist(UUID player);
 
+    /**
+     * Makes it so the server object will still exist within the server manager even if it is disconnected
+     */
+    void persist();
+
     /**
      * Get the Signature of this Object
      *

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/ServerImpl.java

@@ -1,23 +1,24 @@
 package net.ME1312.SubServers.Bungee.Host;
 
-import net.ME1312.Galaxi.Library.Container.ContainedPair;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.DataClient;
 import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubServers.Bungee.Event.SubEditServerEvent;
-import net.ME1312.SubServers.Bungee.Event.SubNetworkConnectEvent;
-import net.ME1312.SubServers.Bungee.Event.SubNetworkDisconnectEvent;
+import net.ME1312.SubServers.Bungee.Event.SubSendCommandEvent;
+import net.ME1312.SubServers.Bungee.Host.SubServer.LoggedCommand;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
-import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExRunEvent;
-import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExUpdateWhitelist;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketExControlPlayer;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExEditServer;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExEditServer.Edit;
 import net.ME1312.SubServers.Bungee.SubAPI;
 
 import net.md_5.bungee.BungeeServerInfo;
 import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.ProxyServer;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
+import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.util.*;
@@ -33,6 +34,7 @@ public class ServerImpl extends BungeeServerInfo implements Server {
     private List<UUID> whitelist = new ArrayList<UUID>();
     private boolean hidden;
     private final String signature = SubAPI.getInstance().signAnonymousObject();
+    private volatile boolean persistent = true;
 
     /**
      * Construct a new Server data type
@@ -72,7 +74,7 @@ public class ServerImpl extends BungeeServerInfo implements Server {
 
     @SuppressWarnings("deprecation")
     private void init(String name, SocketAddress address, String motd, boolean hidden, boolean restricted) throws InvalidServerException {
-        if (Util.isNull(name, address, motd, hidden, restricted)) throw new NullPointerException();
+        Util.nullpo(name, address, motd, hidden, restricted);
         if (name.contains(" ")) throw new InvalidServerException("Server names cannot have spaces: " + name);
         SubAPI.getInstance().getInternals().subprotocol.whitelist(getAddress().getAddress().getHostAddress());
         this.hidden = hidden;
@@ -80,6 +82,16 @@ public class ServerImpl extends BungeeServerInfo implements Server {
         subdata.put(0, null);
     }
 
+    /**
+     * Get if this server has been registered
+     *
+     * @return Registered status
+     */
+    @SuppressWarnings("deprecation")
+    protected boolean isRegistered() {
+        return SubAPI.getInstance().getInternals().exServers.containsKey(getName().toLowerCase());
+    }
+
     @Override
     public DataClient[] getSubData() {
         Integer[] keys = subdata.keySet().toArray(new Integer[0]);
@@ -93,7 +105,7 @@ public class ServerImpl extends BungeeServerInfo implements Server {
         boolean update = false;
         if (channel < 0) throw new IllegalArgumentException("Subchannel ID cannot be less than zero");
         if (client != null || channel == 0) {
-            if (!subdata.keySet().contains(channel) || (channel == 0 && (client == null || subdata.get(channel) == null))) {
+            if (!subdata.containsKey(channel) || (channel == 0 && (client == null || subdata.get(channel) == null))) {
                 update = true;
                 subdata.put(channel, (SubDataClient) client);
                 if (client != null && (client.getHandler() == null || !equals(client.getHandler()))) ((SubDataClient) client).setHandler(this);
@@ -103,12 +115,20 @@ public class ServerImpl extends BungeeServerInfo implements Server {
             subdata.remove(channel);
         }
 
-        if (update) for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
-            ObjectMap<String> args = new ObjectMap<String>();
-            args.set("server", getName());
-            args.set("channel", channel);
-            if (client != null) args.set("id", client.getID());
-            ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExRunEvent((client != null)?SubNetworkConnectEvent.class:SubNetworkDisconnectEvent.class, args));
+        if (update) {
+            for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+                if (client != null) {
+                    ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.CONNECTED, channel, client.getID()));
+                } else {
+                    ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.DISCONNECTED, channel));
+                }
+            }
+            if (!persistent) {
+                DataClient[] subdata = getSubData();
+                if (subdata[0] == null && subdata.length <= 1) {
+                    SubAPI.getInstance().removeServer(getName());
+                }
+            }
         }
     }
 
@@ -130,6 +150,9 @@ public class ServerImpl extends BungeeServerInfo implements Server {
         } else {
             this.nick = value;
         }
+        for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+            ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.DISPLAY_NAME, getDisplayName()));
+        }
     }
 
     @Override
@@ -140,7 +163,7 @@ public class ServerImpl extends BungeeServerInfo implements Server {
     @Override
     @SuppressWarnings("deprecation")
     public void addGroup(String value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         if (value.length() > 0 && !groups.contains(value)) {
             groups.add(value);
             Collections.sort(groups);
@@ -150,11 +173,25 @@ public class ServerImpl extends BungeeServerInfo implements Server {
     @Override
     @SuppressWarnings("deprecation")
     public void removeGroup(String value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         groups.remove(value);
         Collections.sort(groups);
     }
 
+    @Override
+    public boolean command(UUID player, UUID target, String command) {
+        Util.nullpo(command);
+        SubDataClient channel = (SubDataClient) getSubData()[0];
+        if (channel != null) {
+            SubSendCommandEvent event = new SubSendCommandEvent(player, this, command, target);
+            ProxyServer.getInstance().getPluginManager().callEvent(event);
+            if (!event.isCancelled() && (player == null || !SubServerImpl.DISALLOWED_COMMANDS.matcher(command).find())) {
+                channel.sendPacket(new PacketExControlPlayer(target, command));
+                return true;
+            } else return false;
+        } else return false;
+    }
+
     @Override
     public Collection<RemotePlayer> getRemotePlayers() {
         return SubAPI.getInstance().getRemotePlayers(this).values();
@@ -167,23 +204,32 @@ public class ServerImpl extends BungeeServerInfo implements Server {
 
     @Override
     public void setHidden(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
         this.hidden = value;
+        if (isRegistered()) for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+            ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.HIDDEN, isHidden()));
+        }
     }
 
     public void setMotd(String value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         try {
             Util.reflect(BungeeServerInfo.class.getDeclaredField("motd"), this, value);
+            for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+                ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.MOTD, getMotd()));
+            }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
     public void setRestricted(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
+        Util.nullpo(value);
         try {
             Util.reflect(BungeeServerInfo.class.getDeclaredField("restricted"), this, value);
+
+            if (isRegistered()) for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+                ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.RESTRICTED, isRestricted()));
+            }
         } catch (Exception e) {
             e.printStackTrace();
         }
@@ -197,7 +243,7 @@ public class ServerImpl extends BungeeServerInfo implements Server {
      */
     @Override
     public boolean canAccess(CommandSender player) {
-        return (player instanceof ProxiedPlayer && whitelist.contains(((ProxiedPlayer) player).getUniqueId())) || super.canAccess(player);
+        return super.canAccess(player) || (player instanceof ProxiedPlayer && whitelist.contains(((ProxiedPlayer) player).getUniqueId()));
     }
 
     @Override
@@ -212,16 +258,25 @@ public class ServerImpl extends BungeeServerInfo implements Server {
 
     @Override
     public void whitelist(UUID player) {
-        if (Util.isNull(player)) throw new NullPointerException();
+        Util.nullpo(player);
         if (!whitelist.contains(player)) whitelist.add(player);
-        for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExUpdateWhitelist(getName(), true, player));
+        if (isRegistered()) for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+            ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.WHITELIST_ADD, player));
+        }
     }
 
     @Override
     public void unwhitelist(UUID player) {
-        if (Util.isNull(player)) throw new NullPointerException();
+        Util.nullpo(player);
         whitelist.remove(player);
-        for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExUpdateWhitelist(getName(), false, player));
+        if (isRegistered()) for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
+            ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketOutExEditServer(this, Edit.WHITELIST_REMOVE, player));
+        }
+    }
+
+    @Override
+    public final void persist() {
+        persistent = true;
     }
 
     @Override
@@ -229,21 +284,26 @@ public class ServerImpl extends BungeeServerInfo implements Server {
         return signature;
     }
 
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof ServerImpl && signature.equals(((ServerImpl) obj).signature);
+    }
+
     @Override
     public void addExtra(String handle, Object value) {
-        if (Util.isNull(handle, value)) throw new NullPointerException();
+        Util.nullpo(handle, value);
         extra.set(handle, value);
     }
 
     @Override
     public boolean hasExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         return extra.getKeys().contains(handle);
     }
 
     @Override
     public ObjectMapValue getExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         return extra.get(handle);
     }
 
@@ -254,7 +314,7 @@ public class ServerImpl extends BungeeServerInfo implements Server {
 
     @Override
     public void removeExtra(String handle) {
-        if (Util.isNull(handle)) throw new NullPointerException();
+        Util.nullpo(handle);
         extra.remove(handle);
     }
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/SubCreator.java

@@ -1,6 +1,5 @@
 package net.ME1312.SubServers.Bungee.Host;
 
-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;
@@ -12,6 +11,7 @@ import com.google.common.collect.Range;
 import java.io.File;
 import java.net.InetSocketAddress;
 import java.util.*;
+import java.util.function.Consumer;
 
 /**
  * SubCreator Layout Class
@@ -22,6 +22,7 @@ public abstract class SubCreator {
         private String name;
         private String nick = null;
         private boolean enabled;
+        private boolean internal;
         private String icon;
         private File directory;
         private ServerType type;
@@ -39,17 +40,18 @@ public abstract class SubCreator {
          * @param options Configuration Options
          */
         public ServerTemplate(String name, boolean enabled, String icon, File directory, ObjectMap<String> build, ObjectMap<String> options) {
-            this(name, enabled, icon, directory, build, options, true);
+            this(name, enabled, false, icon, directory, build, options, true);
         }
 
-        private ServerTemplate(String name, boolean enabled, String icon, File directory, ObjectMap<String> build, ObjectMap<String> options, boolean dynamic) {
-            if (Util.isNull(name, enabled, directory, build, options)) throw new NullPointerException();
+        private ServerTemplate(String name, boolean enabled, boolean internal, String icon, File directory, ObjectMap<String> build, ObjectMap<String> options, boolean dynamic) {
+            Util.nullpo(name, enabled, directory, build, options);
             if (name.contains(" ")) throw new InvalidTemplateException("Template names cannot have spaces: " + name);
             this.name = name;
             this.enabled = enabled;
+            this.internal = internal;
             this.icon = icon;
             this.directory = directory;
-            this.type = (build.contains("Server-Type"))?ServerType.valueOf(build.getRawString("Server-Type").toUpperCase()):ServerType.CUSTOM;
+            this.type = (build.contains("Server-Type"))?ServerType.valueOf(build.getString("Server-Type").toUpperCase()):ServerType.CUSTOM;
             this.build = build;
             this.options = options;
             this.dynamic = dynamic;
@@ -104,6 +106,15 @@ public abstract class SubCreator {
             enabled = value;
         }
 
+        /**
+         * Get if this Template is for Internal use only
+         *
+         * @return Internal Status
+         */
+        public boolean isInternal() {
+            return internal;
+        }
+
         /**
          * Get the Item Icon for this Template
          *
@@ -161,7 +172,7 @@ public abstract class SubCreator {
         /**
          * Get whether this Template was generated by a SubCreator instance
          *
-         * @return Custom Status
+         * @return Dynamic Status
          */
         public boolean isDynamic() {
             return dynamic;
@@ -222,7 +233,7 @@ public abstract class SubCreator {
      * @param callback Callback
      * @return Success Status
      */
-    public abstract boolean create(UUID player, String name, ServerTemplate template, Version version, Integer port, Callback<SubServer> callback);
+    public abstract boolean create(UUID player, String name, ServerTemplate template, Version version, Integer port, Consumer<SubServer> callback);
 
     /**
      * Create a SubServer
@@ -248,7 +259,7 @@ public abstract class SubCreator {
      * @param callback Callback
      * @return Success Status
      */
-    public boolean create(String name, ServerTemplate template, Version version, Integer port, Callback<SubServer> callback) {
+    public boolean create(String name, ServerTemplate template, Version version, Integer port, Consumer<SubServer> callback) {
         return create(null, name, template, version, port, callback);
     }
 
@@ -275,7 +286,7 @@ public abstract class SubCreator {
      * @param callback Callback
      * @return Success Status
      */
-    public abstract boolean update(UUID player, SubServer server, ServerTemplate template, Version version, Callback<Boolean> callback);
+    public abstract boolean update(UUID player, SubServer server, ServerTemplate template, Version version, Consumer<Boolean> callback);
 
     /**
      * Update a SubServer
@@ -299,7 +310,7 @@ public abstract class SubCreator {
      * @param callback Callback
      * @return Success Status
      */
-    public boolean update(SubServer server, ServerTemplate template, Version version, Callback<Boolean> callback) {
+    public boolean update(SubServer server, ServerTemplate template, Version version, Consumer<Boolean> callback) {
         return update(null, server, template, version, callback);
     }
 
@@ -512,17 +523,23 @@ public abstract class SubCreator {
      *
      * @param name Template Name
      * @param enabled Template Enabled Status
+     * @param internal Template Internal Status
      * @param icon Template Item Icon Name
      * @param directory Template Directory
      * @param build Build Options
      * @param options Configuration Options
      */
-    protected ServerTemplate loadTemplate(String name, boolean enabled, String icon, File directory, ObjectMap<String> build, ObjectMap<String> options) {
-        return new ServerTemplate(name, enabled, icon, directory, build, options, false);
+    protected ServerTemplate loadTemplate(String name, boolean enabled, boolean internal, String icon, File directory, ObjectMap<String> build, ObjectMap<String> options) {
+        return new ServerTemplate(name, enabled, internal, icon, directory, build, options, false);
     }
 
     /**
      * Reload SubCreator
      */
     public abstract void reload();
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof SubCreator && getHost().getSignature().equals(((SubCreator) obj).getHost().getSignature());
+    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/SubServer.java

@@ -3,6 +3,7 @@ package net.ME1312.SubServers.Bungee.Host;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Util;
 
+import java.io.File;
 import java.util.*;
 
 /**
@@ -40,7 +41,7 @@ public interface SubServer extends Server {
          * @param command Command
          */
         public LoggedCommand(String command) {
-            if (Util.isNull(command)) throw new NullPointerException();
+            Util.nullpo(command);
             this.date = Calendar.getInstance().getTime();
             this.sender = null;
             this.command = command;
@@ -53,7 +54,7 @@ public interface SubServer extends Server {
          * @param command Command
          */
         public LoggedCommand(UUID sender, String command) {
-            if (Util.isNull(command)) throw new NullPointerException();
+            Util.nullpo(command);
             this.date = Calendar.getInstance().getTime();
             this.sender = sender;
             this.command = command;
@@ -67,7 +68,7 @@ public interface SubServer extends Server {
          * @param command Command
          */
         public LoggedCommand(Date date, UUID sender, String command) {
-            if (Util.isNull(date, command)) throw new NullPointerException();
+            Util.nullpo(date, command);
             this.date = date;
             this.sender = sender;
             this.command = command;
@@ -114,7 +115,9 @@ public interface SubServer extends Server {
      *
      * @return Success Status
      */
-    boolean start();
+    default boolean start() {
+        return start(null);
+    }
 
     /**
      * Stops the Server
@@ -129,7 +132,9 @@ public interface SubServer extends Server {
      *
      * @return Success Status
      */
-    boolean stop();
+    default boolean stop() {
+        return stop(null);
+    }
 
     /**
      * Terminates the Server
@@ -144,24 +149,9 @@ public interface SubServer extends Server {
      *
      * @return Success Status
      */
-    boolean terminate();
-
-    /**
-     * Commands the Server
-     *
-     * @param player Player who Commanded
-     * @param command Command to Send
-     * @return Success Status
-     */
-    boolean command(UUID player, String command);
-
-    /**
-     * Commands the Server
-     *
-     * @param command Command to Send
-     * @return Success Status
-     */
-    boolean command(String command);
+    default boolean terminate() {
+        return terminate(null);
+    }
 
     /**
      * Edits the Server
@@ -227,6 +217,14 @@ public interface SubServer extends Server {
      */
     boolean isOnline();
 
+    /**
+     * If the Server is Stopping<br>
+     * <b>This method can only be true when the server is stopped through the server manager!</b>
+     *
+     * @return Stopping Status
+     */
+    boolean isStopping();
+
     /**
      * Grabs the Host of the Server
      *
@@ -325,7 +323,9 @@ public interface SubServer extends Server {
      *
      * @return Full Server Directory Path
      */
-    String getFullPath();
+    default String getFullPath()  {
+        return new File(getHost().getPath(), getPath()).getPath();
+    }
 
     /**
      * Get the Server's Executable String

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/SubServerController.java

@@ -231,7 +231,7 @@ public abstract class SubServerController {
     /**
      * Commands the Server
      *
-     * @param player Player who Commanded
+     * @param player Player who's Commanding
      * @param command Command to Send
      * @return Success Status
      */

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Host/SubServerImpl.java

@@ -12,15 +12,17 @@ import java.net.SocketAddress;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
+import java.util.regex.Pattern;
 
 /**
  * SubServer Layout Class
  */
 public abstract class SubServerImpl extends ServerImpl implements SubServer {
+    protected static final Pattern DISALLOWED_COMMANDS = Pattern.compile("^/?(?:[^\\s]+:)?sub(?:servers?)?(?:\\s|$)", Pattern.CASE_INSENSITIVE & Pattern.UNICODE_CASE);
     private List<Pair<String, String>> incompatibilities = new ArrayList<Pair<String, String>>();
     private SubCreator.ServerTemplate templateV = null;
     private String templateS = null;
-    protected boolean registered, started, updating;
+    protected boolean registered, started, stopping, updating;
 
     /**
      * Creates a SubServer
@@ -56,26 +58,6 @@ public abstract class SubServerImpl extends ServerImpl implements SubServer {
         super(name, new InetSocketAddress(host.getAddress().getHostAddress(), port), motd, hidden, restricted);
     }
 
-    @Override
-    public boolean start() {
-        return start(null);
-    }
-
-    @Override
-    public boolean stop() {
-        return stop(null);
-    }
-
-    @Override
-    public boolean terminate() {
-        return terminate(null);
-    }
-
-    @Override
-    public boolean command(String command) {
-        return command(null, command);
-    }
-
     public int edit(UUID player, ObjectMap<String> edit) {
         return edit(player, edit, false);
     }
@@ -96,6 +78,11 @@ public abstract class SubServerImpl extends ServerImpl implements SubServer {
         return -1;
     }
 
+    @Override
+    protected final boolean isRegistered() {
+        return registered;
+    }
+
     @Override
     public boolean isAvailable() {
         return registered && !updating && getHost().isAvailable();
@@ -106,6 +93,11 @@ public abstract class SubServerImpl extends ServerImpl implements SubServer {
         return isRunning() && started;
     }
 
+    @Override
+    public boolean isStopping() {
+        return isRunning() && stopping;
+    }
+
     @Override
     public void setTemplate(String template) {
         this.templateV = null;
@@ -122,18 +114,13 @@ public abstract class SubServerImpl extends ServerImpl implements SubServer {
     public SubCreator.ServerTemplate getTemplate() {
         if (templateV != null) {
             return templateV;
-        } else if (templateS != null && getHost().getCreator().getTemplates().keySet().contains(templateS.toLowerCase())) {
+        } else if (templateS != null && getHost().getCreator().getTemplates().containsKey(templateS.toLowerCase())) {
             return getHost().getCreator().getTemplate(templateS.toLowerCase());
         } else {
             return null;
         }
     }
 
-    @Override
-    public String getFullPath() {
-        return new File(getHost().getPath(), getPath()).getPath();
-    }
-
     @Override
     public void toggleCompatibility(SubServer... server) {
         for (SubServer s : server) {
@@ -181,7 +168,12 @@ public abstract class SubServerImpl extends ServerImpl implements SubServer {
         return servers;
     }
 
-    @SuppressWarnings({"deprecation", "unchecked"})
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof SubServerImpl && super.equals(obj);
+    }
+
+    @SuppressWarnings("deprecation")
     @Override
     public ObjectMap<String> forSubData() {
         ObjectMap<String> sinfo = super.forSubData();
@@ -196,6 +188,7 @@ public abstract class SubServerImpl extends ServerImpl implements SubServer {
         sinfo.set("exec", getExecutable());
         sinfo.set("running", isRunning());
         sinfo.set("online", isOnline());
+        sinfo.set("stopping", isStopping());
         sinfo.set("stop-cmd", getStopCommand());
         sinfo.set("stop-action", getStopAction().toString());
         sinfo.set("auto-run", SubAPI.getInstance().getInternals().servers.get().getMap("Servers").getMap(getName(), new ObjectMap<String>()).getBoolean("Run-On-Launch", false));

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Launch.java

@@ -1,13 +1,12 @@
 package net.ME1312.SubServers.Bungee;
 
 import net.ME1312.Galaxi.Library.Platform;
-import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.Galaxi.Library.Try;
 
 import java.security.Security;
 import java.text.SimpleDateFormat;
 import java.util.Calendar;
 import java.util.Date;
-import java.util.logging.Logger;
 
 /**
  * SubServers/BungeeCord Launch Class
@@ -23,9 +22,10 @@ public final class Launch {
     @SuppressWarnings({"deprecation", "unchecked"})
     public static void main(String[] args) throws Exception {
         System.setProperty("jdk.lang.Process.allowAmbiguousCommands", "true");
+        System.setProperty("jdk.util.jar.enableMultiRelease", "force");
         System.setProperty("apple.laf.useScreenMenuBar", "true");
 
-        if (Util.getDespiteException(() -> Class.forName("net.md_5.bungee.BungeeCord") == null, true)) {
+        if (Try.all.get(() -> Class.forName("net.md_5.bungee.BungeeCord") == null, true)) {
             System.out.println("");
             System.out.println("*******************************************");
             System.out.println("*** Error: BungeeCord.jar Doesn't Exist ***");
@@ -65,7 +65,7 @@ public final class Launch {
                     if (net.md_5.bungee.BungeeCord.class.getPackage().getSpecificationVersion() != null) {
                         Date date = (new SimpleDateFormat("yyyyMMdd")).parse(net.md_5.bungee.BungeeCord.class.getPackage().getSpecificationVersion());
                         Calendar line = Calendar.getInstance();
-                        line.add(3, -4);
+                        line.add(Calendar.WEEK_OF_YEAR, -8);
                         if (date.before(line.getTime())) {
                             System.out.println("***   Warning: BungeeCord is outdated   ***");
                             System.out.println("***  Please download a new build from:  ***");
@@ -82,38 +82,38 @@ public final class Launch {
                     System.out.println("*******************************************");
                 }
                 System.out.println("");
-            }
 
-            SubProxy plugin = new SubProxy(System.out, patched);
-            net.md_5.bungee.api.ProxyServer.class.getMethod("setInstance", net.md_5.bungee.api.ProxyServer.class).invoke(null, plugin);
-            plugin.getLogger().info("Enabled " + plugin.getBungeeName() + " version " + plugin.getVersion());
-            plugin.start();
+                SubProxy plugin = new SubProxy(System.out, patched);
+                net.md_5.bungee.api.ProxyServer.class.getMethod("setInstance", net.md_5.bungee.api.ProxyServer.class).invoke(null, plugin);
+                plugin.getLogger().info("Enabled " + plugin.getBungeeName() + " version " + plugin.getVersion());
+                plugin.start();
 
-            if (!options.has("noconsole")) {
-                try {
-                    if (Util.getDespiteException(() -> Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole").getMethod("readCommands") != null, false)) { // Waterfall Setup
-                        Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole").getMethod("readCommands").invoke(null);
-                    } else if (Util.getDespiteException(() -> Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole").getMethod("start") != null, false)) {
-                        Class console = Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole");
-                        console.getMethod("start").invoke(console.getConstructor().newInstance());
-                    } else {
-                        plugin.canSudo = true;
-                        String line;
-                        while (plugin.isRunning && (line = plugin.getConsoleReader().readLine(">")) != null) {
-                            if (plugin.sudo == null) {
-                                if (!plugin.getPluginManager().dispatchCommand(net.md_5.bungee.command.ConsoleCommandSender.class.cast(net.md_5.bungee.command.ConsoleCommandSender.class.getMethod("getInstance").invoke(null)), line)) {
-                                    plugin.getConsole().sendMessage(net.md_5.bungee.api.ChatColor.RED + "Command not found");
+                if (!options.has("noconsole")) {
+                    try {
+                        if (Try.all.get(() -> Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole").getMethod("readCommands") != null, false)) { // Waterfall Setup
+                            Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole").getMethod("readCommands").invoke(null);
+                        } else if (Try.all.get(() -> Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole").getMethod("start") != null, false)) {
+                            Class console = Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole");
+                            console.getMethod("start").invoke(console.getConstructor().newInstance());
+                        } else {
+                            plugin.canSudo = true;
+                            String line;
+                            while (plugin.isRunning && (line = plugin.getConsoleReader().readLine(">")) != null) {
+                                if (plugin.sudo == null) {
+                                    if (!plugin.getPluginManager().dispatchCommand(net.md_5.bungee.command.ConsoleCommandSender.class.cast(net.md_5.bungee.command.ConsoleCommandSender.class.getMethod("getInstance").invoke(null)), line)) {
+                                        plugin.getConsole().sendMessage(net.md_5.bungee.api.ChatColor.RED + "Command not found");
+                                    }
+                                } else if (line.equalsIgnoreCase("exit")) {
+                                    plugin.sudo = null;
+                                    net.ME1312.SubServers.Bungee.Library.Compatibility.Logger.get("SubServers").info("Reverting to the BungeeCord Console");
+                                } else {
+                                    plugin.sudo.command(line);
                                 }
-                            } else if (line.equalsIgnoreCase("exit")) {
-                                plugin.sudo = null;
-                                net.ME1312.SubServers.Bungee.Library.Compatibility.Logger.get("SubServers").info("Reverting to the BungeeCord Console");
-                            } else {
-                                plugin.sudo.command(line);
                             }
                         }
+                    } catch (NoSuchMethodError | NoSuchMethodException e) {
+                        plugin.getLogger().warning("Standard BungeeCord console not found; Console commands may now be disabled.");
                     }
-                } catch (NoSuchMethodError | NoSuchMethodException e) {
-                    plugin.getLogger().warning("Standard BungeeCord console not found; Console commands may now be disabled.");
                 }
             }
         }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/Compatibility/JNA.java

@@ -1,14 +1,19 @@
 package net.ME1312.SubServers.Bungee.Library.Compatibility;
 
-import net.ME1312.Galaxi.Library.UniversalFile;
+
 import net.ME1312.SubServers.Bungee.SubAPI;
 
 import com.google.common.io.Resources;
+import net.md_5.bungee.api.ProxyServer;
 
+import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.logging.Logger;
+
+import static java.util.logging.Level.SEVERE;
 
 /**
  * JNA Library Loader Class
@@ -28,12 +33,13 @@ public class JNA {
     public static ClassLoader get() {
         if (JNA == null) {
             boolean announced = false;
-            UniversalFile library = new UniversalFile(SubAPI.getInstance().getInternals().dir, "SubServers:Cache:Libraries");
-            UniversalFile jna = new UniversalFile(library, "jna-" + JNA_VERSION + ".jar");
+            Logger log = ProxyServer.getInstance().getLogger();
+            File library = new File(SubAPI.getInstance().getInternals().dir, "SubServers/Cache/Libraries");
+            File jna = new File(library, "jna-" + JNA_VERSION + ".jar");
             jna.getParentFile().mkdirs();
             if (!jna.exists()) {
                 announced = true;
-                System.out.println(">> Downloading JNA Library v" + JNA_VERSION);
+                log.info(">> Downloading JNA v" + JNA_VERSION);
                 try (FileOutputStream fin = new FileOutputStream(jna)) {
                     Resources.copy(new URL(JNA_DOWNLOAD.replace("$1", "jna")), fin);
                 } catch (Throwable e) {
@@ -41,10 +47,10 @@ public class JNA {
                     e.printStackTrace();
                 }
             }
-            UniversalFile platform = new UniversalFile(library, "jna-platform-" + JNA_VERSION + ".jar");
+            File platform = new File(library, "jna-platform-" + JNA_VERSION + ".jar");
             platform.getParentFile().mkdirs();
             if (!platform.exists()) {
-                if (!announced) System.out.println(">> Downloading JNA Library v" + JNA_VERSION);
+                if (!announced) log.info(">> Downloading JNA platform v" + JNA_VERSION);
                 announced = true;
                 try (FileOutputStream fin = new FileOutputStream(platform)) {
                     Resources.copy(new URL(JNA_DOWNLOAD.replace("$1", "jna-platform")), fin);
@@ -54,16 +60,14 @@ public class JNA {
                 }
             }
             if (jna.exists() && platform.exists()) {
-                if (announced) System.out.println(">> Loading JNA Library");
+                if (announced) log.info(">> JNA download complete");
                 try {
                     JNA = new URLClassLoader(new URL[]{jna.toURI().toURL(), platform.toURI().toURL()});
                 } catch (Throwable e) {
-                    System.out.println(">> Could not load JNA Library:");
-                    e.printStackTrace();
+                    log.log(SEVERE, ">> Couldn't load JNA:", e);
                 }
             } else {
-                System.out.println(">> Could not load JNA Library:");
-                new FileNotFoundException().printStackTrace();
+                log.log(SEVERE, ">> Couldn't load JNA:", new FileNotFoundException());
             }
         }
         return JNA;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/Compatibility/LegacyServerMap.java

@@ -5,10 +5,8 @@ import net.ME1312.SubServers.Bungee.SubAPI;
 import net.md_5.bungee.api.config.ServerInfo;
 import net.md_5.bungee.util.CaseInsensitiveMap;
 
-import java.util.Collection;
 import java.util.Map;
 import java.util.Map.Entry;
-import java.util.Set;
 
 /**
  * Legacy Server Map Translation Class

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/ConfigUpdater.java

@@ -113,7 +113,7 @@ public class ConfigUpdater {
             } if (was.compareTo(new Version("20w08d")) <= 0) {
                 if (existing.contains("Hosts")) {
                     for (String name : existing.getMap("Hosts", new YAMLSection()).getKeys()) {
-                        if (existing.getMap("Hosts").getMap(name).getRawString("Driver", "BUILT_IN").replace('-', '_').replace(' ', '_').equalsIgnoreCase("BUILT_IN"))
+                        if (existing.getMap("Hosts").getMap(name).getString("Driver", "BUILT_IN").replace('-', '_').replace(' ', '_').equalsIgnoreCase("BUILT_IN"))
                             updated.getMap("Hosts").getMap(name).set("Driver", "VIRTUAL");
                     }
                 }
@@ -138,6 +138,11 @@ public class ConfigUpdater {
 
                 existing = updated.clone();
                 i++;
+            } else if (was.compareTo(new Version("21w27b")) <= 0) {
+
+              //existing = updated.clone();
+                i++;
+
             }// if (was.compareTo(new Version("99w99a")) <= 0) {
             //  // do something
             //  existing = updated.clone();
@@ -150,8 +155,9 @@ public class ConfigUpdater {
         if (i > 0) {
             YAMLSection settings = new YAMLSection();
             settings.set("Version", ((now.compareTo(was) <= 0)?was:now).toString());
-            if (updated.getMap("Settings", new YAMLSection()).contains("RPEC-Check-Interval")) settings.set("RPEC-Check-Interval", updated.getMap("Settings").getRawString("RPEC-Check-Interval"));
-            settings.set("Disabled-Overrides", updated.getMap("Settings", new YAMLSection()).getRawStringList("Disabled-Overrides", Collections.emptyList()));
+            if (updated.getMap("Settings", new YAMLSection()).contains("RPEC-Check-Interval")) settings.set("RPEC-Check-Interval", updated.getMap("Settings").getString("RPEC-Check-Interval"));
+            settings.set("Strict-Server-Linking", updated.getMap("Settings", new YAMLSection()).getBoolean("Strict-Server-Linking", true));
+            settings.set("Disabled-Overrides", updated.getMap("Settings", new YAMLSection()).getStringList("Disabled-Overrides", Collections.emptyList()));
 
             YAMLSection smart_fallback = new YAMLSection();
             smart_fallback.set("Enabled", updated.getMap("Settings", new YAMLSection()).getMap("Smart-Fallback", new YAMLSection()).getBoolean("Enabled", true));
@@ -167,10 +173,10 @@ public class ConfigUpdater {
             settings.set("UPnP", upnp);
 
             YAMLSection subdata = new YAMLSection();
-            subdata.set("Address", updated.getMap("Settings", new YAMLSection()).getMap("SubData", new YAMLSection()).getRawString("Address", "127.0.0.1:4391"));
-            if (updated.getMap("Settings", new YAMLSection()).getMap("SubData", new YAMLSection()).contains("Password")) subdata.set("Password", updated.getMap("Settings").getMap("SubData").getRawString("Password"));
-            subdata.set("Encryption", updated.getMap("Settings", new YAMLSection()).getMap("SubData", new YAMLSection()).getRawString("Encryption", "RSA/AES"));
-            subdata.set("Whitelist", updated.getMap("Settings", new YAMLSection()).getMap("SubData", new YAMLSection()).getRawStringList("Whitelist", Collections.emptyList()));
+            subdata.set("Address", updated.getMap("Settings", new YAMLSection()).getMap("SubData", new YAMLSection()).getString("Address", "127.0.0.1:4391"));
+            if (updated.getMap("Settings", new YAMLSection()).getMap("SubData", new YAMLSection()).contains("Password")) subdata.set("Password", updated.getMap("Settings").getMap("SubData").getString("Password"));
+            subdata.set("Encryption", updated.getMap("Settings", new YAMLSection()).getMap("SubData", new YAMLSection()).getString("Encryption", "RSA/AES"));
+            subdata.set("Whitelist", updated.getMap("Settings", new YAMLSection()).getMap("SubData", new YAMLSection()).getStringList("Whitelist", Collections.emptyList()));
             settings.set("SubData", subdata);
 
             rewritten.set("Settings", settings);
@@ -180,12 +186,12 @@ public class ConfigUpdater {
             for (String name : updated.getMap("Hosts", new YAMLSection()).getKeys()) {
                 YAMLSection host = new YAMLSection();
                 host.set("Enabled", updated.getMap("Hosts").getMap(name).getBoolean("Enabled", false));
-                host.set("Display", updated.getMap("Hosts").getMap(name).getRawString("Display", ""));
-                host.set("Driver", updated.getMap("Hosts").getMap(name).getRawString("Driver", "VIRTUAL"));
-                host.set("Address", updated.getMap("Hosts").getMap(name).getRawString("Address", "127.0.0.1"));
-                host.set("Port-Range", updated.getMap("Hosts").getMap(name).getRawString("Port-Range", "25500-25559"));
-                host.set("Directory", updated.getMap("Hosts").getMap(name).getRawString("Directory", (host.getRawString("Driver").equalsIgnoreCase("VIRTUAL"))?"./SubServers/Servers":"./Servers"));
-                host.set("Git-Bash", updated.getMap("Hosts").getMap(name).getRawString("Git-Bash", "%ProgramFiles%\\Git"));
+                host.set("Display", updated.getMap("Hosts").getMap(name).getString("Display", ""));
+                host.set("Driver", updated.getMap("Hosts").getMap(name).getString("Driver", "VIRTUAL"));
+                host.set("Address", updated.getMap("Hosts").getMap(name).getString("Address", "127.0.0.1"));
+                host.set("Port-Range", updated.getMap("Hosts").getMap(name).getString("Port-Range", "25500-25559"));
+                host.set("Directory", updated.getMap("Hosts").getMap(name).getString("Directory", (host.getString("Driver").equalsIgnoreCase("VIRTUAL"))?"./SubServers/Servers":"./Servers"));
+                host.set("Git-Bash", updated.getMap("Hosts").getMap(name).getString("Git-Bash", "%ProgramFiles%\\Git"));
                 host.set("Log-Creator", updated.getMap("Hosts").getMap(name).getBoolean("Log-Creator", true));
                 if (updated.getMap("Hosts").getMap(name).contains("Extra")) host.set("Extra", updated.getMap("Hosts").getMap(name).getMap("Extra"));
                 hosts.set(name, host);
@@ -227,7 +233,7 @@ public class ConfigUpdater {
                         if (existing.getMap("Servers").getMap(name).getBoolean("Auto-Restart", true))
                             updated.getMap("Servers").getMap(name).safeSet("Stop-Action", "RESTART");
 
-                        if (existing.getMap("Servers").getMap(name).getRawString("Stop-Action", "NONE").equalsIgnoreCase("DELETE_SERVER"))
+                        if (existing.getMap("Servers").getMap(name).getString("Stop-Action", "NONE").equalsIgnoreCase("DELETE_SERVER"))
                             updated.getMap("Servers").getMap(name).set("Stop-Action", "RECYCLE_SERVER");
                     }
                 }
@@ -254,20 +260,20 @@ public class ConfigUpdater {
             for (String name : updated.getMap("Servers", new YAMLSection()).getKeys()) {
                 YAMLSection server = new YAMLSection();
                 server.set("Enabled", updated.getMap("Servers").getMap(name).getBoolean("Enabled", false));
-                server.set("Display", updated.getMap("Servers").getMap(name).getRawString("Display", ""));
-                server.set("Host", updated.getMap("Servers").getMap(name).getRawString("Host", "~"));
-                if (updated.getMap("Servers").getMap(name).contains("Template")) server.set("Template", updated.getMap("Servers").getMap(name).getRawString("Template"));
-                server.set("Group", updated.getMap("Servers").getMap(name).getRawStringList("Groups", Collections.emptyList()));
+                server.set("Display", updated.getMap("Servers").getMap(name).getString("Display", ""));
+                server.set("Host", updated.getMap("Servers").getMap(name).getString("Host", "~"));
+                if (updated.getMap("Servers").getMap(name).contains("Template")) server.set("Template", updated.getMap("Servers").getMap(name).getString("Template"));
+                server.set("Group", updated.getMap("Servers").getMap(name).getStringList("Groups", Collections.emptyList()));
                 server.set("Port", updated.getMap("Servers").getMap(name).getInt("Port", 25567));
-                server.set("Motd", updated.getMap("Servers").getMap(name).getRawString("Motd", "Some SubServer"));
+                server.set("Motd", updated.getMap("Servers").getMap(name).getString("Motd", "Some SubServer"));
                 server.set("Log", updated.getMap("Servers").getMap(name).getBoolean("Log", true));
-                server.set("Directory", updated.getMap("Servers").getMap(name).getRawString("Directory", "." + File.separatorChar));
-                server.set("Executable", updated.getMap("Servers").getMap(name).getRawString("Executable", "java -Xmx1024M -Djline.terminal=jline.UnsupportedTerminal -jar Spigot.jar"));
-                server.set("Stop-Command", updated.getMap("Servers").getMap(name).getRawString("Stop-Command", "stop"));
-                server.set("Stop-Action", updated.getMap("Servers").getMap(name).getRawString("Stop-Action", "NONE"));
+                server.set("Directory", updated.getMap("Servers").getMap(name).getString("Directory", "." + File.separatorChar));
+                server.set("Executable", updated.getMap("Servers").getMap(name).getString("Executable", "java -Xmx1024M -Djline.terminal=jline.UnsupportedTerminal -jar Spigot.jar"));
+                server.set("Stop-Command", updated.getMap("Servers").getMap(name).getString("Stop-Command", "stop"));
+                server.set("Stop-Action", updated.getMap("Servers").getMap(name).getString("Stop-Action", "NONE"));
                 server.set("Run-On-Launch", updated.getMap("Servers").getMap(name).getBoolean("Run-On-Launch", false));
                 server.set("Restricted", updated.getMap("Servers").getMap(name).getBoolean("Restricted", false));
-                server.set("Incompatible", updated.getMap("Servers").getMap(name).getRawStringList("Incompatible", Collections.emptyList()));
+                server.set("Incompatible", updated.getMap("Servers").getMap(name).getStringList("Incompatible", Collections.emptyList()));
                 server.set("Hidden", updated.getMap("Servers").getMap(name).getBoolean("Hidden", false));
                 if (updated.getMap("Servers").getMap(name).contains("Extra")) server.set("Extra", updated.getMap("Servers").getMap(name).getMap("Extra"));
                 servers.set(name, server);
@@ -303,7 +309,7 @@ public class ConfigUpdater {
             if (was.compareTo(new Version("19w22b")) <= 0) {
                 if (existing.contains("Lang")) {
                     updated.getMap("Lang").remove("Interface.Host-Admin.SubServers");
-                    updated.getMap("Lang").remove("Interface.SubServer-Admin.Command");
+                    updated.getMap("Lang").remove("Interface.Server-Admin.Command");
                 }
 
                 existing = updated.clone();
@@ -318,9 +324,12 @@ public class ConfigUpdater {
 
                 existing = updated.clone();
                 i++;
-            } if (was.compareTo(new Version("21w24h")) <= 0) {
+            } if (was.compareTo(new Version("22w07c")) <= 0) {
+                if (existing.contains("Lang")) {
+                    updated.getMap("Lang").remove("Command.Teleport");
+                }
 
-              //existing = updated.clone();
+                existing = updated.clone();
                 i++;
             }// if (was.compareTo(new Version("99w99a")) <= 0) {
             //  // do something
@@ -339,6 +348,7 @@ public class ConfigUpdater {
             LinkedHashMap<String, String> def = new LinkedHashMap<String, String>();
             def.put("Bungee.Feature.Smart-Fallback", "&6Returning from $str$: &r$msg$");
             def.put("Bungee.Feature.Smart-Fallback.Result", "&6You are now on $str$.");
+            def.put("Bungee.Restricted", "&cYou don't have permission to access this server.");
             def.put("Bungee.Ping.Offline", "&6&l[&e&lWarning&6&l] &7Backend server(s) are not running");
             def.put("Bungee.Server.Current", "&6You are currently connected to $str$");
             def.put("Bungee.Server.Available", "&6You may connect to the following servers at this time:");
@@ -351,6 +361,13 @@ public class ConfigUpdater {
             def.put("Bungee.List.List", "&f$str$");
             def.put("Bungee.List.Divider", "&f, ");
             def.put("Bungee.List.Total", "Total players online: $int$");
+            def.put("Signs.Create", "&aSubServers &2&l\\u00BB&a Server sign activated");
+            def.put("Signs.Delete", "&aSubServers &2&l\\u00BB&a Server sign removed");
+            def.put("Signs.Text.Unknown", "&f&oSubServers\\n&3$str$\\n&7Unknown Status\\n&8\\u2022 \\u2022 \\u2022 \\u2022 \\u2022 \\u2022 \\u2022");
+            def.put("Signs.Text.Offline", "&c&oSubServers\\n&3$str$\\n&4Offline\\n&7Click to Start");
+            def.put("Signs.Text.Starting", "&e&oSubServers\\n&3$str$\\n&6Starting\\n&8\\u2022 \\u2022 \\u2022 \\u2022 \\u2022 \\u2022 \\u2022");
+            def.put("Signs.Text.Online", "&a&oSubServers\\n&3$str$\\n&2$int$ Online\\n&7Click to Join");
+            def.put("Signs.Text.Stopping", "&e&oSubServers\\n&3$str$\\n&6Stopping\\n&8\\u2022 \\u2022 \\u2022 \\u2022 \\u2022 \\u2022 \\u2022");
             def.put("Command.Generic.Player-Only", "&cSubServers &4&l\\u00BB&c The console cannot perform this command");
             def.put("Command.Generic.Console-Only", "&cSubServers &4&l\\u00BB&c This command is for console use only");
             def.put("Command.Generic.Usage", "&7SubServers &8&l\\u00BB&7 Usage: &f$str$");
@@ -423,9 +440,10 @@ public class ConfigUpdater {
             def.put("Command.Terminate", "&aSubServers &2&l\\u00BB&a Terminated &2$int$&a subserver(s)");
             def.put("Command.Terminate.Disappeared", "&cSubServers &4&l\\u00BB&c Subserver &4$str$&c has disappeared");
             def.put("Command.Terminate.Not-Running", "&7SubServers &8&l\\u00BB&7 &f$int$&7 subserver(s) were already offline");
-            def.put("Command.Command", "&aSubServers &2&l\\u00BB&a Sent command to &2$int$&a subserver(s)");
+            def.put("Command.Command", "&aSubServers &2&l\\u00BB&a Sent command to &2$int$&a server(s)");
+            def.put("Command.Command.Disappeared", "&cSubServers &4&l\\u00BB&c Server &4$str$&c has disappeared");
             def.put("Command.Command.No-Command", "&cSubServers &4&l\\u00BB&c No command was entered");
-            def.put("Command.Command.Not-Running", "&7SubServers &8&l\\u00BB&7 &f$int$&7 subserver(s) were offline");
+            def.put("Command.Command.Not-Running", "&7SubServers &8&l\\u00BB&7 &f$int$&7 server(s) were unavailable");
             def.put("Command.Creator", "&aSubServers &2&l\\u00BB&a Creating subserver &2$str$&a");
             def.put("Command.Creator.Exists", "&cSubServers &4&l\\u00BB&c There is already a subserver with that name");
             def.put("Command.Creator.Unknown-Host", "&cSubServers &4&l\\u00BB&c There is no host with that name");
@@ -446,7 +464,11 @@ public class ConfigUpdater {
             def.put("Command.Update.Template-Disabled", "&cSubServers &4&l\\u00BB&c The template that created &4$str$&c is not enabled");
             def.put("Command.Update.Template-Invalid", "&cSubServers &4&l\\u00BB&c The template that created &4$str$&c does not support subserver updating");
             def.put("Command.Update.Version-Required", "&cSubServers &4&l\\u00BB&c The template that created &4$str$&c requires a Minecraft version to be specified");
-            def.put("Command.Teleport", "&aSubServers &2&l\\u00BB&a Teleporting &2$str$&a to server");
+            def.put("Command.Delete.Disappeared", "&cSubServers &4&l\\u00BB&c Subserver &4$str$&c has disappeared");
+            def.put("Command.Delete.Running", "&cSubServers &4&l\\u00BB&c Cannot delete &4$str$&c while it is still running");
+            def.put("Command.Delete", "&aSubServers &2&l\\u00BB&a Deleting &2$int$&a subserver(s)");
+            def.put("Command.Teleport", "&aSubServers &2&l\\u00BB&a Teleporting to &2$str$");
+            def.put("Command.Teleport.Others", "&aSubServers &2&l\\u00BB&a Teleporting &2$name$&a to &2$str$");
             def.put("Command.Teleport.Not-Running", "&cSubServers &4&l\\u00BB&c Subserver &4$str$&c is not running");
             def.put("Interface.Generic.Back", "&cBack");
             def.put("Interface.Generic.Back-Arrow", "&e&l<--");
@@ -510,28 +532,27 @@ public class ConfigUpdater {
             def.put("Interface.Server-Menu.SubServer-Incompatible", "&4Incompatible with $str$");
             def.put("Interface.Server-Menu.SubServer-Unavailable", "&4Unavailable");
             def.put("Interface.Server-Menu.SubServer-Disabled", "&4Disabled");
-            def.put("Interface.Server-Menu.SubServer-Invalid", "&4Cannot be managed by SubServers");
             def.put("Interface.Server-Menu.No-Servers", "&c&oThere are No Servers");
             def.put("Interface.Server-Menu.Host-Menu", "&b&lView Hosts");
-            def.put("Interface.SubServer-Admin.Title", "SubServer/$str$");
-            def.put("Interface.SubServer-Admin.Start", "&aStart SubServer");
-            def.put("Interface.SubServer-Admin.Start.Title", "&aStarting SubServer");
-            def.put("Interface.SubServer-Admin.Stop", "&cStop SubServer");
-            def.put("Interface.SubServer-Admin.Stop.Title", "&cStopping $str$");
-            def.put("Interface.SubServer-Admin.Terminate", "&4Terminate SubServer");
-            def.put("Interface.SubServer-Admin.Terminate.Title", "&cTerminating $str$");
-            def.put("Interface.SubServer-Admin.Command", "&bSend a Command to the SubServer");
-            def.put("Interface.SubServer-Admin.Command.Title", "&eSubServers\\n&6Enter a Command to send via Chat");
-            def.put("Interface.SubServer-Admin.Command.Message", "&eSubServers &6&l\\u00BB&e Enter a Command to send via Chat");
-            def.put("Interface.SubServer-Admin.Update", "&eUpdate SubServer");
-            def.put("Interface.SubServer-Admin.Update.Title", "&eSubServers\\n&6Enter a Server Version to update to");
-            def.put("Interface.SubServer-Admin.Update.Message", "&eSubServers &6&l\\u00BB&e Enter a Server Version to update to via Chat");
-            def.put("Interface.SubServer-Admin.Plugins", "&bPlugins...");
-            def.put("Interface.SubServer-Plugin.Title", "SubServer/$str$/Plugins");
+            def.put("Interface.Server-Admin.Title", "Server/$str$");
+            def.put("Interface.Server-Admin.Start", "&aStart SubServer");
+            def.put("Interface.Server-Admin.Start.Title", "&aStarting SubServer");
+            def.put("Interface.Server-Admin.Stop", "&cStop SubServer");
+            def.put("Interface.Server-Admin.Stop.Title", "&cStopping $str$");
+            def.put("Interface.Server-Admin.Terminate", "&4Terminate SubServer");
+            def.put("Interface.Server-Admin.Terminate.Title", "&cTerminating $str$");
+            def.put("Interface.Server-Admin.Command", "&bSend a Command to the Server");
+            def.put("Interface.Server-Admin.Command.Title", "&eSubServers\\n&6Enter a Command to send via Chat");
+            def.put("Interface.Server-Admin.Command.Message", "&eSubServers &6&l\\u00BB&e Enter a Command to send via Chat");
+            def.put("Interface.Server-Admin.Update", "&eUpdate SubServer");
+            def.put("Interface.Server-Admin.Update.Title", "&eSubServers\\n&6Enter a Server Version to update to");
+            def.put("Interface.Server-Admin.Update.Message", "&eSubServers &6&l\\u00BB&e Enter a Server Version to update to via Chat");
+            def.put("Interface.Server-Admin.Plugins", "&bPlugins...");
+            def.put("Interface.SubServer-Plugin.Title", "Server/$str$/Plugins");
             def.put("Interface.SubServer-Plugin.No-Plugins", "&c&oThere are No Plugins Available");
 
             YAMLSection lang = new YAMLSection();
-            for (String key : def.keySet()) lang.set(key, updated.getMap("Lang", new YAMLSection()).getRawString(key, def.get(key)));
+            for (String key : def.keySet()) lang.set(key, updated.getMap("Lang", new YAMLSection()).getString(key, def.get(key)));
             rewritten.set("Lang", lang);
 
             config.set(rewritten);

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/FileScanner.java

@@ -1,10 +1,13 @@
 package net.ME1312.SubServers.Bungee.Library;
 
-import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.Galaxi.Library.Directories;
 
-import java.io.*;
-import java.lang.reflect.InvocationTargetException;
-import java.util.*;
+import java.io.File;
+import java.io.IOException;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.PrimitiveIterator;
 import java.util.regex.Pattern;
 
 /**
@@ -19,12 +22,7 @@ public abstract class FileScanner {
      * @param whitelist File Whitelist
      */
     protected void scan(File dir, String... whitelist) throws IOException {
-        List<String> files;
-        try {
-            files = Util.reflect(Util.class.getDeclaredMethod("zipsearch", File.class, File.class), null, dir, dir);
-        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            throw new IllegalStateException("Cannot access zipsearch()", e);
-        }
+        List<String> files = Directories.search(dir);
         if (files.size() <= 0 || whitelist.length <= 0)
             return;
 
@@ -76,9 +74,6 @@ public abstract class FileScanner {
                         literal = new StringBuilder();
                     }
                     switch (c) {
-                        case '\\':
-                            if (i.hasNext()) c = i.next();
-                            literal.appendCodePoint(c);
                         case '[':
                             for (boolean escaped = false; i.hasNext() && (c != ']' || escaped); c = i.next()) {
                                 if (c == '\\') escaped = !escaped;
@@ -97,6 +92,8 @@ public abstract class FileScanner {
                         case '?':
                             rule.append("[^/]");
                             break;
+                        case '\\':
+                            if (i.hasNext()) c = i.next();
                         default:
                             literal.appendCodePoint(c);
                             break;

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/Metrics.java

@@ -1,450 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library;
-
-import net.ME1312.SubServers.Bungee.SubProxy;
-
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
-import net.md_5.bungee.config.Configuration;
-import net.md_5.bungee.config.ConfigurationProvider;
-import net.md_5.bungee.config.YamlConfiguration;
-
-import javax.net.ssl.HttpsURLConnection;
-import java.io.*;
-import java.lang.reflect.InvocationTargetException;
-import java.net.URL;
-import java.nio.file.Path;
-import java.util.*;
-import java.util.concurrent.Callable;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import java.util.zip.GZIPOutputStream;
-
-/**
- * bStats collects some data for plugin authors.
- *
- * Check out https://bStats.org/ to learn more about bStats!
- */
-public class Metrics {
-
-    static {
-        // You can use the property to disable the check in your test environment
-        if (System.getProperty("bstats.relocatecheck") == null || !System.getProperty("bstats.relocatecheck").equals("false")) {
-            // Maven's Relocate is clever and changes strings, too. So we have to use this little "trick" ... :D
-            final String defaultPackage = new String(
-                    new byte[]{'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's', '.', 'b', 'u', 'n', 'g', 'e', 'e', 'c', 'o', 'r', 'd'});
-            final String examplePackage = new String(new byte[]{'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
-            // We want to make sure nobody just copy & pastes the example and use the wrong package names
-            if (Metrics.class.getPackage().getName().equals(defaultPackage) || Metrics.class.getPackage().getName().equals(examplePackage)) {
-                throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
-            }
-        }
-    }
-
-    // The version of this bStats class
-    public static final int B_STATS_VERSION = 1;
-
-    // The url to which the data is sent
-    private static final String URL = "https://bStats.org/submitData/bungeecord";
-
-    // The plugin
-    private final SubProxy plugin;
-
-    // Is bStats enabled on this server?
-    private boolean enabled;
-
-    // The uuid of the server
-    private String serverUUID;
-
-    // Should failed requests be logged?
-    private boolean logFailedRequests = false;
-
-    // A list with all known metrics class objects including this one
-    private static final List<Object> knownMetricsInstances = new ArrayList<>();
-
-    public Metrics(SubProxy plugin) {
-        this.plugin = plugin;
-
-        try {
-            loadConfig();
-        } catch (IOException e) {
-            // Failed to load configuration
-            plugin.getLogger().log(Level.WARNING, "Failed to load bStats config!", e);
-            return;
-        }
-
-        // We are not allowed to send data about this server :(
-        if (!enabled) {
-            return;
-        }
-
-        Class<?> usedMetricsClass = getFirstBStatsClass();
-        if (usedMetricsClass == null) {
-            // Failed to get first metrics class
-            return;
-        }
-        if (usedMetricsClass == getClass()) {
-            // We are the first! :)
-            linkMetrics(this);
-            startSubmitting();
-        } else {
-            // We aren't the first so we link to the first metrics class
-            try {
-                usedMetricsClass.getMethod("linkMetrics", Object.class).invoke(null,this);
-            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
-                if (logFailedRequests) {
-                    plugin.getLogger().log(Level.WARNING, "Failed to link to first metrics class " + usedMetricsClass.getName() + "!", e);
-                }
-            }
-        }
-    }
-
-    /**
-     * Links an other metrics class with this class.
-     * This method is called using Reflection.
-     *
-     * @param metrics An object of the metrics class to link.
-     */
-    public static void linkMetrics(Object metrics) {
-        knownMetricsInstances.add(metrics);
-    }
-
-    /**
-     * Gets the plugin specific data.
-     * This method is called using Reflection.
-     *
-     * @return The plugin specific data.
-     */
-    public JsonObject getPluginData() {
-        JsonObject data = new JsonObject();
-
-        String pluginName = "SubServers 2";
-        String pluginVersion = plugin.version.toString();
-
-        data.addProperty("pluginName", pluginName);
-        data.addProperty("pluginVersion", pluginVersion);
-
-        JsonArray customCharts = new JsonArray();
-        customCharts.add(new SingleLineChart("managed_hosts", new Callable<Integer>() {
-            @Override
-            public Integer call() throws Exception {
-                return plugin.api.getHosts().size();
-            }
-        }).getRequestJsonObject(plugin.getLogger(), logFailedRequests));
-        customCharts.add(new SingleLineChart("subdata_connected", new Callable<Integer>() {
-            @Override
-            public Integer call() throws Exception {
-                return (plugin.subdata != null)?plugin.subdata.getClients().size():0;
-            }
-        }).getRequestJsonObject(plugin.getLogger(), logFailedRequests));
-        data.add("customCharts", customCharts);
-
-        return data;
-    }
-
-    private void startSubmitting() {
-        new Timer("SubServers.Bungee::Metrics_Uploader").schedule( new TimerTask() {
-            @Override
-            public void run() {
-                // The data collection is async, as well as sending the data
-                // Bungeecord does not have a main thread, everything is async
-                submitData();
-            }
-        }, TimeUnit.MINUTES.toMillis(2), TimeUnit.MINUTES.toMillis(30));
-        // Submit the data every 30 minutes, first time after 2 minutes to give other plugins enough time to start
-        // WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted!
-        // WARNING: Just don't do it!
-    }
-
-    /**
-     * Gets the server specific data.
-     *
-     * @return The server specific data.
-     */
-    private JsonObject getServerData() {
-        // Minecraft specific data
-        int playerAmount = plugin.getOnlineCount();
-        playerAmount = playerAmount > 500 ? 500 : playerAmount;
-        int onlineMode = plugin.getConfig().isOnlineMode() ? 1 : 0;
-        String bungeecordVersion = (plugin.getName().equals("SubServers Platform"))?"SubServers-Bungee-Patched":plugin.getVersion();
-        int managedServers = plugin.getServers().size();
-
-        // OS/Java specific data
-        String javaVersion = System.getProperty("java.version");
-        String osName = System.getProperty("os.name");
-        String osArch = System.getProperty("os.arch");
-        String osVersion = System.getProperty("os.version");
-        int coreCount = Runtime.getRuntime().availableProcessors();
-
-        JsonObject data = new JsonObject();
-
-        data.addProperty("serverUUID", serverUUID);
-
-        data.addProperty("playerAmount", playerAmount);
-        data.addProperty("managedServers", managedServers);
-        data.addProperty("onlineMode", onlineMode);
-        data.addProperty("bungeecordVersion", bungeecordVersion);
-
-        data.addProperty("javaVersion", javaVersion);
-        data.addProperty("osName", osName);
-        data.addProperty("osArch", osArch);
-        data.addProperty("osVersion", osVersion);
-        data.addProperty("coreCount", coreCount);
-
-        return data;
-    }
-
-    /**
-     * Collects the data and sends it afterwards.
-     */
-    private void submitData() {
-        final JsonObject data = getServerData();
-
-        final JsonArray pluginData = new JsonArray();
-        // Search for all other bStats Metrics classes to get their plugin data
-        for (Object metrics : knownMetricsInstances) {
-            try {
-                Object plugin = metrics.getClass().getMethod("getPluginData").invoke(metrics);
-                if (plugin instanceof JsonObject) {
-                    pluginData.add((JsonObject) plugin);
-                }
-            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) { }
-        }
-
-        data.add("plugins", pluginData);
-
-        try {
-            // Send the data
-            sendData(data);
-        } catch (Exception e) {
-            // Something went wrong! :(
-            if (logFailedRequests) {
-                plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats!", e);
-            }
-        }
-    }
-
-    /**
-     * Loads the bStats configuration.
-     *
-     * @throws IOException If something did not work :(
-     */
-    private void loadConfig() throws IOException {
-        Path configPath = new File(plugin.dir, "plugins").toPath().resolve("bStats");
-        configPath.toFile().mkdirs();
-        File configFile = new File(configPath.toFile(), "config.yml");
-        if (!configFile.exists()) {
-            writeFile(configFile,
-                    "#bStats collects some data for plugin authors like how many servers are using their plugins.",
-                    "#To honor their work, you should not disable it.",
-                    "#This has nearly no effect on the server performance!",
-                    "#Check out https://bStats.org/ to learn more :)",
-                    "enabled: true",
-                    "serverUuid: \"" + UUID.randomUUID().toString() + "\"",
-                    "logFailedRequests: false");
-        }
-
-        Configuration configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(configFile);
-
-        // Load configuration
-        enabled = configuration.getBoolean("enabled", true);
-        serverUUID = configuration.getString("serverUuid");
-        logFailedRequests = configuration.getBoolean("logFailedRequests", false);
-    }
-
-    /**
-     * Gets the first bStat Metrics class.
-     *
-     * @return The first bStats metrics class.
-     */
-    private Class<?> getFirstBStatsClass() {
-        Path configPath = new File(plugin.dir, "plugins").toPath().resolve("bStats");
-        configPath.toFile().mkdirs();
-        File tempFile = new File(configPath.toFile(), "temp.txt");
-
-        try {
-            String className = readFile(tempFile);
-            if (className != null) {
-                try {
-                    // Let's check if a class with the given name exists.
-                    return Class.forName(className);
-                } catch (ClassNotFoundException ignored) { }
-            }
-            writeFile(tempFile, getClass().getName());
-            return getClass();
-        } catch (IOException e) {
-            if (logFailedRequests) {
-                plugin.getLogger().log(Level.WARNING, "Failed to get first bStats class!", e);
-            }
-            return null;
-        }
-    }
-
-    /**
-     * Reads the first line of the file.
-     *
-     * @param file The file to read. Cannot be null.
-     * @return The first line of the file or <code>null</code> if the file does not exist or is empty.
-     * @throws IOException If something did not work :(
-     */
-    private String readFile(File file) throws IOException {
-        if (!file.exists()) {
-            return null;
-        }
-        try (
-                FileReader fileReader = new FileReader(file);
-                BufferedReader bufferedReader =  new BufferedReader(fileReader);
-        ) {
-            return bufferedReader.readLine();
-        }
-    }
-
-    /**
-     * Writes a String to a file. It also adds a note for the user,
-     *
-     * @param file The file to write to. Cannot be null.
-     * @param lines The lines to write.
-     * @throws IOException If something did not work :(
-     */
-    private void writeFile(File file, String... lines) throws IOException {
-        if (!file.exists()) {
-            file.createNewFile();
-        }
-        try (
-                FileWriter fileWriter = new FileWriter(file);
-                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter)
-        ) {
-            for (String line : lines) {
-                bufferedWriter.write(line);
-                bufferedWriter.newLine();
-            }
-        }
-    }
-
-    /**
-     * Sends the data to the bStats server.
-     *
-     * @param data The data to send.
-     * @throws Exception If the request failed.
-     */
-    private static void sendData(JsonObject data) throws Exception {
-        if (data == null) {
-            throw new IllegalArgumentException("Data cannot be null");
-        }
-
-        HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection();
-
-        // Compress the data to save bandwidth
-        byte[] compressedData = compress(data.toString());
-
-        // Add headers
-        connection.setRequestMethod("POST");
-        connection.addRequestProperty("Accept", "application/json");
-        connection.addRequestProperty("Connection", "close");
-        connection.addRequestProperty("Content-Encoding", "gzip"); // We gzip our request
-        connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
-        connection.setRequestProperty("Content-Type", "application/json"); // We send our data in JSON format
-        connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION);
-
-        // Send data
-        connection.setDoOutput(true);
-        DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream());
-        outputStream.write(compressedData);
-        outputStream.flush();
-        outputStream.close();
-
-        connection.getInputStream().close(); // We don't care about the response - Just send our data :)
-    }
-
-    /**
-     * Gzips the given String.
-     *
-     * @param str The string to gzip.
-     * @return The gzipped String.
-     * @throws IOException If the compression failed.
-     */
-    private static byte[] compress(final String str) throws IOException {
-        if (str == null) {
-            return null;
-        }
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-        GZIPOutputStream gzip = new GZIPOutputStream(outputStream);
-        gzip.write(str.getBytes("UTF-8"));
-        gzip.close();
-        return outputStream.toByteArray();
-    }
-    /**
-     * Represents a custom chart.
-     */
-    private static abstract class CustomChart {
-
-        // The id of the chart
-        private final String chartId;
-
-        /**
-         * Class constructor.
-         *
-         * @param chartId The id of the chart.
-         */
-        CustomChart(String chartId) {
-            if (chartId == null || chartId.isEmpty()) {
-                throw new IllegalArgumentException("ChartId cannot be null or empty!");
-            }
-            this.chartId = chartId;
-        }
-
-        JsonObject getRequestJsonObject(Logger logger, boolean logFailedRequests) {
-            JsonObject chart = new JsonObject();
-            chart.addProperty("chartId", chartId);
-            try {
-                JsonObject data = getChartData();
-                if (data == null) {
-                    // If the data is null we don't send the chart.
-                    return null;
-                }
-                chart.add("data", data);
-            } catch (Throwable t) {
-                if (logFailedRequests) {
-                    logger.log(Level.WARNING, "Failed to get data for custom chart with id " + chartId, t);
-                }
-                return null;
-            }
-            return chart;
-        }
-
-        protected abstract JsonObject getChartData() throws Exception;
-
-    }
-
-    /**
-     * Represents a custom single line chart.
-     */
-    private static class SingleLineChart extends CustomChart {
-
-        private final Callable<Integer> callable;
-
-        /**
-         * Class constructor.
-         *
-         * @param chartId The id of the chart.
-         * @param callable The callable which is used to request the chart data.
-         */
-        public SingleLineChart(String chartId, Callable<Integer> callable) {
-            super(chartId);
-            this.callable = callable;
-        }
-
-        @Override
-        protected JsonObject getChartData() throws Exception {
-            JsonObject data = new JsonObject();
-            int value = callable.call();
-            if (value == 0) {
-                // Null = skip the chart
-                return null;
-            }
-            data.addProperty("value", value);
-            return data;
-        }
-
-    }
-}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/ReplacementScanner.java

@@ -3,9 +3,7 @@ package net.ME1312.SubServers.Bungee.Library;
 import net.ME1312.Galaxi.Library.Util;
 
 import java.io.*;
-import java.lang.reflect.InvocationTargetException;
 import java.util.*;
-import java.util.regex.Pattern;
 
 /**
  * File Replacement Scanner
@@ -17,7 +15,7 @@ public class ReplacementScanner extends FileScanner {
         TreeMap<Integer, LinkedList<String>> order = new TreeMap<Integer, LinkedList<String>>(Comparator.reverseOrder());
         for (String key : replacements.keySet()) {
             int length = key.length();
-            if (!order.keySet().contains(length)) order.put(length, new LinkedList<>());
+            if (!order.containsKey(length)) order.put(length, new LinkedList<>());
             order.get(length).add(key);
         }
 

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketAddServer.java

@@ -28,8 +28,7 @@ public class PacketAddServer implements PacketObjectIn<Integer>, PacketObjectOut
      * @param plugin SubPlugin
      */
     public PacketAddServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -57,26 +56,26 @@ public class PacketAddServer implements PacketObjectIn<Integer>, PacketObjectOut
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         UUID tracker =     (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String name =                    data.getRawString(0x0001);
+            String name =                    data.getString(0x0001);
             boolean subserver =                data.getBoolean(0x0002);
             ObjectMap<String> opt = new ObjectMap<>((Map<String, ?>)data.getObject(0x0003));
             UUID player =                      (data.contains(0x0004)?data.getUUID(0x0004):null);
 
-            if (plugin.api.getServers().keySet().contains(name.toLowerCase())) {
+            if (plugin.api.getServers().containsKey(name.toLowerCase())) {
                 client.sendPacket(new PacketAddServer(3, tracker));
             } else {
                 if (!subserver) {
-                    if (plugin.api.addServer(player, name, InetAddress.getByName(opt.getRawString("address").split(":")[0]), Integer.parseInt(opt.getRawString("address").split(":")[1]),
-                            ChatColor.translateAlternateColorCodes('&', opt.getString("motd")), opt.getBoolean("hidden"), opt.getBoolean("restricted")) != null) {
+                    if (plugin.api.addServer(player, name, InetAddress.getByName(opt.getString("address").split(":")[0]), Integer.parseInt(opt.getString("address").split(":")[1]),
+                            ChatColor.translateAlternateColorCodes('&', Util.unescapeJavaString(opt.getString("motd"))), opt.getBoolean("hidden"), opt.getBoolean("restricted")) != null) {
                         client.sendPacket(new PacketAddServer(0, tracker));
                     } else {
                         client.sendPacket(new PacketAddServer(1, tracker));
                     }
-                } else if (!plugin.api.getHosts().keySet().contains(opt.getRawString("host").toLowerCase())) {
+                } else if (!plugin.api.getHosts().containsKey(opt.getString("host").toLowerCase())) {
                     client.sendPacket(new PacketAddServer(4, tracker));
                 } else {
-                    if (plugin.api.getHost(opt.getRawString("host")).addSubServer(player, name, opt.getBoolean("enabled"), opt.getInt("port"), ChatColor.translateAlternateColorCodes('&', opt.getString("motd")),
-                            opt.getBoolean("log"), opt.getRawString("dir"), opt.getRawString("exec"), opt.getRawString("stop-cmd"), opt.getBoolean("hidden"), opt.getBoolean("restricted")) != null) {
+                    if (plugin.api.getHost(opt.getString("host")).addSubServer(player, name, opt.getBoolean("enabled"), opt.getInt("port"), ChatColor.translateAlternateColorCodes('&', Util.unescapeJavaString(opt.getString("motd"))),
+                            opt.getBoolean("log"), opt.getString("dir"), opt.getString("exec"), opt.getString("stop-cmd"), opt.getBoolean("hidden"), opt.getBoolean("restricted")) != null) {
                         client.sendPacket(new PacketAddServer(0, tracker));
                     } else {
                         client.sendPacket(new PacketAddServer(1, tracker));
@@ -88,9 +87,4 @@ public class PacketAddServer implements PacketObjectIn<Integer>, PacketObjectOut
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketCheckPermission.java

@@ -1,6 +1,5 @@
 package net.ME1312.SubServers.Bungee.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.Server.Protocol.PacketObjectIn;
@@ -9,12 +8,13 @@ import net.ME1312.SubData.Server.SubDataClient;
 
 import java.util.HashMap;
 import java.util.UUID;
+import java.util.function.Consumer;
 
 /**
  * Check Permission Packet
  */
 public class PacketCheckPermission implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
-    static HashMap<UUID, Callback<Boolean>[]> callbacks = new HashMap<UUID, Callback<Boolean>[]>();
+    static HashMap<UUID, Consumer<Boolean>[]> callbacks = new HashMap<UUID, Consumer<Boolean>[]>();
     private UUID player;
     private String permission;
     private UUID tracker;
@@ -32,7 +32,7 @@ public class PacketCheckPermission implements PacketObjectIn<Integer>, PacketObj
      * @param callback Callbacks
      */
     @SafeVarargs
-    public PacketCheckPermission(UUID player, String permission, Callback<Boolean>... callback) {
+    public PacketCheckPermission(UUID player, String permission, Consumer<Boolean>... callback) {
         this.player = player;
         this.permission = permission;
         this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
@@ -50,11 +50,6 @@ public class PacketCheckPermission implements PacketObjectIn<Integer>, PacketObj
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) throws Throwable {
-        client.sendPacket(new PacketCheckPermissionResponse(data.getUUID(0x0001), data.getRawString(0x0002), (data.contains(0x0000))?data.getUUID(0x0000):null));
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
+        client.sendPacket(new PacketCheckPermissionResponse(data.getUUID(0x0001), data.getString(0x0002), (data.contains(0x0000))?data.getUUID(0x0000):null));
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketCheckPermissionResponse.java

@@ -1,8 +1,7 @@
 package net.ME1312.SubServers.Bungee.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.Try;
 import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
 import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
 import net.ME1312.SubData.Server.SubDataClient;
@@ -10,6 +9,7 @@ import net.ME1312.SubData.Server.SubDataClient;
 import net.md_5.bungee.api.ProxyServer;
 
 import java.util.UUID;
+import java.util.function.Consumer;
 
 import static net.ME1312.SubServers.Bungee.Network.Packet.PacketCheckPermission.callbacks;
 
@@ -34,7 +34,7 @@ public class PacketCheckPermissionResponse implements PacketObjectIn<Integer>, P
      * @param tracker Receiver ID
      */
     public PacketCheckPermissionResponse(UUID player, String permission, UUID tracker) {
-        this.result = Util.getDespiteException(() -> ProxyServer.getInstance().getPlayer(player).hasPermission(permission), false);
+        this.result = Try.all.get(() -> ProxyServer.getInstance().getPlayer(player).hasPermission(permission), false);
         this.tracker = tracker;
     }
 
@@ -48,12 +48,6 @@ public class PacketCheckPermissionResponse implements PacketObjectIn<Integer>, P
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) throws Throwable {
-        for (Callback<Boolean> callback : callbacks.get(data.getUUID(0x0000))) callback.run(data.getBoolean(0x0001));
-        callbacks.remove(data.getUUID(0x0000));
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
+        for (Consumer<Boolean> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data.getBoolean(0x0001));
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketCommandServer.java

@@ -26,8 +26,7 @@ public class PacketCommandServer implements PacketObjectIn<Integer>, PacketObjec
      * @param plugin SubPlugin
      */
     public PacketCommandServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -51,27 +50,28 @@ public class PacketCommandServer implements PacketObjectIn<Integer>, PacketObjec
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
-        UUID tracker =      (data.contains(0x0000)?data.getUUID(0x0000):null);
+        UUID tracker =       (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String server =  data.getRawString(0x0001);
-            String command = data.getRawString(0x0002);
-            UUID player =       (data.contains(0x0003)?data.getUUID(0x0003):null);
+            String server =  data.getString(0x0001);
+            String command = data.getString(0x0002);
+            UUID player =    (data.contains(0x0003)?data.getUUID(0x0003):null);
+            UUID target =    (data.contains(0x0004)?data.getUUID(0x0004):null);
 
             Map<String, Server> servers = plugin.api.getServers();
-            if (!server.equals("*") && !servers.keySet().contains(server.toLowerCase())) {
+            if (!server.equals("*") && !servers.containsKey(server.toLowerCase())) {
                 client.sendPacket(new PacketCommandServer(3, tracker));
-            } else if (!server.equals("*") && !(servers.get(server.toLowerCase()) instanceof SubServer)) {
+            } else if (!server.equals("*") && !(target == null && servers.get(server.toLowerCase()) instanceof SubServer) && servers.get(server.toLowerCase()).getSubData()[0] == null) {
                 client.sendPacket(new PacketCommandServer(4, tracker));
-            } else if (!server.equals("*") && !((SubServer) servers.get(server.toLowerCase())).isRunning()) {
+            } else if (!server.equals("*") && servers.get(server.toLowerCase()) instanceof SubServer && !((SubServer) servers.get(server.toLowerCase())).isRunning()) {
                 client.sendPacket(new PacketCommandServer(5, tracker));
             } else {
                 if (server.equals("*")) {
                     boolean sent = false;
                     for (Server next : servers.values()) {
-                        if (next instanceof SubServer && ((SubServer) next).isRunning()) {
-                            if (((SubServer) next).command(player, command)) {
-                                sent = true;
-                            }
+                        if (target == null) {
+                            sent |= next.command(player, command);
+                        } else {
+                            sent |= next.command(player, target, command);
                         }
                     }
                     if (sent) {
@@ -80,10 +80,10 @@ public class PacketCommandServer implements PacketObjectIn<Integer>, PacketObjec
                         client.sendPacket(new PacketCommandServer(1, tracker));
                     }
                 } else {
-                    if (((SubServer) servers.get(server.toLowerCase())).command(player, command)) {
-                        client.sendPacket(new PacketCommandServer(0, tracker));
+                    if (target == null) {
+                        client.sendPacket(new PacketCommandServer((servers.get(server.toLowerCase()).command(player, command))? 0 : 1, tracker));
                     } else {
-                        client.sendPacket(new PacketCommandServer(1, tracker));
+                        client.sendPacket(new PacketCommandServer((servers.get(server.toLowerCase()).command(player, target, command))? 0 : 1, tracker));
                     }
                 }
             }
@@ -92,9 +92,4 @@ public class PacketCommandServer implements PacketObjectIn<Integer>, PacketObjec
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketCreateServer.java

@@ -50,9 +50,9 @@ public class PacketCreateServer implements PacketObjectIn<Integer>, PacketObject
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         UUID tracker =       (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String name =     data.getRawString(0x0001);
-            String host =     data.getRawString(0x0002);
-            String template = data.getRawString(0x0003);
+            String name =     data.getString(0x0001);
+            String host =     data.getString(0x0002);
+            String template = data.getString(0x0003);
             Version version =       (data.contains(0x0004)?data.getVersion(0x0004):null);
             Integer port =       (data.contains(0x0005)?data.getInt(0x0005):null);
             UUID player =        (data.contains(0x0006)?data.getUUID(0x0006):null);
@@ -60,15 +60,15 @@ public class PacketCreateServer implements PacketObjectIn<Integer>, PacketObject
 
             if (name.contains(" ")) {
                 client.sendPacket(new PacketCreateServer(3, tracker));
-            } else if (plugin.api.getSubServers().keySet().contains(name.toLowerCase()) || SubCreator.isReserved(name)) {
+            } else if (plugin.api.getSubServers().containsKey(name.toLowerCase()) || SubCreator.isReserved(name)) {
                 client.sendPacket(new PacketCreateServer(4, tracker));
-            } else if (!plugin.hosts.keySet().contains(host.toLowerCase())) {
+            } else if (!plugin.hosts.containsKey(host.toLowerCase())) {
                 client.sendPacket(new PacketCreateServer(5, tracker));
             } else if (!plugin.hosts.get(host.toLowerCase()).isAvailable()) {
                 client.sendPacket(new PacketCreateServer(6, tracker));
             } else if (!plugin.hosts.get(host.toLowerCase()).isEnabled()) {
                 client.sendPacket(new PacketCreateServer(7, tracker));
-            } else if (!plugin.hosts.get(host.toLowerCase()).getCreator().getTemplates().keySet().contains(template.toLowerCase())) {
+            } else if (!plugin.hosts.get(host.toLowerCase()).getCreator().getTemplates().containsKey(template.toLowerCase())) {
                 client.sendPacket(new PacketCreateServer(8, tracker));
             } else if (!plugin.hosts.get(host.toLowerCase()).getCreator().getTemplate(template).isEnabled()) {
                 client.sendPacket(new PacketCreateServer(9, tracker));
@@ -91,9 +91,4 @@ public class PacketCreateServer implements PacketObjectIn<Integer>, PacketObject
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDeleteServer.java

@@ -26,8 +26,7 @@ public class PacketDeleteServer implements PacketObjectIn<Integer>, PacketObject
      * @param plugin SubPlugin
      */
     public PacketDeleteServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -53,13 +52,13 @@ public class PacketDeleteServer implements PacketObjectIn<Integer>, PacketObject
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         UUID tracker =         (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String name =   data.getRawString(0x0001);
+            String name =   data.getString(0x0001);
             boolean recycle = data.getBoolean(0x0002);
             boolean force =   data.getBoolean(0x0003);
             UUID player =      (data.contains(0x0004)?data.getUUID(0x0004):null);
 
             Map<String, Server> servers = plugin.api.getServers();
-            if (!servers.keySet().contains(name.toLowerCase())) {
+            if (!servers.containsKey(name.toLowerCase())) {
                 client.sendPacket(new PacketDeleteServer(3, tracker));
             } else if (!(servers.get(name.toLowerCase()) instanceof SubServer)) {
                 client.sendPacket(new PacketDeleteServer(4, tracker));
@@ -99,9 +98,4 @@ public class PacketDeleteServer implements PacketObjectIn<Integer>, PacketObject
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDisconnectPlayer.java

@@ -1,33 +1,33 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
+import net.ME1312.Galaxi.Library.Container.Container;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.Galaxi.Library.Merger;
 import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
 import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
 import net.ME1312.SubData.Server.SubDataClient;
+import net.ME1312.SubServers.Bungee.Host.Proxy;
 import net.ME1312.SubServers.Bungee.Host.RemotePlayer;
-import net.ME1312.SubServers.Bungee.SubProxy;
+import net.ME1312.SubServers.Bungee.SubAPI;
 
+import net.md_5.bungee.api.ProxyServer;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
-import java.util.UUID;
+import java.util.*;
+import java.util.function.IntConsumer;
 
 /**
  * Disconnect Player Packet
  */
 public class PacketDisconnectPlayer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
-    private SubProxy plugin;
     private int response;
     private UUID tracker;
 
     /**
      * New PacketDisconnectPlayer (In)
-     *
-     * @param plugin SubPlugin
      */
-    public PacketDisconnectPlayer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+    public PacketDisconnectPlayer() {
+
     }
 
     /**
@@ -51,38 +51,51 @@ public class PacketDisconnectPlayer implements PacketObjectIn<Integer>, PacketOb
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
-        UUID tracker =      (data.contains(0x0000)?data.getUUID(0x0000):null);
-        try {
-            UUID id =       data.getUUID(0x0001);
+        UUID tracker = (data.contains(0x0000)?data.getUUID(0x0000):null);
+        run(data.getUUIDList(0x0001), data.contains(0x0002)?data.getString(0x0002):null, i -> {
+            client.sendPacket(new PacketDisconnectPlayer(i, tracker));
+        });
+    }
 
-            ProxiedPlayer local;
-            RemotePlayer remote;
-            if ((local = plugin.getPlayer(id)) != null) {
-                if (data.contains(0x0002)) {
-                    local.disconnect(data.getRawString(0x0002));
+    @SuppressWarnings("deprecation")
+    public static void run(List<UUID> ids, String reason, IntConsumer callback) {
+        try {
+            Container<Integer> failures = new Container<>(0);
+            HashMap<Proxy, List<UUID>> requests = new HashMap<Proxy, List<UUID>>();
+            for (UUID id : ids) {
+                ProxiedPlayer local;
+                RemotePlayer remote;
+                if ((local = ProxyServer.getInstance().getPlayer(id)) != null) {
+                    if (reason != null) {
+                        local.disconnect(reason);
+                    } else local.disconnect();
+                } else if ((remote = SubAPI.getInstance().getRemotePlayer(id)) != null && remote.getProxy().getSubData()[0] != null) {
+                    Proxy proxy = remote.getProxy();
+                    List<UUID> list = requests.getOrDefault(proxy, new ArrayList<>());
+                    list.add(id);
+                    requests.put(proxy, list);
                 } else {
-                    local.disconnect();
-                }
-                client.sendPacket(new PacketDisconnectPlayer(0, tracker));
-            } else if ((remote = plugin.api.getRemotePlayer(id)) != null) {
-                if (remote.getProxy().getSubData()[0] != null) {
-                    ((SubDataClient) remote.getProxy().getSubData()[0]).sendPacket(new PacketExDisconnectPlayer(remote.getUniqueId(), (data.contains(0x0002)?data.getRawString(0x0002):null), r -> {
-                        client.sendPacket(new PacketDisconnectPlayer(r.getInt(0x0001), tracker));
-                    }));
-                } else {
-                    client.sendPacket(new PacketDisconnectPlayer(4, tracker));
+                    ++failures.value;
                 }
+            }
+
+            if (requests.size() == 0) {
+                callback.accept(failures.value);
             } else {
-                client.sendPacket(new PacketDisconnectPlayer(3, tracker));
+                Merger merge = new Merger(() -> {
+                    callback.accept(failures.value);
+                });
+                for (Map.Entry<Proxy, List<UUID>> entry : requests.entrySet()) {
+                    merge.reserve();
+                    ((SubDataClient) entry.getKey().getSubData()[0]).sendPacket(new PacketExDisconnectPlayer(entry.getValue(), reason, r -> {
+                        failures.value += r.getInt(0x0001);
+                        merge.release();
+                    }));
+                }
             }
         } catch (Throwable e) {
-            client.sendPacket(new PacketDisconnectPlayer(2, tracker));
             e.printStackTrace();
+            callback.accept(-1);
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDownloadGroupInfo.java

@@ -24,8 +24,7 @@ public class PacketDownloadGroupInfo implements PacketObjectIn<Integer>, PacketO
      * @param plugin SubPlugin
      */
     public PacketDownloadGroupInfo(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -36,8 +35,7 @@ public class PacketDownloadGroupInfo implements PacketObjectIn<Integer>, PacketO
      * @param tracker Receiver ID
      */
     public PacketDownloadGroupInfo(SubProxy plugin, List<String> groups, UUID tracker) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
         this.tracker = tracker;
 
         if (groups != null) {
@@ -78,11 +76,6 @@ public class PacketDownloadGroupInfo implements PacketObjectIn<Integer>, PacketO
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
-        client.sendPacket(new PacketDownloadGroupInfo(plugin, (data.contains(0x0001))?data.getRawStringList(0x0001):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
+        client.sendPacket(new PacketDownloadGroupInfo(plugin, (data.contains(0x0001))?data.getStringList(0x0001):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDownloadHostInfo.java

@@ -26,8 +26,7 @@ public class PacketDownloadHostInfo implements PacketObjectIn<Integer>, PacketOb
      * @param plugin SubPlugin
      */
     public PacketDownloadHostInfo(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -38,8 +37,7 @@ public class PacketDownloadHostInfo implements PacketObjectIn<Integer>, PacketOb
      * @param tracker Receiver ID
      */
     public PacketDownloadHostInfo(SubProxy plugin, List<String> hosts, UUID tracker) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
         this.tracker = tracker;
 
         if (hosts != null) {
@@ -66,11 +64,6 @@ public class PacketDownloadHostInfo implements PacketObjectIn<Integer>, PacketOb
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
-        client.sendPacket(new PacketDownloadHostInfo(plugin, (data.contains(0x0001))?data.getRawStringList(0x0001):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
+        client.sendPacket(new PacketDownloadHostInfo(plugin, (data.contains(0x0001))?data.getStringList(0x0001):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDownloadLang.java

@@ -52,9 +52,4 @@ public class PacketDownloadLang implements PacketObjectIn<Integer>, PacketObject
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         client.sendPacket(new PacketDownloadLang(plugin, (data != null && data.contains(0x0000))?data.getUUID(0x0000):null));
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDownloadPlatformInfo.java

@@ -101,9 +101,4 @@ public class PacketDownloadPlatformInfo implements PacketObjectIn<Integer>, Pack
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         client.sendPacket(new PacketDownloadPlatformInfo(plugin, (data != null && data.contains(0x0000))?data.getUUID(0x0000):null));
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDownloadPlayerInfo.java

@@ -26,8 +26,7 @@ public class PacketDownloadPlayerInfo implements PacketObjectIn<Integer>, Packet
      * @param plugin SubPlugin
      */
     public PacketDownloadPlayerInfo(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -39,8 +38,7 @@ public class PacketDownloadPlayerInfo implements PacketObjectIn<Integer>, Packet
      * @param tracker Receiver ID
      */
     public PacketDownloadPlayerInfo(SubProxy plugin, List<String> names, List<UUID> ids, UUID tracker) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
         this.tracker = tracker;
 
         if (ids != null) {
@@ -79,11 +77,6 @@ public class PacketDownloadPlayerInfo implements PacketObjectIn<Integer>, Packet
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
-        client.sendPacket(new PacketDownloadPlayerInfo(plugin, (data.contains(0x0001))?data.getRawStringList(0x0001):null, (data.contains(0x0002))?data.getUUIDList(0x0002):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
+        client.sendPacket(new PacketDownloadPlayerInfo(plugin, (data.contains(0x0001))?data.getStringList(0x0001):null, (data.contains(0x0002))?data.getUUIDList(0x0002):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDownloadProxyInfo.java

@@ -26,8 +26,7 @@ public class PacketDownloadProxyInfo implements PacketObjectIn<Integer>, PacketO
      * @param plugin SubPlugin
      */
     public PacketDownloadProxyInfo(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -38,8 +37,7 @@ public class PacketDownloadProxyInfo implements PacketObjectIn<Integer>, PacketO
      * @param tracker Receiver ID
      */
     public PacketDownloadProxyInfo(SubProxy plugin, List<String> proxies, UUID tracker) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
         this.tracker = tracker;
 
         if (proxies != null) {
@@ -69,11 +67,6 @@ public class PacketDownloadProxyInfo implements PacketObjectIn<Integer>, PacketO
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
-        client.sendPacket(new PacketDownloadProxyInfo(plugin, (data.contains(0x0001))?data.getRawStringList(0x0001):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
+        client.sendPacket(new PacketDownloadProxyInfo(plugin, (data.contains(0x0001))?data.getStringList(0x0001):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketDownloadServerInfo.java

@@ -26,8 +26,7 @@ public class PacketDownloadServerInfo implements PacketObjectIn<Integer>, Packet
      * @param plugin SubPlugin
      */
     public PacketDownloadServerInfo(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -38,8 +37,7 @@ public class PacketDownloadServerInfo implements PacketObjectIn<Integer>, Packet
      * @param tracker Receiver ID
      */
     public PacketDownloadServerInfo(SubProxy plugin, List<String> servers, UUID tracker) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
         this.tracker = tracker;
 
         if (servers != null) {
@@ -66,11 +64,6 @@ public class PacketDownloadServerInfo implements PacketObjectIn<Integer>, Packet
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
-        client.sendPacket(new PacketDownloadServerInfo(plugin, (data.contains(0x0001))?data.getRawStringList(0x0001):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
+        client.sendPacket(new PacketDownloadServerInfo(plugin, (data.contains(0x0001))?data.getStringList(0x0001):null, (data.contains(0x0000))?data.getUUID(0x0000):null));
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketEditServer.java

@@ -27,8 +27,7 @@ public class PacketEditServer implements PacketObjectIn<Integer>, PacketObjectOu
      * @param plugin SubPlugin
      */
     public PacketEditServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -68,13 +67,13 @@ public class PacketEditServer implements PacketObjectIn<Integer>, PacketObjectOu
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         UUID tracker =     (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String name =                    data.getRawString(0x0001);
+            String name =                    data.getString(0x0001);
             ObjectMap<String> edit = new ObjectMap<>((Map<String, ?>)data.getObject(0x0002));
             boolean perma =                    data.getBoolean(0x0003);
             UUID player =                       (data.contains(0x0004)?data.getUUID(0x0004):null);
 
             Map<String, Server> servers = plugin.api.getServers();
-            if (!servers.keySet().contains(name.toLowerCase())) {
+            if (!servers.containsKey(name.toLowerCase())) {
                 client.sendPacket(new PacketEditServer(3, tracker));
             } else if (!(servers.get(name.toLowerCase()) instanceof SubServer)) {
                 client.sendPacket(new PacketEditServer(4, tracker));
@@ -96,9 +95,4 @@ public class PacketEditServer implements PacketObjectIn<Integer>, PacketObjectOu
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExAddServer.java

@@ -1,6 +1,5 @@
 package net.ME1312.SubServers.Bungee.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.Server.Protocol.PacketObjectIn;
@@ -10,12 +9,13 @@ import net.ME1312.SubServers.Bungee.Host.External.ExternalSubServer;
 
 import java.util.HashMap;
 import java.util.UUID;
+import java.util.function.Consumer;
 
 /**
  * Add Server External Host Packet
  */
 public class PacketExAddServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
-    private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
+    private static HashMap<UUID, Consumer<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Consumer<ObjectMap<Integer>>[]>();
     private String name;
     private boolean enabled;
     private int port;
@@ -35,7 +35,7 @@ public class PacketExAddServer implements PacketObjectIn<Integer>, PacketObjectO
      * New PacketExAddServer (Out)
      */
     @SafeVarargs
-    public PacketExAddServer(ExternalSubServer server, UUID running, Callback<ObjectMap<Integer>>... callback) {
+    public PacketExAddServer(ExternalSubServer server, UUID running, Consumer<ObjectMap<Integer>>... callback) {
         if (callback == null) throw new NullPointerException();
         this.name = server.getName();
         this.enabled = server.isEnabled();
@@ -49,10 +49,14 @@ public class PacketExAddServer implements PacketObjectIn<Integer>, PacketObjectO
         callbacks.put(tracker, callback);
     }
 
+    public String peek() {
+        return name;
+    }
+
     @Override
     public ObjectMap<Integer> send(SubDataClient client) {
         ObjectMap<Integer> data = new ObjectMap<Integer>();
-        if (tracker != null) data.set(0x0000, tracker);
+        data.set(0x0000, tracker);
         data.set(0x0001, name);
         data.set(0x0002, enabled);
         data.set(0x0003, port);
@@ -60,18 +64,12 @@ public class PacketExAddServer implements PacketObjectIn<Integer>, PacketObjectO
         data.set(0x0005, directory);
         data.set(0x0006, executable);
         data.set(0x0007, stopcmd);
-        if (running != null) data.set(0x0008, running.toString());
+        if (running != null) data.set(0x0008, running);
         return data;
     }
 
     @Override
     public void receive(SubDataClient 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;
+        for (Consumer<ObjectMap<Integer>> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data);
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExConfigureHost.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
 import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
@@ -43,12 +44,7 @@ public class PacketExConfigureHost implements PacketObjectIn<Integer>, PacketObj
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         if (client.getHandler() != null && client.getHandler() instanceof ExternalHost && plugin.config.get().getMap("Hosts").getKeys().contains(((ExternalHost) client.getHandler()).getName())) {
             client.sendPacket(new PacketExConfigureHost(plugin, (ExternalHost) client.getHandler()));
-            Util.isException(() -> Util.reflect(ExternalSubCreator.class.getDeclaredField("enableRT"), ((ExternalHost) client.getHandler()).getCreator(), ((data == null || data.getBoolean(0x0000, false))?null:false)));
+            Try.all.run(() -> Util.reflect(ExternalSubCreator.class.getDeclaredField("enableRT"), ((ExternalHost) client.getHandler()).getCreator(), ((data == null || data.getBoolean(0x0000, false))?null:false)));
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExControlPlayer.java

@@ -0,0 +1,56 @@
+package net.ME1312.SubServers.Bungee.Network.Packet;
+
+import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
+import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
+import net.ME1312.SubData.Server.SubDataClient;
+
+import java.util.HashMap;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+/**
+ * External Player Control Packet
+ */
+public class PacketExControlPlayer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
+    private static HashMap<UUID, Consumer<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Consumer<ObjectMap<Integer>>[]>();
+    private String command;
+    private UUID target;
+    private UUID tracker;
+
+    /**
+     * New PacketExControlPlayer (In)
+     */
+    public PacketExControlPlayer() {}
+
+    /**
+     * New PacketExControlPlayer (Out)
+     *
+     * @param target Target Player
+     * @param command Command to send
+     * @param callback Callbacks
+     */
+    @SafeVarargs
+    public PacketExControlPlayer(UUID target, String command, Consumer<ObjectMap<Integer>>... callback) {
+        Util.nullpo(command, callback);
+        this.target = target;
+        this.command = command;
+        this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
+        callbacks.put(tracker, callback);
+    }
+
+    @Override
+    public ObjectMap<Integer> send(SubDataClient client) {
+        ObjectMap<Integer> data = new ObjectMap<Integer>();
+        data.set(0x0000, tracker);
+        data.set(0x0001, command);
+        if (target != null) data.set(0x0002, target);
+        return data;
+    }
+
+    @Override
+    public void receive(SubDataClient client, ObjectMap<Integer> data) {
+        for (Consumer<ObjectMap<Integer>> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data);
+    }
+}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExControlServer.java

@@ -12,15 +12,15 @@ import net.ME1312.SubServers.Bungee.SubProxy;
 import java.util.Arrays;
 
 /**
- * Edit External Server Packet
+ * Control External Server Packet
  */
-public class PacketExEditServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
+public class PacketExControlServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
     private SubProxy plugin;
     private SubServer server;
-    private UpdateType type;
+    private Action type;
     private Object[] args;
 
-    public enum UpdateType {
+    public enum Action {
         // Actions
         START(1, String.class),
         COMMAND(2, String.class),
@@ -35,7 +35,7 @@ public class PacketExEditServer implements PacketObjectIn<Integer>, PacketObject
 
         private short value;
         private Class<?>[] args;
-        UpdateType(int value, Class<?>... args) {
+        Action(int value, Class<?>... args) {
             this.value = (short) value;
             this.args = args;
         }
@@ -50,30 +50,31 @@ public class PacketExEditServer implements PacketObjectIn<Integer>, PacketObject
     }
 
     /**
-     * New PacketExEditServer (In)
+     * New PacketExControlServer (In)
      * @param plugin SubPlugin
      */
-    public PacketExEditServer(SubProxy plugin) {
+    public PacketExControlServer(SubProxy plugin) {
         this.plugin = plugin;
     }
 
     /**
-     * New PacketExEditServer (Out)
+     * New PacketExControlServer (Out)
      *
      * @param server SubServer
      * @param type Update Type
      * @param arguments Arguments
      */
-    public PacketExEditServer(SubServer server, UpdateType type, Object... arguments) {
-        if (arguments.length != type.getArguments().length) throw new IllegalArgumentException(((arguments.length > type.getArguments().length)?"Too many":"Not enough") + " arguments for type: " + type.toString());
-        int i = 0;
-        while (i < arguments.length) {
-            if (!type.getArguments()[i].isInstance(arguments[i])) throw new IllegalArgumentException("Argument " + (i+1) + " is not " + type.getArguments()[i].getCanonicalName());
-            i++;
-        }
+    public PacketExControlServer(SubServer server, Action type, Object... arguments) {
+        if (arguments.length < type.getArguments().length) throw new IllegalArgumentException("Not enough arguments for type: " + type);
+
         this.server = server;
         this.type = type;
-        this.args = arguments;
+        this.args = new Object[type.getArguments().length];
+
+        for (int i = 0; i < type.getArguments().length; ++i) {
+            if (!type.getArguments()[i].isInstance(arguments[i])) throw new IllegalArgumentException("Argument " + (i+1) + " is not " + type.getArguments()[i].getTypeName());
+            args[i] = arguments[i];
+        }
     }
 
     @Override
@@ -88,7 +89,7 @@ public class PacketExEditServer implements PacketObjectIn<Integer>, PacketObject
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         try {
-            ExternalSubServer server = (ExternalSubServer) plugin.api.getSubServer(data.getRawString(0x0000));
+            ExternalSubServer server = (ExternalSubServer) plugin.api.getSubServer(data.getString(0x0000));
             switch (data.getInt(0x0001)) {
                 case 1:
                     Util.reflect(ExternalSubServer.class.getDeclaredMethod("falsestart"), server);
@@ -101,9 +102,4 @@ public class PacketExEditServer implements PacketObjectIn<Integer>, PacketObject
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExCreateServer.java

@@ -1,6 +1,5 @@
 package net.ME1312.SubServers.Bungee.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;
@@ -12,12 +11,13 @@ import net.ME1312.SubServers.Bungee.Host.SubServer;
 
 import java.util.HashMap;
 import java.util.UUID;
+import java.util.function.Consumer;
 
 /**
  * Create Server External Host Packet
  */
 public class PacketExCreateServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
-    private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
+    private static HashMap<UUID, Consumer<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Consumer<ObjectMap<Integer>>[]>();
     private UUID player;
     private String name;
     private SubCreator.ServerTemplate template;
@@ -45,8 +45,8 @@ public class PacketExCreateServer implements PacketObjectIn<Integer>, PacketObje
      * @param callback Callbacks
      */
     @SafeVarargs
-    public PacketExCreateServer(UUID player, SubServer server, SubCreator.ServerTemplate template, Version version, UUID log, Callback<ObjectMap<Integer>>... callback) {
-        if (Util.isNull(server, template, log, callback)) throw new NullPointerException();
+    public PacketExCreateServer(UUID player, SubServer server, SubCreator.ServerTemplate template, Version version, UUID log, Consumer<ObjectMap<Integer>>... callback) {
+        Util.nullpo(server, template, log, callback);
         this.player = player;
         this.name = server.getName();
         this.template = template;
@@ -70,8 +70,8 @@ public class PacketExCreateServer implements PacketObjectIn<Integer>, PacketObje
      * @param callback Callbacks
      */
     @SafeVarargs
-    public PacketExCreateServer(UUID player, String name, SubCreator.ServerTemplate template, Version version, int port, UUID log, Callback<ObjectMap<Integer>>... callback) {
-        if (Util.isNull(name, template, port, log, callback)) throw new NullPointerException();
+    public PacketExCreateServer(UUID player, String name, SubCreator.ServerTemplate template, Version version, int port, UUID log, Consumer<ObjectMap<Integer>>... callback) {
+        Util.nullpo(name, template, port, log, callback);
         this.player = player;
         this.name = name;
         this.template = template;
@@ -117,12 +117,6 @@ public class PacketExCreateServer implements PacketObjectIn<Integer>, PacketObje
 
     @Override
     public void receive(SubDataClient 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;
+        for (Consumer<ObjectMap<Integer>> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data);
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExDeleteServer.java

@@ -1,6 +1,5 @@
 package net.ME1312.SubServers.Bungee.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.Server.Protocol.PacketObjectIn;
@@ -9,12 +8,13 @@ import net.ME1312.SubData.Server.SubDataClient;
 
 import java.util.HashMap;
 import java.util.UUID;
+import java.util.function.Consumer;
 
 /**
  * Delete Server External Host Packet
  */
 public class PacketExDeleteServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
-    private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
+    private static HashMap<UUID, Consumer<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Consumer<ObjectMap<Integer>>[]>();
     private String name;
     private ObjectMap<String> info;
     private boolean recycle;
@@ -33,8 +33,8 @@ public class PacketExDeleteServer implements PacketObjectIn<Integer>, PacketObje
      * @param callback Callbacks
      */
     @SafeVarargs
-    public PacketExDeleteServer(String name, ObjectMap<String> info, boolean recycle, Callback<ObjectMap<Integer>>... callback) {
-        if (Util.isNull(name, info, callback)) throw new NullPointerException();
+    public PacketExDeleteServer(String name, ObjectMap<String> info, boolean recycle, Consumer<ObjectMap<Integer>>... callback) {
+        Util.nullpo(name, info, callback);
         this.name = name;
         this.info = info;
         this.recycle = recycle;
@@ -44,26 +44,16 @@ public class PacketExDeleteServer implements PacketObjectIn<Integer>, PacketObje
 
     @Override
     public ObjectMap<Integer> send(SubDataClient client) {
-        if (tracker == null) {
-            return null;
-        } else {
-            ObjectMap<Integer> data = new ObjectMap<Integer>();
-            data.set(0x0000, tracker);
-            data.set(0x0001, name);
-            data.set(0x0002, info);
-            if (recycle) data.set(0x0003, true);
-            return data;
-        }
+        ObjectMap<Integer> data = new ObjectMap<Integer>();
+        data.set(0x0000, tracker);
+        data.set(0x0001, name);
+        data.set(0x0002, info);
+        if (recycle) data.set(0x0003, true);
+        return data;
     }
 
     @Override
     public void receive(SubDataClient 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;
+        for (Consumer<ObjectMap<Integer>> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data);
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExDisconnectPlayer.java

@@ -1,6 +1,5 @@
 package net.ME1312.SubServers.Bungee.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.Server.Protocol.PacketObjectIn;
@@ -8,14 +7,16 @@ import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
 import net.ME1312.SubData.Server.SubDataClient;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.UUID;
+import java.util.function.Consumer;
 
 /**
  * Disconnect External Player Packet
  */
 public class PacketExDisconnectPlayer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
-    private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
-    private UUID player;
+    private static HashMap<UUID, Consumer<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Consumer<ObjectMap<Integer>>[]>();
+    private List<UUID> players;
     private String reason;
     private UUID id;
 
@@ -27,14 +28,14 @@ public class PacketExDisconnectPlayer implements PacketObjectIn<Integer>, Packet
     /**
      * New PacketExDisconnectPlayer (Out)
      *
-     * @param player Player
+     * @param players Players
      * @param reason Reason
      * @param callback Callbacks
      */
     @SafeVarargs
-    public PacketExDisconnectPlayer(UUID player, String reason, Callback<ObjectMap<Integer>>... callback) {
-        if (Util.isNull(player, callback)) throw new NullPointerException();
-        this.player = player;
+    public PacketExDisconnectPlayer(List<UUID> players, String reason, Consumer<ObjectMap<Integer>>... callback) {
+        Util.nullpo(players, callback);
+        this.players = players;
         this.reason = reason;
         this.id = Util.getNew(callbacks.keySet(), UUID::randomUUID);
         callbacks.put(id, callback);
@@ -44,19 +45,13 @@ public class PacketExDisconnectPlayer implements PacketObjectIn<Integer>, Packet
     public ObjectMap<Integer> send(SubDataClient client) {
         ObjectMap<Integer> data = new ObjectMap<Integer>();
         data.set(0x0000, id);
-        data.set(0x0001, player);
+        data.set(0x0001, players);
         if (reason != null) data.set(0x0002, reason);
         return data;
     }
 
     @Override
     public void receive(SubDataClient 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;
+        for (Consumer<ObjectMap<Integer>> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data);
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExDownloadTemplates.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.Galaxi.Library.UniversalFile;
+import net.ME1312.Galaxi.Library.Directories;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.Library.DataSize;
 import net.ME1312.SubData.Server.Protocol.PacketIn;
@@ -8,10 +9,16 @@ import net.ME1312.SubData.Server.Protocol.PacketStreamOut;
 import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.SubServers.Bungee.Host.External.ExternalHost;
 import net.ME1312.SubServers.Bungee.Host.External.ExternalSubCreator;
+import net.ME1312.SubServers.Bungee.Host.SubCreator.ServerTemplate;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
 
 /**
  * External Host Template Download Packet
@@ -39,10 +46,29 @@ public class PacketExDownloadTemplates implements PacketIn, PacketStreamOut {
     public void send(SubDataClient client, OutputStream stream) throws Throwable {
         try {
             if (client.getBlockSize() < DataSize.MBB) client.tempBlockSize(DataSize.MBB);
-            Util.zip(new UniversalFile(plugin.dir, "SubServers:Templates"), stream);
-            stream.close();
+            HashMap<String, ServerTemplate> map = Try.all.getOrSupply(() -> Util.reflect(ExternalSubCreator.class.getDeclaredField("templates"), ((ExternalHost) client.getHandler()).getCreator()), HashMap::new);
+            File dir = new File(plugin.dir, "SubServers/Templates");
+            ZipOutputStream zip = new ZipOutputStream(stream);
 
-            Util.isException(() -> Util.reflect(ExternalSubCreator.class.getDeclaredField("enableRT"), host.getCreator(), true));
+            byte[] buffer = new byte[4096];
+            for (String file : Directories.search(dir)) {
+                int index = file.indexOf(File.separatorChar);
+                if (index != -1 && !map.containsKey(file.substring(0, index).toLowerCase())) {
+
+                    zip.putNextEntry(new ZipEntry(file.replace(File.separatorChar, '/')));
+                    FileInputStream in = new FileInputStream(dir.getAbsolutePath() + File.separator + file);
+
+                    int len;
+                    while ((len = in.read(buffer)) != -1) {
+                        zip.write(buffer, 0, len);
+                    }
+
+                    in.close();
+                }
+            }
+            zip.close();
+
+            Try.all.run(() -> Util.reflect(ExternalSubCreator.class.getDeclaredField("enableRT"), host.getCreator(), true));
         } catch (Exception e) {
             Logger.get("SubData").info("Problem encoding template files for Host: " + host.getName());
             e.printStackTrace();
@@ -55,9 +81,4 @@ public class PacketExDownloadTemplates implements PacketIn, PacketStreamOut {
             client.sendPacket(new PacketExDownloadTemplates(plugin, (ExternalHost) client.getHandler()));
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExMessagePlayer.java

@@ -0,0 +1,59 @@
+package net.ME1312.SubServers.Bungee.Network.Packet;
+
+import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
+import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
+import net.ME1312.SubData.Server.SubDataClient;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+/**
+ * Message External Player Packet
+ */
+public class PacketExMessagePlayer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
+    private static HashMap<UUID, Consumer<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Consumer<ObjectMap<Integer>>[]>();
+    private List<UUID> players;
+    private List<String> legacy, raw;
+    private UUID id;
+
+    /**
+     * New PacketExMessagePlayer (In)
+     */
+    public PacketExMessagePlayer() {}
+
+    /**
+     * New PacketExMessagePlayer (Out)
+     *
+     * @param players Players
+     * @param legacy Messages (Legacy)
+     * @param raw Messages (JSON)
+     * @param callback Callbacks
+     */
+    @SafeVarargs
+    public PacketExMessagePlayer(List<UUID> players, List<String> legacy, List<String> raw, Consumer<ObjectMap<Integer>>... callback) {
+        this.players = players;
+        this.legacy = legacy;
+        this.raw = raw;
+        this.id = Util.getNew(callbacks.keySet(), UUID::randomUUID);
+        callbacks.put(id, callback);
+    }
+
+    @Override
+    public ObjectMap<Integer> send(SubDataClient client) {
+        ObjectMap<Integer> data = new ObjectMap<Integer>();
+        data.set(0x0000, id);
+        if (players != null) data.set(0x0001, players);
+        if (legacy != null) data.set(0x0002, legacy);
+        if (raw != null) data.set(0x0003, raw);
+        return data;
+    }
+
+    @Override
+    public void receive(SubDataClient client, ObjectMap<Integer> data) {
+        for (Consumer<ObjectMap<Integer>> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data);
+    }
+}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExRemoveServer.java

@@ -1,6 +1,5 @@
 package net.ME1312.SubServers.Bungee.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.Server.Protocol.PacketObjectIn;
@@ -9,12 +8,13 @@ import net.ME1312.SubData.Server.SubDataClient;
 
 import java.util.HashMap;
 import java.util.UUID;
+import java.util.function.Consumer;
 
 /**
  * Create Server External Host Packet
  */
 public class PacketExRemoveServer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
-    private static HashMap<UUID, Callback<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Callback<ObjectMap<Integer>>[]>();
+    private static HashMap<UUID, Consumer<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Consumer<ObjectMap<Integer>>[]>();
     private String name;
     private UUID tracker;
 
@@ -30,8 +30,8 @@ public class PacketExRemoveServer implements PacketObjectIn<Integer>, PacketObje
      * @param callback Callbacks
      */
     @SafeVarargs
-    public PacketExRemoveServer(String name, Callback<ObjectMap<Integer>>... callback) {
-        if (Util.isNull(name, callback)) throw new NullPointerException();
+    public PacketExRemoveServer(String name, Consumer<ObjectMap<Integer>>... callback) {
+        Util.nullpo(name, callback);
         this.name = name;
         this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
         callbacks.put(tracker, callback);
@@ -47,12 +47,6 @@ public class PacketExRemoveServer implements PacketObjectIn<Integer>, PacketObje
 
     @Override
     public void receive(SubDataClient 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;
+        for (Consumer<ObjectMap<Integer>> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data);
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExSyncPlayer.java

@@ -32,8 +32,7 @@ public class PacketExSyncPlayer implements PacketObjectIn<Integer>, PacketObject
      * @param plugin SubPlugin
      */
     public PacketExSyncPlayer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -76,10 +75,10 @@ public class PacketExSyncPlayer implements PacketObjectIn<Integer>, PacketObject
                     }
                 }
                 if (data.getBoolean(0x0001) != Boolean.FALSE) {
-                    if (data.contains(0x0002)) for (Map<String, Object> object : (List<Map<String, Object>>) data.getObjectList(0x0002)) {
-                        Server server = (object.getOrDefault("server", null) != null)?plugin.api.getServer(object.get("server").toString()):null;
-                        RemotePlayer player = new RemotePlayer(object.get("name").toString(), UUID.fromString(object.get("id").toString()), (Proxy) client.getHandler(), server,
-                                new InetSocketAddress(object.get("address").toString().split(":")[0], Integer.parseInt(object.get("address").toString().split(":")[1])));
+                    if (data.contains(0x0002)) for (ObjectMap<String> object : (List<ObjectMap<String>>) (List<?>) data.getMapList(0x0002)) {
+                        Server server = (object.contains("server"))?plugin.api.getServer(object.getString("server")):null;
+                        RemotePlayer player = new RemotePlayer(object.getString("name"), object.getUUID("id"), (Proxy) client.getHandler(), server,
+                                new InetSocketAddress(object.getString("address").split(":")[0], Integer.parseInt(object.getString("address").split(":")[1])));
 
                         forward.add(player);
                         plugin.rPlayerLinkP.put(player.getUniqueId(), (Proxy) client.getHandler());
@@ -87,8 +86,8 @@ public class PacketExSyncPlayer implements PacketObjectIn<Integer>, PacketObject
                         if (server != null) plugin.rPlayerLinkS.put(player.getUniqueId(), server);
                     }
                 } else {
-                    if (data.contains(0x0002)) for (Map<String, Object> object : (List<Map<String, Object>>) data.getObjectList(0x0002)) {
-                        UUID id = UUID.fromString(object.get("id").toString());
+                    if (data.contains(0x0002)) for (ObjectMap<String> object : (List<ObjectMap<String>>) (List<?>) data.getMapList(0x0002)) {
+                        UUID id = object.getUUID("id");
                         RemotePlayer player = plugin.rPlayers.get(id);
 
                         // Don't accept removal requests from non-managing proxies
@@ -110,9 +109,4 @@ public class PacketExSyncPlayer implements PacketObjectIn<Integer>, PacketObject
             }
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExTransferPlayer.java

@@ -0,0 +1,57 @@
+package net.ME1312.SubServers.Bungee.Network.Packet;
+
+import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
+import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
+import net.ME1312.SubData.Server.SubDataClient;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+/**
+ * Transfer External Player Packet
+ */
+public class PacketExTransferPlayer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
+    private static HashMap<UUID, Consumer<ObjectMap<Integer>>[]> callbacks = new HashMap<UUID, Consumer<ObjectMap<Integer>>[]>();
+    private List<UUID> players;
+    private String server;
+    private UUID id;
+
+    /**
+     * New PacketExTransferPlayer (In)
+     */
+    public PacketExTransferPlayer() {}
+
+    /**
+     * New PacketExTransferPlayer (Out)
+     *
+     * @param players Players
+     * @param server Server
+     * @param callback Callbacks
+     */
+    @SafeVarargs
+    public PacketExTransferPlayer(List<UUID> players, String server, Consumer<ObjectMap<Integer>>... callback) {
+        Util.nullpo(players, server, callback);
+        this.players = players;
+        this.server = server;
+        this.id = Util.getNew(callbacks.keySet(), UUID::randomUUID);
+        callbacks.put(id, callback);
+    }
+
+    @Override
+    public ObjectMap<Integer> send(SubDataClient client) {
+        ObjectMap<Integer> data = new ObjectMap<Integer>();
+        data.set(0x0000, id);
+        data.set(0x0001, players);
+        data.set(0x0002, server);
+        return data;
+    }
+
+    @Override
+    public void receive(SubDataClient client, ObjectMap<Integer> data) {
+        for (Consumer<ObjectMap<Integer>> callback : callbacks.remove(data.getUUID(0x0000))) callback.accept(data);
+    }
+}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketExUploadTemplates.java

@@ -1,7 +1,7 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.Galaxi.Library.UniversalFile;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
 import net.ME1312.SubData.Server.Protocol.PacketOut;
@@ -12,7 +12,9 @@ import net.ME1312.SubServers.Bungee.Host.SubCreator;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
 import java.io.File;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.Map;
 import java.util.logging.Logger;
 
@@ -20,41 +22,44 @@ import java.util.logging.Logger;
  * External Host Template Upload Packet
  */
 public class PacketExUploadTemplates implements PacketObjectIn<Integer>, PacketOut {
+    private static LinkedList<Runnable> callbacks = new LinkedList<Runnable>();
     private SubProxy plugin;
 
     /**
      * New PacketExUploadTemplates
      */
-    public PacketExUploadTemplates(SubProxy plugin) {
+    public PacketExUploadTemplates(SubProxy plugin, Runnable... callbacks) {
         this.plugin = plugin;
+        PacketExUploadTemplates.callbacks.addAll(Arrays.asList(callbacks));
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         if (client.getHandler() != null && client.getHandler() instanceof ExternalHost) {
-            HashMap<String, SubCreator.ServerTemplate> map = Util.getDespiteException(() -> Util.reflect(ExternalSubCreator.class.getDeclaredField("templates"), ((ExternalHost) client.getHandler()).getCreator()), new HashMap<>());
-            UniversalFile templatedir = new UniversalFile(plugin.dir, "SubServers:Cache:Remote:Templates");
+            HashMap<String, SubCreator.ServerTemplate> map = Try.all.get(() -> Util.reflect(ExternalSubCreator.class.getDeclaredField("templates"), ((ExternalHost) client.getHandler()).getCreator()), new HashMap<>());
+            File templatedir = new File(plugin.dir, "SubServers/Cache/Remote/Templates");
             ObjectMap<String> templates = new ObjectMap<>((Map<String, ?>) data.getObject(0x0000));
             map.clear();
             for (String name : templates.getKeys()) {
                 try {
-                    UniversalFile dir = new UniversalFile(templatedir, name);
-                    SubCreator.ServerTemplate template = Util.reflect(SubCreator.class.getDeclaredMethod("loadTemplate", String.class, boolean.class, String.class, File.class, ObjectMap.class, ObjectMap.class),
-                            ((ExternalHost) client.getHandler()).getCreator(), name, templates.getMap(name).getBoolean("enabled"), templates.getMap(name).getRawString("icon"), dir,
+                    File dir = new File(templatedir, name);
+                    SubCreator.ServerTemplate template = Util.reflect(SubCreator.class.getDeclaredMethod("loadTemplate", String.class, boolean.class, boolean.class, String.class, File.class, ObjectMap.class, ObjectMap.class),
+                            ((ExternalHost) client.getHandler()).getCreator(), name, templates.getMap(name).getBoolean("enabled"), templates.getMap(name).getBoolean("internal"), templates.getMap(name).getString("icon"), dir,
                             templates.getMap(name).getMap("build").clone(), templates.getMap(name).getMap("settings").clone());
                     map.put(name.toLowerCase(), template);
-                    if (!templates.getMap(name).getRawString("display").equals(name)) template.setDisplayName(templates.getMap(name).getRawString("display"));
+                    if (!templates.getMap(name).getString("display").equals(name)) template.setDisplayName(templates.getMap(name).getString("display"));
                 } catch (Exception e) {
                     Logger.getLogger("SubServers").severe("Couldn't load template: " + name);
                     e.printStackTrace();
                 }
             }
+
+            LinkedList<Runnable> callbacks = PacketExUploadTemplates.callbacks;
+            PacketExUploadTemplates.callbacks = new LinkedList<Runnable>();
+            for (Runnable r : callbacks) {
+                r.run();
+            }
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketInExLogMessage.java

@@ -23,19 +23,21 @@ public class PacketInExLogMessage implements PacketObjectIn<Integer> {
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         try {
-            if (data.contains(0x0000) && data.contains(0x0001) && loggers.keySet().contains(data.getUUID(0x0000))) {
-                Util.reflect(ExternalSubLogger.class.getDeclaredMethod("log", String.class), loggers.get(data.getUUID(0x0000)), data.getRawString(0x0001));
+            if (data.contains(0x0000)) {
+                if (data.contains(0x0002) && data.contains(0x0001)) {
+                    if (loggers.containsKey(data.getUUID(0x0000))) {
+                        Util.reflect(ExternalSubLogger.class.getDeclaredMethod("log", int.class, String.class), loggers.get(data.getUUID(0x0000)), data.getInt(0x0001), data.getString(0x0002));
+                    }
+                } else {
+                    unregister(data.getUUID(0x0000));
+                    client.close();
+                }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
-    @Override
-    public int version() {
-        return 0x0001;
-    }
-
     /**
      * Register External Logger
      *
@@ -54,6 +56,6 @@ public class PacketInExLogMessage implements PacketObjectIn<Integer> {
      * @param id External Address
      */
     public static void unregister(UUID id) {
-        loggers.remove(id);
+        if (loggers.containsKey(id)) loggers.remove(id).stop();
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketInExRequestQueue.java

@@ -31,9 +31,4 @@ public class PacketInExRequestQueue implements PacketIn {
             }
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketInReload.java

@@ -31,9 +31,4 @@ public class PacketInReload implements PacketObjectIn<Integer> {
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketLinkExHost.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.Protocol.Initial.InitialPacket;
 import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
@@ -30,8 +31,7 @@ public class PacketLinkExHost implements InitialPacket, PacketObjectIn<Integer>,
      * @param plugin SubPlugin
      */
     public PacketLinkExHost(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -41,7 +41,7 @@ public class PacketLinkExHost implements InitialPacket, PacketObjectIn<Integer>,
      * @param message Message
      */
     public PacketLinkExHost(int response, String message) {
-        if (Util.isNull(response)) throw new NullPointerException();
+        Util.nullpo(response);
         this.response = response;
         this.message = message;
     }
@@ -58,24 +58,24 @@ public class PacketLinkExHost implements InitialPacket, PacketObjectIn<Integer>,
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         try {
             Map<String, Host> hosts = plugin.api.getHosts();
-            if (hosts.keySet().contains(data.getRawString(0x0000).toLowerCase())) {
-                Host host = hosts.get(data.getRawString(0x0000).toLowerCase());
+            if (hosts.containsKey(data.getString(0x0000).toLowerCase())) {
+                Host host = hosts.get(data.getString(0x0000).toLowerCase());
                 if (host instanceof ExternalHost) {
                     Integer channel = data.getInt(0x0001);
-                    HashMap<Integer, SubDataClient> subdata = Util.getDespiteException(() -> Util.reflect(ExternalHost.class.getDeclaredField("subdata"), host), null);
-                    if (!subdata.keySet().contains(channel) || (channel == 0 && subdata.get(0) == null)) {
+                    HashMap<Integer, SubDataClient> subdata = Try.all.get(() -> Util.reflect(ExternalHost.class.getDeclaredField("subdata"), host));
+                    if (!subdata.containsKey(channel) || (channel == 0 && subdata.get(0) == null)) {
                         ((ExternalHost) host).setSubData(client, channel);
-                        Logger.get("SubData").info(client.getAddress().toString() + " has been defined as Host: " + host.getName() + ((channel > 0)?" (Sub-"+channel+")":""));
+                        Logger.get("SubData").info(client.getAddress().toString() + " has been defined as Host: " + host.getName() + ((channel > 0)?" [+"+channel+"]":""));
                         queue(host.getName(), () -> client.sendPacket(new PacketLinkExHost(0, null)));
                         setReady(client);
                     } else {
-                        client.sendPacket(new PacketLinkExHost(3, "Host already linked"));
+                        client.sendPacket(new PacketLinkExHost(3, "Host already linked: " + data.getString(0x0000)));
                     }
                 } else {
-                    client.sendPacket(new PacketLinkExHost(4, "That host does not support a network interface"));
+                    client.sendPacket(new PacketLinkExHost(4, "Requested host does not support network interfaces: " + data.getString(0x0000)));
                 }
             } else {
-                client.sendPacket(new PacketLinkExHost(2, "There is no host with name: " + data.getRawString(0x0000)));
+                client.sendPacket(new PacketLinkExHost(2, "There is no host with name: " + data.getString(0x0000)));
             }
         } catch (Throwable e) {
             client.sendPacket(new PacketLinkExHost(1, null));
@@ -98,9 +98,4 @@ public class PacketLinkExHost implements InitialPacket, PacketObjectIn<Integer>,
         ++req;
         last = now;
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketLinkProxy.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.Protocol.Initial.InitialPacket;
 import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
@@ -31,8 +32,7 @@ public class PacketLinkProxy implements InitialPacket, PacketObjectIn<Integer>,
      * @param plugin SubPlugin
      */
     public PacketLinkProxy(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -60,27 +60,27 @@ public class PacketLinkProxy implements InitialPacket, PacketObjectIn<Integer>,
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         try {
             Map<String, Proxy> proxies = plugin.api.getProxies();
-            String name = ((data.contains(0x0000))?data.getRawString(0x0000):null);
+            String name = ((data.contains(0x0000))?data.getString(0x0000):null);
             Integer channel = data.getInt(0x0001);
 
             boolean isnew = false;
             Proxy proxy;
-            if (name != null && proxies.keySet().contains(name.toLowerCase())) {
+            if (name != null && proxies.containsKey(name.toLowerCase())) {
                 proxy = proxies.get(name.toLowerCase());
             } else {
-                proxy = new Proxy((name != null && !proxies.keySet().contains(name.toLowerCase()))?name:null);
+                proxy = new Proxy((name != null && !proxies.containsKey(name.toLowerCase()))?name:null);
                 isnew = true;
                 plugin.proxies.put(proxy.getName().toLowerCase(), proxy);
             }
-            HashMap<Integer, SubDataClient> subdata = Util.getDespiteException(() -> Util.reflect(Proxy.class.getDeclaredField("subdata"), proxy), null);
-            if (!subdata.keySet().contains(channel) || (channel == 0 && subdata.get(0) == null)) {
+            HashMap<Integer, SubDataClient> subdata = Try.all.get(() -> Util.reflect(Proxy.class.getDeclaredField("subdata"), proxy));
+            if (!subdata.containsKey(channel) || (channel == 0 && subdata.get(0) == null)) {
                 proxy.setSubData(client, channel);
                 if (isnew) plugin.getPluginManager().callEvent(new SubAddProxyEvent(proxy));
-                Logger.get("SubData").info(client.getAddress().toString() + " has been defined as Proxy: " + proxy.getName() + ((channel > 0)?" (Sub-"+channel+")":""));
+                Logger.get("SubData").info(client.getAddress().toString() + " has been defined as Proxy: " + proxy.getName() + ((channel > 0)?" [+"+channel+"]":""));
                 queue(proxy.getName(), () -> client.sendPacket(new PacketLinkProxy(proxy.getName(), 0, null)));
                 setReady(client);
             } else {
-                client.sendPacket(new PacketLinkProxy(proxy.getName(), 2, "Proxy already linked"));
+                client.sendPacket(new PacketLinkProxy(null, 2, "Proxy already linked: " + proxy.getName()));
 
             }
         } catch (Throwable e) {
@@ -104,9 +104,4 @@ public class PacketLinkProxy implements InitialPacket, PacketObjectIn<Integer>,
         ++req;
         last = now;
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketLinkServer.java

@@ -1,6 +1,7 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.Library.DisconnectReason;
 import net.ME1312.SubData.Server.Protocol.Initial.InitialPacket;
@@ -13,6 +14,7 @@ import net.ME1312.SubServers.Bungee.Host.ServerImpl;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.Host.SubServerImpl;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
+import net.ME1312.SubServers.Bungee.SubAPI;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
 import net.md_5.bungee.api.ProxyServer;
@@ -25,6 +27,7 @@ import java.util.concurrent.TimeUnit;
  * Link Server Packet
  */
 public class PacketLinkServer implements InitialPacket, PacketObjectIn<Integer>, PacketObjectOut<Integer> {
+    public static boolean strict = true;
     private SubProxy plugin;
     private int response;
     private String message;
@@ -42,8 +45,7 @@ public class PacketLinkServer implements InitialPacket, PacketObjectIn<Integer>,
      * @param plugin SubPlugin
      */
     public PacketLinkServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -54,7 +56,7 @@ public class PacketLinkServer implements InitialPacket, PacketObjectIn<Integer>,
      * @param message Message
      */
     public PacketLinkServer(String name, int response, String message) {
-        if (Util.isNull(response)) throw new NullPointerException();
+        Util.nullpo(response);
         this.name = name;
         this.response = response;
         this.message = message;
@@ -71,20 +73,29 @@ public class PacketLinkServer implements InitialPacket, PacketObjectIn<Integer>,
 
     @Override
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
-        String name =  (data.contains(0x0000))?data.getRawString(0x0000):null;
-        Integer port = (data.contains(0x0001))?data.getInt(0x0001):null;
+        String name =  (data.contains(0x0000))?data.getString(0x0000):null;
         Integer channel = data.getInt(0x0002);
+        InetSocketAddress address;
 
         try {
-            Map<String, Server> servers = plugin.api.getServers();
+            if (!data.contains(0x0001)) {
+                address = null;
+            } else if (data.isNumber(0x0001)) {
+                address = new InetSocketAddress(client.getAddress().getAddress(), data.getInt(0x0001));
+            } else {
+                String[] sa = data.getString(0x0001).split(":");
+                address = new InetSocketAddress(sa[0], Integer.parseInt(sa[1]));
+            }
+
             Server server;
-            if (name != null && servers.keySet().contains(name.toLowerCase())) {
+            Map<String, Server> servers = plugin.api.getServers();
+            if (name != null && servers.containsKey(name.toLowerCase())) {
                 link(client, servers.get(name.toLowerCase()), channel);
-            } else if (port != null) {
-                if ((server = search(new InetSocketAddress(client.getAddress().getAddress(), port))) != null) {
+            } else if (address != null) {
+                if ((server = search(address)) != null || (server = create(name, address)) != null) {
                     link(client, server, channel);
                 } else {
-                    throw new ServerLinkException("There is no server with address: " + client.getAddress().getAddress().getHostAddress() + ':' + port);
+                    throw new ServerLinkException("There is no server with address: " + address.getAddress().getHostAddress() + ':' + address.getPort());
                 }
             } else {
                 throw new ServerLinkException("Not enough arguments");
@@ -101,25 +112,47 @@ public class PacketLinkServer implements InitialPacket, PacketObjectIn<Integer>,
         }
     }
 
-    static int req = 1;
+    private Server create(String name, InetSocketAddress address) throws Throwable {
+        if (strict) {
+            return null;
+        } else {
+            String id = (name == null)? Util.getNew(SubAPI.getInstance().getServers().keySet(), () -> UUID.randomUUID().toString()) : name;
+            Server server = SubAPI.getInstance().addServer(id, address.getAddress(), address.getPort(), "Some Dynamic Server", name == null, false);
+            if (server != null) Util.reflect(ServerImpl.class.getDeclaredField("persistent"), server, false);
+            return server;
+        }
+    }
+
+    private Server search(InetSocketAddress address) {
+        Server server = null;
+        for (Server s : plugin.api.getServers().values()) {
+            if (s.getAddress().equals(address)) {
+                if (server != null) throw new ServerLinkException("Multiple servers match address: " + address.getAddress().getHostAddress() + ':' + address.getPort());
+                server = s;
+            }
+        }
+        return server;
+    }
+
+    static long req = 1;
     static long last = Calendar.getInstance().getTime().getTime();
     private void link(SubDataClient client, Server server, int channel) throws Throwable {
-        HashMap<Integer, SubDataClient> subdata = Util.getDespiteException(() -> Util.reflect(ServerImpl.class.getDeclaredField("subdata"), server), null);
-        if (!subdata.keySet().contains(channel) || (channel == 0 && subdata.get(0) == null)) {
+        HashMap<Integer, SubDataClient> subdata = Try.all.get(() -> Util.reflect(ServerImpl.class.getDeclaredField("subdata"), server));
+        if (!subdata.containsKey(channel) || (channel == 0 && subdata.get(0) == null)) {
             server.setSubData(client, channel);
-            Logger.get("SubData").info(client.getAddress().toString() + " has been defined as " + ((server instanceof SubServer) ? "SubServer" : "Server") + ": " + server.getName() + ((channel > 0)?" (Sub-"+channel+")":""));
+            Logger.get("SubData").info(client.getAddress().toString() + " has been defined as " + ((server instanceof SubServer) ? "SubServer" : "Server") + ": " + server.getName() + ((channel > 0)?" [+"+channel+"]":""));
             Runnable register = () -> {
                 if (server instanceof SubServer && !((SubServer) server).isRunning()) {
-                    if (((SubServer) server).getHost().isAvailable()) {
+                    if (((SubServer) server).isAvailable()) {
                         Logger.get("SubServers").info("Sending shutdown signal to rogue SubServer: " + server.getName());
                         client.sendPacket(new PacketOutExReset("Rogue SubServer Detected"));
                     } else {
                         // Drop connection if host is unavailable for rogue checking (try again later)
-                        Util.isException(() -> Util.reflect(SubDataClient.class.getDeclaredMethod("close", DisconnectReason.class), client, DisconnectReason.CLOSE_REQUESTED));
+                        Try.all.run(() -> Util.reflect(SubDataClient.class.getDeclaredMethod("close", DisconnectReason.class), client, DisconnectReason.CLOSE_REQUESTED));
                     }
                 } else {
-                    if (server instanceof SubServer && !Util.getDespiteException(() -> Util.reflect(SubServerImpl.class.getDeclaredField("started"), server), true)) {
-                        Util.isException(() -> Util.reflect(SubServerImpl.class.getDeclaredField("started"), server, true));
+                    if (server instanceof SubServer && !Try.all.get(() -> Util.reflect(SubServerImpl.class.getDeclaredField("started"), server), true)) {
+                        Try.all.run(() -> Util.reflect(SubServerImpl.class.getDeclaredField("started"), server, true));
                         SubStartedEvent event = new SubStartedEvent((SubServer) server);
                         ProxyServer.getInstance().getPluginManager().callEvent(event);
                     }
@@ -142,23 +175,7 @@ public class PacketLinkServer implements InitialPacket, PacketObjectIn<Integer>,
             last = now;
             setReady(client);
         } else {
-            client.sendPacket(new PacketLinkServer(null, 4, "Server already linked"));
+            client.sendPacket(new PacketLinkServer(null, 4, "Server already linked: " + server.getName()));
         }
     }
-
-    private Server search(InetSocketAddress address) throws ServerLinkException {
-        Server server = null;
-        for (Server s : plugin.api.getServers().values()) {
-            if (s.getAddress().equals(address)) {
-                if (server != null) throw new ServerLinkException("Multiple servers match address: " + address.getAddress().getHostAddress() + ':' + address.getPort());
-                server = s;
-            }
-        }
-        return server;
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketMessagePlayer.java

@@ -0,0 +1,146 @@
+package net.ME1312.SubServers.Bungee.Network.Packet;
+
+import net.ME1312.Galaxi.Library.Container.ContainedPair;
+import net.ME1312.Galaxi.Library.Container.Container;
+import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.Galaxi.Library.Merger;
+import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
+import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
+import net.ME1312.SubData.Server.SubDataClient;
+import net.ME1312.SubServers.Bungee.Host.Proxy;
+import net.ME1312.SubServers.Bungee.Host.RemotePlayer;
+import net.ME1312.SubServers.Bungee.SubAPI;
+
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.chat.ComponentSerializer;
+
+import java.util.*;
+import java.util.function.IntConsumer;
+
+/**
+ * Message Player Packet
+ */
+public class PacketMessagePlayer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
+    private int response;
+    private UUID tracker;
+
+    /**
+     * New PacketMessagePlayer (In)
+     */
+    public PacketMessagePlayer() {
+
+    }
+
+    /**
+     * New PacketMessagePlayer (Out)
+     *
+     * @param response Response ID
+     * @param tracker Receiver ID
+     */
+    public PacketMessagePlayer(int response, UUID tracker) {
+        this.response = response;
+        this.tracker = tracker;
+    }
+
+    @Override
+    public ObjectMap<Integer> send(SubDataClient client) {
+        ObjectMap<Integer> json = new ObjectMap<Integer>();
+        if (tracker != null) json.set(0x0000, tracker);
+        json.set(0x0001, response);
+        return json;
+    }
+
+    @Override
+    public void receive(SubDataClient client, ObjectMap<Integer> data) {
+        UUID tracker = (data.contains(0x0000)?data.getUUID(0x0000):null);
+        run(data.contains(0x0001)?data.getUUIDList(0x0001):null, null, data, i -> {
+            client.sendPacket(new PacketMessagePlayer(i, tracker));
+        });
+    }
+
+    @SuppressWarnings("deprecation")
+    public static void run(List<UUID> ids, ContainedPair<String[], BaseComponent[][]> message, ObjectMap<Integer> data, IntConsumer callback) {
+        try {
+            Container<Integer> failures = new Container<>(0);
+            HashMap<Proxy, List<UUID>> requests = new HashMap<Proxy, List<UUID>>();
+            if (ids == null || ids.size() == 0) {
+                if (ProxyServer.getInstance().getPlayers().size() > 0) {
+                    if (message == null) message = parseMessage(data);
+
+                    if (message.key != null) for (String s : message.key)
+                        ProxyServer.getInstance().broadcast(s);
+                    if (message.value != null) for (BaseComponent[] c : message.value)
+                        ProxyServer.getInstance().broadcast(c);
+                }
+                for (Proxy proxy : SubAPI.getInstance().getProxies().values()) {
+                    if (proxy.getPlayers().size() > 0 && proxy.getSubData()[0] != null) requests.put(proxy, null);
+                }
+            } else {
+                for (UUID id : ids) {
+                    ProxiedPlayer local;
+                    RemotePlayer remote;
+                    if ((local = ProxyServer.getInstance().getPlayer(id)) != null) {
+                        if (message == null) message = parseMessage(data);
+                        if (message.key != null)
+                            local.sendMessages(message.key);
+                        if (message.value != null) for (BaseComponent[] c : message.value)
+                            local.sendMessage(c);
+                    } else if ((remote = SubAPI.getInstance().getRemotePlayer(id)) != null && remote.getProxy().getSubData()[0] != null) {
+                        Proxy proxy = remote.getProxy();
+                        List<UUID> list = requests.getOrDefault(proxy, new ArrayList<>());
+                        list.add(id);
+                        requests.put(proxy, list);
+                    } else {
+                        ++failures.value;
+                    }
+                }
+            }
+
+            if (requests.size() == 0) {
+                callback.accept(failures.value);
+            } else {
+                Merger merge = new Merger(() -> {
+                    callback.accept(failures.value);
+                });
+                List<String> legacy, raw;
+                if (data == null) {
+                    legacy = (message.key != null?Arrays.asList(message.key):null);
+                    if (message.value != null) {
+                        raw = new LinkedList<String>();
+                        for (BaseComponent[] c : message.value) raw.add(ComponentSerializer.toString(c));
+                    } else {
+                        raw = null;
+                    }
+                } else {
+                    legacy = (data.contains(0x0002)?data.getStringList(0x0002):null);
+                    raw =    (data.contains(0x0003)?data.getStringList(0x0003):null);
+                }
+                for (Map.Entry<Proxy, List<UUID>> entry : requests.entrySet()) {
+                    merge.reserve();
+                    ((SubDataClient) entry.getKey().getSubData()[0]).sendPacket(new PacketExMessagePlayer(entry.getValue(), legacy, raw, r -> {
+                        failures.value += r.getInt(0x0001);
+                        merge.release();
+                    }));
+                }
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+            callback.accept((ids == null || ids.size() == 0)? 1 : ids.size());
+        }
+    }
+
+    private static ContainedPair<String[], BaseComponent[][]> parseMessage(ObjectMap<Integer> data) {
+        ContainedPair<String[], BaseComponent[][]> value = new ContainedPair<>();
+        if (data.contains(0x0002))
+            value.key = data.getStringList(0x0002).toArray(new String[0]);
+        if (data.contains(0x0003)) {
+            List<String> messages = data.getStringList(0x0003);
+            BaseComponent[][] components = new BaseComponent[messages.size()][];
+            for (int i = 0; i < components.length; ++i) components[i] = ComponentSerializer.parse(messages.get(i));
+            value.value = components;
+        }
+        return value;
+    }
+}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketOutExEditServer.java

@@ -0,0 +1,90 @@
+package net.ME1312.SubServers.Bungee.Network.Packet;
+
+import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
+import net.ME1312.SubData.Server.SubDataClient;
+import net.ME1312.SubServers.Bungee.Host.Server;
+import net.ME1312.SubServers.Bungee.SubProxy;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * External Server Edit Notification Packet
+ */
+public class PacketOutExEditServer implements PacketObjectOut<Integer> {
+    private SubProxy plugin;
+    private Server server;
+    private Edit type;
+    private Object[] args;
+
+    public enum Edit {
+        // Generic
+        DISPLAY_NAME(0, String.class),
+        MOTD(1, String.class),
+        RESTRICTED(2, Boolean.class),
+        HIDDEN(3, Boolean.class),
+
+        // SubData
+        CONNECTED(4, Integer.class, UUID.class),
+        DISCONNECTED(5, Integer.class),
+
+        // Whitelist
+        WHITELIST_SET(6, List.class),
+        WHITELIST_ADD(7, UUID.class),
+        WHITELIST_REMOVE(8, UUID.class);
+
+        private short value;
+        private Class<?>[] args;
+        Edit(int value, Class<?>... args) {
+            this.value = (short) value;
+            this.args = args;
+        }
+
+        public Class<?>[] getArguments() {
+            return args;
+        }
+
+        public short getValue() {
+            return value;
+        }
+    }
+
+    /**
+     * New PacketExEditServer (In)
+     * @param plugin SubPlugin
+     */
+    public PacketOutExEditServer(SubProxy plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * New PacketExEditServer (Out)
+     *
+     * @param server SubServer
+     * @param type Update Type
+     * @param arguments Arguments
+     */
+    public PacketOutExEditServer(Server server, Edit type, Object... arguments) {
+        if (arguments.length < type.getArguments().length) throw new IllegalArgumentException("Not enough arguments for type: " + type);
+
+        this.server = server;
+        this.type = type;
+        this.args = new Object[type.getArguments().length];
+
+        for (int i = 0; i < type.getArguments().length; ++i) {
+            if (!type.getArguments()[i].isInstance(arguments[i])) throw new IllegalArgumentException("Argument " + (i+1) + " is not " + type.getArguments()[i].getTypeName());
+            args[i] = arguments[i];
+        }
+    }
+
+    @Override
+    public ObjectMap<Integer> send(SubDataClient client) {
+        ObjectMap<Integer> data = new ObjectMap<Integer>();
+        data.set(0x0000, server.getName());
+        data.set(0x0001, type.getValue());
+        data.set(0x0002, Arrays.asList(args));
+        return data;
+    }
+}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketOutExReload.java

@@ -29,9 +29,4 @@ public class PacketOutExReload implements PacketObjectOut<Integer> {
             return data;
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketOutExReset.java

@@ -29,9 +29,4 @@ public class PacketOutExReset implements PacketObjectOut<Integer> {
             return json;
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketOutExRunEvent.java

@@ -28,8 +28,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
      * @param plugin
      */
     public PacketOutExRunEvent(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -39,7 +38,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
      * @param args Arguments
      */
     public PacketOutExRunEvent(Class<? extends SubEvent> event, ObjectMap<String> args) {
-        if (Util.isNull(event, args)) throw new NullPointerException();
+        Util.nullpo(event, args);
         this.type = event.getSimpleName();
         this.args = args;
     }
@@ -52,11 +51,6 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
         return json;
     }
 
-    @Override
-    public int version() {
-        return 0x0001;
-    }
-
     private void broadcast(PacketOutExRunEvent packet) {
         broadcast(null, packet);
     }
@@ -86,7 +80,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubAddHostEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             args.set("host", event.getHost().getName());
             broadcast(event.getHost(), new PacketOutExRunEvent(event.getClass(), args));
         }
@@ -96,7 +90,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubAddServerEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             if (event.getHost() != null) args.set("host", event.getHost().getName());
             args.set("server", event.getServer().getName());
             broadcast(event.getServer(), new PacketOutExRunEvent(event.getClass(), args));
@@ -107,7 +101,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubCreateEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             args.set("update", event.isUpdate());
             args.set("name", event.getName());
             args.set("host", event.getHost().getName());
@@ -121,7 +115,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     @EventHandler(priority = Byte.MAX_VALUE)
     public void event(SubCreatedEvent event) {
         ObjectMap<String> args = new ObjectMap<String>();
-        if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+        if (event.getPlayer() != null) args.set("player", event.getPlayer());
         args.set("success", event.wasSuccessful());
         args.set("update", event.wasUpdate());
         args.set("name", event.getName());
@@ -136,9 +130,10 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubSendCommandEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             args.set("server", event.getServer().getName());
             args.set("command", event.getCommand());
+            if (event.getTarget() != null) args.set("target", event.getTarget());
             broadcast(new PacketOutExRunEvent(event.getClass(), args));
         }
     }
@@ -147,7 +142,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubEditServerEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             args.set("server", event.getServer().getName());
             args.set("edit", event.getEdit().key());
             args.set("value", event.getEdit().value().asObject());
@@ -159,7 +154,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubStartEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             args.set("server", event.getServer().getName());
             broadcast(new PacketOutExRunEvent(event.getClass(), args));
         }
@@ -176,7 +171,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubStopEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             args.set("server", event.getServer().getName());
             args.set("force", event.isForced());
             broadcast(new PacketOutExRunEvent(event.getClass(), args));
@@ -195,7 +190,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubRemoveServerEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             if (event.getHost() != null) args.set("host", event.getHost().getName());
             args.set("server", event.getServer().getName());
             broadcast(event.getServer(), new PacketOutExRunEvent(event.getClass(), args));
@@ -206,7 +201,7 @@ public class PacketOutExRunEvent implements Listener, PacketObjectOut<Integer> {
     public void event(SubRemoveHostEvent event) {
         if (!event.isCancelled()) {
             ObjectMap<String> args = new ObjectMap<String>();
-            if (event.getPlayer() != null) args.set("player", event.getPlayer().toString());
+            if (event.getPlayer() != null) args.set("player", event.getPlayer());
             args.set("host", event.getHost().getName());
             broadcast(event.getHost(), new PacketOutExRunEvent(event.getClass(), args));
         }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketOutExUpdateWhitelist.java

@@ -1,45 +0,0 @@
-package net.ME1312.SubServers.Bungee.Network.Packet;
-
-import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
-import net.ME1312.SubData.Server.SubDataClient;
-
-import java.util.UUID;
-
-/**
- * Update External Whitelist Packet
- */
-public class PacketOutExUpdateWhitelist implements PacketObjectOut<Integer> {
-    private String name;
-    private boolean mode;
-    private UUID value;
-
-    /**
-     * New PacketOutExUpdateWhitelist
-     *
-     * @param name Server Name
-     * @param mode Update Mode (true for add, false for remove)
-     * @param value Whitelist Value
-     */
-    public PacketOutExUpdateWhitelist(String name, boolean mode, UUID value) {
-        if (Util.isNull(name, mode, value)) throw new NullPointerException();
-        this.name = name;
-        this.mode = mode;
-        this.value = value;
-    }
-
-    @Override
-    public ObjectMap<Integer> send(SubDataClient client) {
-        ObjectMap<Integer> data = new ObjectMap<Integer>();
-        data.set(0x0000, name);
-        data.set(0x0001, mode);
-        data.set(0x0002, value);
-        return data;
-    }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
-}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketRemoveServer.java

@@ -27,8 +27,7 @@ public class PacketRemoveServer implements PacketObjectIn<Integer>, PacketObject
      * @param plugin SubPlugin
      */
     public PacketRemoveServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -54,12 +53,12 @@ public class PacketRemoveServer implements PacketObjectIn<Integer>, PacketObject
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         UUID tracker =       (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String name = data.getRawString(0x0001);
+            String name = data.getString(0x0001);
             boolean force = data.getBoolean(0x0002);
             UUID player =    (data.contains(0x0003)?data.getUUID(0x0003):null);
 
             Map<String, Server> servers = plugin.api.getServers();
-            if (!servers.keySet().contains(name.toLowerCase())) {
+            if (!servers.containsKey(name.toLowerCase())) {
                 client.sendPacket(new PacketRemoveServer(3, tracker));
             } else if (!(servers.get(name.toLowerCase()) instanceof SubServer)) {
                 if (force) {
@@ -95,9 +94,4 @@ public class PacketRemoveServer implements PacketObjectIn<Integer>, PacketObject
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketRestartServer.java

@@ -26,8 +26,7 @@ public class PacketRestartServer implements PacketObjectIn<Integer>, PacketObjec
      * @param plugin SubPlugin
      */
     public PacketRestartServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -53,12 +52,12 @@ public class PacketRestartServer implements PacketObjectIn<Integer>, PacketObjec
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         UUID tracker =       (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String name = data.getRawString(0x0001);
+            String name = data.getString(0x0001);
             UUID player =    (data.contains(0x0002)?data.getUUID(0x0002):null);
 
             Runnable starter = () -> {
                 Map<String, Server> servers = plugin.api.getServers();
-                if (!servers.keySet().contains(name.toLowerCase())) {
+                if (!servers.containsKey(name.toLowerCase())) {
                 } else if (!(servers.get(name.toLowerCase()) instanceof SubServer)) {
                 } else if (!((SubServer) servers.get(name.toLowerCase())).getHost().isAvailable()) {
                 } else if (!((SubServer) servers.get(name.toLowerCase())).getHost().isEnabled()) {
@@ -72,7 +71,7 @@ public class PacketRestartServer implements PacketObjectIn<Integer>, PacketObjec
             };
 
             Map<String, Server> servers = plugin.api.getServers();
-            if (!servers.keySet().contains(name.toLowerCase())) {
+            if (!servers.containsKey(name.toLowerCase())) {
                 client.sendPacket(new PacketRestartServer(3, tracker));
             } else if (!(servers.get(name.toLowerCase()) instanceof SubServer)) {
                 client.sendPacket(new PacketRestartServer(4, tracker));
@@ -98,9 +97,4 @@ public class PacketRestartServer implements PacketObjectIn<Integer>, PacketObjec
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketStartServer.java

@@ -27,8 +27,7 @@ public class PacketStartServer implements PacketObjectIn<Integer>, PacketObjectO
      * @param plugin SubPlugin
      */
     public PacketStartServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -66,11 +65,11 @@ public class PacketStartServer implements PacketObjectIn<Integer>, PacketObjectO
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         UUID tracker =       (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String name = data.getRawString(0x0001);
+            String name = data.getString(0x0001);
             UUID player =    (data.contains(0x0002)?data.getUUID(0x0002):null);
 
             Map<String, Server> servers = plugin.api.getServers();
-            if (!servers.keySet().contains(name.toLowerCase())) {
+            if (!servers.containsKey(name.toLowerCase())) {
                 client.sendPacket(new PacketStartServer(3, tracker));
             } else if (!(servers.get(name.toLowerCase()) instanceof SubServer)) {
                 client.sendPacket(new PacketStartServer(4, tracker));
@@ -103,9 +102,4 @@ public class PacketStartServer implements PacketObjectIn<Integer>, PacketObjectO
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Network/Packet/PacketStopServer.java

@@ -26,8 +26,7 @@ public class PacketStopServer implements PacketObjectIn<Integer>, PacketObjectOu
      * @param plugin SubPlugin
      */
     public PacketStopServer(SubProxy plugin) {
-        if (Util.isNull(plugin)) throw new NullPointerException();
-        this.plugin = plugin;
+        this.plugin = Util.nullpo(plugin);
     }
 
     /**
@@ -53,12 +52,12 @@ public class PacketStopServer implements PacketObjectIn<Integer>, PacketObjectOu
     public void receive(SubDataClient client, ObjectMap<Integer> data) {
         UUID tracker =       (data.contains(0x0000)?data.getUUID(0x0000):null);
         try {
-            String name = data.getRawString(0x0001);
+            String name = data.getString(0x0001);
             boolean force =  (data.contains(0x0002)?data.getBoolean(0x0002):false);
             UUID player =    (data.contains(0x0003)?data.getUUID(0x0003):null);
 
             Map<String, Server> servers = plugin.api.getServers();
-            if (!name.equals("*") && !servers.keySet().contains(name.toLowerCase())) {
+            if (!name.equals("*") && !servers.containsKey(name.toLowerCase())) {
                 client.sendPacket(new PacketStopServer(3, tracker));
             } else if (!name.equals("*") && !(servers.get(name.toLowerCase()) instanceof SubServer)) {
                 client.sendPacket(new PacketStopServer(4, tracker));
@@ -68,44 +67,28 @@ public class PacketStopServer implements PacketObjectIn<Integer>, PacketObjectOu
                 boolean sent = false;
                 if (force) {
                     for (Server server : servers.values()) {
-                        if (server instanceof SubServer && ((SubServer) server).isRunning()) {
-                            if (((SubServer) server).terminate(player)) {
-                                sent = true;
-                            }
+                        if (server instanceof SubServer) {
+                            sent |= ((SubServer) server).terminate(player);
                         }
                     }
-                    if (sent) {
-                        client.sendPacket(new PacketStopServer(0, tracker));
-                    } else {
-                        client.sendPacket(new PacketStopServer(1, tracker));
-                    }
                 } else {
                     for (Server server : servers.values()) {
-                        if (server instanceof SubServer && ((SubServer) server).isRunning()) {
-                            if (((SubServer) server).stop(player)) {
-                                sent = true;
-                            }
+                        if (server instanceof SubServer) {
+                            sent |= ((SubServer) server).stop(player);
                         }
                     }
-                    if (sent) {
-                        client.sendPacket(new PacketStopServer(0, tracker));
-                    } else {
-                        client.sendPacket(new PacketStopServer(1, tracker));
-                    }
+                }
+
+                if (sent) {
+                    client.sendPacket(new PacketStopServer(0, tracker));
+                } else {
+                    client.sendPacket(new PacketStopServer(1, tracker));
                 }
             } else {
                 if (force) {
-                    if (((SubServer) servers.get(name.toLowerCase())).terminate(player)) {
-                        client.sendPacket(new PacketStopServer(0, tracker));
-                    } else {
-                        client.sendPacket(new PacketStopServer(1, tracker));
-                    }
+                    client.sendPacket(new PacketStopServer((((SubServer) servers.get(name.toLowerCase())).terminate(player))? 0 : 1, tracker));
                 } else {
-                    if (((SubServer) servers.get(name.toLowerCase())).stop(player)) {
-                        client.sendPacket(new PacketStopServer(0, tracker));
-                    } else {
-                        client.sendPacket(new PacketStopServer(1, tracker));
-                    }
+                    client.sendPacket(new PacketStopServer((((SubServer) servers.get(name.toLowerCase())).stop(player))? 0 : 1, tracker));
                 }
             }
         } catch (Throwable e) {
@@ -113,9 +96,4 @@ public class PacketStopServer implements PacketObjectIn<Integer>, PacketObjectOu
             e.printStackTrace();
         }
     }
-
-    @Override
-    public int version() {
-        return 0x0001;
-    }
 }