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.

Artifacts/SubServers.Patcher.sh

@@ -79,13 +79,13 @@ if [ $__RETURN -eq 0 ]
         fi
         yes | cp -rf . ../Patched.jar
         cd ../
-        printf "Built-By: SubServers.Bungee.Patcher\n" >> MANIFEST.MF
+        printf "Built-By: SubServers.Patcher\n" >> MANIFEST.MF
         cp -f MANIFEST.MF Patched.jar/META-INF
         if [ -f "Patched.jar/bungee.yml" ]; then
             rm -Rf Patched.jar/bungee.yml
         fi
         if [ ! -f "MODIFICATIONS" ]; then
-            printf "# SubServers.Bungee.Patcher generated difference list (may be empty if git is not installed)\n#\n" > MODIFICATIONS
+            printf "# SubServers.Patcher generated difference list (may be empty if git is not installed)\n#\n" > MODIFICATIONS
         fi
         printf "@ `date`\n> git --no-pager diff --no-index --name-status SubServers.Patcher/Original.jar SubServers.Patcher/Patched.jar\n" >> MODIFICATIONS
         git --no-pager diff --no-index --name-status Original.jar Patched.jar | sed -e "s/\tOriginal.jar\//\t\//" -e "s/\tPatched.jar\//\t\//" >> MODIFICATIONS

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

@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>net.ME1312.SubServers</groupId>
+    <artifactId>SubServers.Bungee.Common</artifactId>
+    <version>-PLACEHOLDER</version>
+    <packaging>jar</packaging>
+
+    <repositories>
+        <repository>
+            <id>md_5-repo</id>
+            <url>http://repo.md-5.net/content/repositories/snapshots/</url>
+        </repository>
+        <repository>
+            <id>me1312-repo</id>
+            <url>https://dev.me1312.net/maven</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>net.md_5</groupId>
+            <artifactId>bungeecord-internal</artifactId>
+            <version>1.15-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>net.ME1312.Galaxi</groupId>
+            <artifactId>GalaxiBase</artifactId>
+            <version>23w51a</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <directory>../../out/compile/target/SubServers.Bungee.Common</directory>
+        <sourceDirectory>src</sourceDirectory>
+        <resources>
+            <resource>
+                <directory>src</directory>
+                <excludes>
+                    <exclude>**/*.java</exclude>
+                </excludes>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.7.0</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <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

@@ -0,0 +1,137 @@
+package net.ME1312.SubServers.Bungee;
+
+import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.Galaxi.Library.Version.Version;
+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;
+
+/**
+ * SubAPI BungeeCord Common Class
+ */
+public interface BungeeAPI {
+
+    /**
+     * Gets the SubAPI BungeeCord Common Methods
+     *
+     * @return SubAPI BungeeCord Common
+     */
+    static BungeeAPI getInstance() {
+        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
+     *
+     * @return Remote Player Collection
+     */
+    int getRemotePlayerCount();
+
+    /**
+     * Get players on this server across all known proxies
+     *
+     * @param server Server to search
+     * @return Remote Player Map
+     */
+    Map<UUID, ? extends RemotePlayer> getRemotePlayers(ServerInfo server);
+
+    /**
+     * Get players on this network across all known proxies
+     *
+     * @return Remote Player Map
+     */
+    Map<UUID, ? extends RemotePlayer> getRemotePlayers();
+
+    /**
+     * Get a player on this network by searching across all known proxies
+     *
+     * @param name Player name
+     * @return Remote Player
+     */
+    RemotePlayer getRemotePlayer(String name);
+
+    /**
+     * Get a player on this network by searching across all known proxies
+     *
+     * @param id Player UUID
+     * @return Remote Player
+     */
+    RemotePlayer getRemotePlayer(UUID id);
+
+    /**
+     * Gets the current SubServers Lang Channels
+     *
+     * @return SubServers Lang Channel list
+     */
+    Collection<String> getLangChannels();
+
+    /**
+     * Gets values from the SubServers Lang
+     *
+     * @param channel Lang Channel
+     * @return Lang Value
+     */
+    Map<String, String> getLang(String channel);
+
+    /**
+     * Gets a value from the SubServers Lang
+     *
+     * @param channel Lang Channel
+     * @param key Key
+     * @return Lang Values
+     */
+    default String getLang(String channel, String key) {
+        Util.nullpo(channel, key);
+        return getLang(channel).get(key);
+    }
+
+    /**
+     * Gets the Runtime Directory
+     *
+     * @return Directory
+     */
+    File getRuntimeDirectory();
+
+    /**
+     * Gets the SubServers Version
+     *
+     * @return SubServers Version
+     */
+    Version getWrapperVersion();
+
+    /**
+     * Gets the SubServers Build Version
+     *
+     * @return SubServers Build Version (or null if unsigned)
+     */
+    Version getWrapperBuild();
+
+    /**
+     * Gets the BungeeCord Version
+     *
+     * @return BungeeCord Version
+     */
+    Version getProxyVersion();
+
+    /**
+     * Get an array of compatible Minecraft Versions
+     *
+     * @return Minecraft Versions
+     */
+    Version[] getGameVersion();
+}

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

@@ -0,0 +1,49 @@
+package net.ME1312.SubServers.Bungee;
+
+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.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 Supplier<BungeeAPI> api;
+    protected final Collection<Channel> listeners;
+
+    protected BungeeCommon(Supplier<BungeeAPI> api) throws Exception {
+        listeners= Util.reflect(BungeeCord.class.getDeclaredField("listeners"), this);
+        this.api = api;
+        instance = this;
+    }
+
+    /**
+     * Get the name from BungeeCord's original signature (for determining which fork is being used)
+     *
+     * @return BungeeCord Software Name
+     */
+    public abstract String getBungeeName();
+
+    /**
+     * Waterfall's getServersCopy()
+     *
+     * @return Server Map Copy
+     */
+    public abstract Map<String, ServerInfo> getServersCopy();
+
+    /**
+     * Gets the ProxyServer Common Object
+     *
+     * @return ProxyServer Common
+     */
+    public static BungeeCommon getInstance() {
+        return instance;
+    }
+}

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

@@ -0,0 +1,39 @@
+package net.ME1312.SubServers.Bungee.Library.Compatibility;
+
+import net.ME1312.SubServers.Bungee.BungeeCommon;
+
+import java.util.HashMap;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+
+/**
+ * Logger Compatibility Class
+ */
+public class Logger {
+    private static final HashMap<String, java.util.logging.Logger> existing = new HashMap<String, java.util.logging.Logger>();
+
+    /**
+     * Get a logger
+     *
+     * @param prefix Prefix
+     * @return Logger
+     */
+    public static java.util.logging.Logger get(String prefix) {
+        if (!existing.containsKey(prefix)) {
+            java.util.logging.Logger log = java.util.logging.Logger.getAnonymousLogger();
+                log.setUseParentHandlers(false);
+                log.addHandler(new Handler() {
+                    @Override
+                    public void publish(LogRecord record) {
+                        BungeeCommon.getInstance().getLogger().log(record.getLevel(), prefix + " > " + record.getMessage(), record.getParameters());
+                    }
+
+                    @Override
+                    public void flush() {}
+                    public void close() {}
+                });
+            existing.put(prefix, log);
+        }
+        return existing.get(prefix);
+    }
+}

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

@@ -0,0 +1,460 @@
+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.
+     *
+     * @return the UUID
+     */
+    UUID getUniqueId();
+
+    /**
+     * Get the unique name of this player.
+     *
+     * @return the player's username
+     */
+    String getName();
+
+    /**
+     * Gets the remote address of this connection.
+     *
+     * @return the remote address
+     */
+    InetSocketAddress getAddress();
+
+    /**
+     * Gets the name of the proxy this player is connected to.
+     *
+     * @return the name of the proxy this player is connected to
+     */
+    String getProxyName();
+
+    /**
+     * Gets the name of the server this player is connected to.
+     *
+     * @return the name of the server this player is connected to
+     */
+    String getServerName();
+
+    /**
+     * Gets the server this player is connected to.
+     *
+     * @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/FallbackState.java

@@ -0,0 +1,72 @@
+package net.ME1312.SubServers.Bungee.Library.Fallback;
+
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.api.config.ServerInfo;
+
+import java.util.*;
+
+/**
+ * Fallback Player State Class
+ */
+public class FallbackState {
+    public final UUID player;
+    public final LinkedList<String> names;
+    public final LinkedList<ServerInfo> servers;
+    public final BaseComponent[] reason;
+    private Map<String, ServerInfo> map;
+    private Timer finish;
+
+    /**
+     * Smart Fallback State Container
+     *
+     * @param player Player
+     * @param servers Fallback Servers
+     * @param reason Original Disconnect Reason
+     */
+    public FallbackState(UUID player, Map<String, ServerInfo> servers, BaseComponent... reason) {
+        this.player = player;
+        this.map = servers;
+        this.names = new LinkedList<>(servers.keySet());
+        this.servers = new LinkedList<>(servers.values());
+        this.reason = reason;
+    }
+
+    /**
+     * <i>Use</i> a server
+     *
+     * @param name Server name to remove
+     */
+    public void remove(String name) {
+        servers.remove(map.get(name));
+        names.remove(name);
+        map.remove(name);
+    }
+
+    /**
+     * <i>Use</i> a server
+     *
+     * @param server Server to remove
+     */
+    public void remove(ServerInfo server) {
+        map.remove(server.getName());
+        names.remove(server.getName());
+        servers.remove(server);
+    }
+
+    /**
+     * Finish the process
+     *
+     * @param callback Finishing callback
+     * @param delay Delay for determining stability
+     */
+    public void done(Runnable callback, long delay) {
+        if (finish != null) finish.cancel();
+        (finish = new Timer("SubServers.Bungee::Fallback_Limbo_Timer(" + player + ')')).schedule(new TimerTask() {
+            @Override
+            public void run() {
+                if (callback != null) callback.run();
+                finish.cancel();
+            }
+        }, delay);
+    }
+}

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

@@ -1,9 +1,10 @@
 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.Host.Server;
-import net.ME1312.SubServers.Bungee.Host.SubServer;
-import net.ME1312.SubServers.Bungee.SubAPI;
+import net.ME1312.SubServers.Bungee.BungeeCommon;
+
 import net.md_5.bungee.UserConnection;
 import net.md_5.bungee.api.AbstractReconnectHandler;
 import net.md_5.bungee.api.ProxyServer;
@@ -22,19 +23,34 @@ import java.util.concurrent.CopyOnWriteArrayList;
  */
 public class SmartFallback implements ReconnectHandler {
     private static List<FallbackInspector> inspectors = new CopyOnWriteArrayList<FallbackInspector>();
+    private static ReconnectHandler reconnect;
+    public static boolean dns_forward = false;
+
+    public SmartFallback(ObjectMap<String> settings) {
+        dns_forward = settings.getBoolean("DNS-Forward", false);
+        if (reconnect == null && settings.getBoolean("Reconnect", false))
+            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
     public ServerInfo getServer(ProxiedPlayer player) {
-        ServerInfo forced = getForcedHost(player.getPendingConnection());
-        if (forced != null) {
-            return forced;
+        return getServer(player, player instanceof UserConnection);
+    }
+
+    protected ServerInfo getServer(ProxiedPlayer player, boolean queue) {
+        ServerInfo override;
+        if ((override = getForcedHost(player.getPendingConnection())) != null
+                || (override = getDNS(player.getPendingConnection())) != null) {
+            if (queue) ((UserConnection) player).setServerJoinQueue(new LinkedList<>());
+            return override;
         } else {
             Map<String, ServerInfo> fallbacks = getFallbackServers(player.getPendingConnection().getListener(), player);
-            if (fallbacks.isEmpty()) {
-                return null;
+
+            if ((override = getReconnectServer(player)) != null || !fallbacks.isEmpty()) {
+                if (queue) ((UserConnection) player).setServerJoinQueue(new LinkedList<>(fallbacks.keySet()));
+                return (override != null)? override : new LinkedList<>(fallbacks.values()).getFirst();
             } else {
-                if (player instanceof UserConnection) ((UserConnection) player).setServerJoinQueue(new LinkedList<>(fallbacks.keySet()));
-                return new LinkedList<Map.Entry<String, ServerInfo>>(fallbacks.entrySet()).getFirst().getValue();
+                return null;
             }
         }
     }
@@ -59,6 +75,45 @@ public class SmartFallback implements ReconnectHandler {
         }
     }
 
+    /**
+     * Grabs the Server that a connection's DNS matches
+     *
+     * @param connection Connection to check
+     * @return DNS Forward Server
+     */
+    public static ServerInfo getDNS(PendingConnection connection) {
+        if (connection.getVirtualHost() == null || !dns_forward) {
+            return null;
+        } else {
+            Map.Entry<String, ServerInfo> server = null;
+            String dns = connection.getVirtualHost().getHostString().toLowerCase();
+            for (Map.Entry<String, ServerInfo> s : ((BungeeCommon) ProxyServer.getInstance()).getServersCopy().entrySet()) {
+                if (dns.startsWith(s.getKey().toLowerCase() + '.'))
+                    if (server == null || server.getKey().length() < s.getKey().length())
+                        server = s;
+            }
+
+            return (server == null)?null:server.getValue();
+        }
+    }
+
+    /**
+     * Grabs the Server that a player was last connected to
+     *
+     * @param player Player
+     * @return Reconnect Server
+     */
+    public static ServerInfo getReconnectServer(ProxiedPlayer player) {
+        if (reconnect == null) {
+            return null;
+        } else try {
+            return Util.reflect(reconnect.getClass().getDeclaredMethod("getStoredServer", ProxiedPlayer.class), reconnect, player);
+        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
     /**
      * Generates a <i>smart</i> sorted map of fallback servers using a generated confidence score
      *
@@ -79,22 +134,10 @@ public class SmartFallback implements ReconnectHandler {
     public static Map<String, ServerInfo> getFallbackServers(ListenerInfo listener, ProxiedPlayer player) {
         TreeMap<Double, List<ServerInfo>> score = new TreeMap<Double, List<ServerInfo>>(Collections.reverseOrder());
         for (String name : listener.getServerPriority()) {
-            ServerInfo server = SubAPI.getInstance().getServer(name.toLowerCase());
-            if (server == null) server = ProxyServer.getInstance().getServerInfo(name);
+            ServerInfo server = ProxyServer.getInstance().getServerInfo(name);
             if (server != null) {
                 boolean valid = true;
                 double confidence = 0;
-                if (server instanceof Server) {
-                    if (!((Server) server).isHidden()) confidence++;
-                    if (!((Server) server).isRestricted()) confidence++;
-                    if (((Server) server).getSubData()[0] != null) confidence++;
-
-                    if (player != null) {
-                        if (((Server) server).canAccess(player)) confidence++;
-                    }
-                } if (server instanceof SubServer) {
-                    if (!((SubServer) server).isRunning()) valid = false;
-                }
 
                 List<FallbackInspector> inspectors = new ArrayList<FallbackInspector>();
                 inspectors.addAll(SmartFallback.inspectors);
@@ -110,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);
                 }
@@ -135,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);
     }
 
@@ -145,22 +188,22 @@ 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
     public void setServer(ProxiedPlayer player) {
-        // Ignore server switching
+        if (reconnect != null) reconnect.setServer(player);
     }
 
     @Override
     public void save() {
-        // Nothing to save
+        if (reconnect != null) reconnect.save();
     }
 
     @Override
     public void close() {
-        // Nothing to close
+        if (reconnect != null) reconnect.close();
     }
 }

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

@@ -1,7 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>net.ME1312.SubServers</groupId>
@@ -28,37 +26,22 @@
             <scope>provided</scope>
         </dependency>
         <dependency>
-            <groupId>net.ME1312.Galaxi</groupId>
-            <artifactId>GalaxiUtil</artifactId>
-            <version>20w15a</version>
+            <groupId>net.ME1312.SubServers</groupId>
+            <artifactId>SubServers.Bungee.Common</artifactId>
+            <version>${project.version}</version>
             <scope>compile</scope>
-            <optional>true</optional>
-        </dependency>
-        <dependency>
-            <groupId>net.ME1312.Galaxi</groupId>
-            <artifactId>GalaxiEngine</artifactId>
-            <version>20w15a</version>
-            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>net.ME1312.SubData</groupId>
             <artifactId>Server</artifactId>
-            <version>20w15a</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>
-        <dependency>
-            <groupId>com.imaginarycode.minecraft</groupId>
-            <artifactId>RedisBungee</artifactId>
-            <version>0.3.8-SNAPSHOT</version>
-            <scope>provided</scope>
         </dependency>
     </dependencies>
 
@@ -97,14 +80,14 @@
                             <tasks>
                                 <mkdir dir="${project.build.directory}" />
                                 <copy file="${basedir}/../LICENSE" todir="${project.build.directory}/classes" />
-                                <mkdir dir="${basedir}/../Artifacts/-Lite" />
-                                <copy file="${basedir}/../Artifacts/SubServers.Client.jar" tofile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/client.jar" />
+                                <mkdir dir="${basedir}/../Artifacts/Modulized" />
+                                <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/src" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/forge.zip" includes="Forge/**" />
-                                <zip basedir="${basedir}/../SubServers.Creator/src" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/paper.zip" includes="Paper/**" />
-                                <zip basedir="${basedir}/../SubServers.Creator/src" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/spigot.zip" includes="Spigot/**" />
-                                <zip basedir="${basedir}/../SubServers.Creator/src" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/sponge.zip" includes="Sponge/**" />
-                                <zip basedir="${basedir}/../SubServers.Creator/src" destfile="${project.build.directory}/classes/net/ME1312/SubServers/Bungee/Library/Files/Templates/vanilla.zip" includes="Vanilla/**" />
+                                <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/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/**" />
                             </tasks>
                         </configuration>
                     </execution>
@@ -116,7 +99,7 @@
                         </goals>
                         <configuration>
                             <tasks> <!-- Dependency Stripped Jar for Testing -->
-                                <jar destfile="${basedir}/../Artifacts/-Lite/SubServers.Bungee.jar" manifest="src/META-INF/MANIFEST.MF">
+                                <jar destfile="${basedir}/../Artifacts/Modulized/SubServers.Bungee.jar" manifest="src/META-INF/MANIFEST.MOD.MF">
                                     <zipfileset src="${basedir}/../Artifacts/SubServers.Bungee.jar" excludes="net/ME1312/Galaxi/** net/ME1312/SubData/**" />
                                 </jar>
                             </tasks>
@@ -124,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>
@@ -134,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>
@@ -160,18 +152,22 @@
                             <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>
+                            <includeDependencySources>true</includeDependencySources>
+                            <dependencySourceIncludes>
+                                <dependencySourceInclude>net.ME1312.SubServers:SubServers.Bungee.Common:*</dependencySourceInclude>
+                            </dependencySourceIncludes>
                         </configuration>
                     </execution>
                 </executions>

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

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

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

@@ -0,0 +1,4 @@
+Manifest-Version: 1.0
+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

@@ -1,8 +1,9 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -23,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

@@ -1,8 +1,9 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.Proxy;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Event;
 
 /**
@@ -17,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

@@ -1,9 +1,10 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.Host.Server;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -26,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

@@ -1,11 +1,12 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.Galaxi.Library.Version.Version;
 import net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.Host.SubCreator;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.Galaxi.Library.Version.Version;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -35,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;
@@ -49,15 +50,16 @@ public class SubCreateEvent extends Event implements SubEvent, Cancellable {
      *
      * @param player Player Updating
      * @param server Server to be Updated
+     * @param template Server Template
      * @param version Server Version
      */
-    public SubCreateEvent(UUID player, SubServer server, Version version) {
-        if (Util.isNull(server)) throw new NullPointerException();
+    public SubCreateEvent(UUID player, SubServer server, SubCreator.ServerTemplate template, Version version) {
+        Util.nullpo(server);
         this.player = player;
         this.update = server;
         this.name = server.getName();
         this.host = server.getHost();
-        this.template = server.getTemplate();
+        this.template = template;
         this.version = version;
         this.port = server.getAddress().getPort();
     }

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

@@ -6,6 +6,7 @@ import net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.Host.SubCreator;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
+
 import net.md_5.bungee.api.plugin.Event;
 
 import java.util.UUID;
@@ -38,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

@@ -1,11 +1,13 @@
 package net.ME1312.SubServers.Bungee.Event;
 
-import net.ME1312.SubServers.Bungee.Host.Server;
+import net.ME1312.Galaxi.Library.Container.ContainedPair;
+import net.ME1312.Galaxi.Library.Container.Pair;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
-import net.ME1312.SubServers.Bungee.Library.SubEvent;
 import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubServers.Bungee.Host.Server;
+import net.ME1312.SubServers.Bungee.Library.SubEvent;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -18,8 +20,7 @@ public class SubEditServerEvent extends Event implements SubEvent, Cancellable {
     private boolean cancelled = false;
     private UUID player;
     private Server server;
-    private NamedContainer<String, ObjectMapValue> edit;
-    private boolean perm;
+    private Pair<String, ObjectMapValue> edit;
 
     /**
      * Server Edit Event
@@ -27,16 +28,14 @@ public class SubEditServerEvent extends Event implements SubEvent, Cancellable {
      * @param player Player Adding Server
      * @param server Server to be Edited
      * @param edit Edit to make
-     * @param permanent If the change is permanent
      */
-    public SubEditServerEvent(UUID player, Server server, NamedContainer<String, ?> edit, boolean permanent) {
-        if (Util.isNull(server, edit)) throw new NullPointerException();
+    public SubEditServerEvent(UUID player, Server server, Pair<String, ?> edit) {
+        Util.nullpo(server, edit);
         ObjectMap<String> section = new ObjectMap<String>();
-        section.set(".", edit.get());
+        section.set(".", edit.value());
         this.player = player;
         this.server = server;
-        this.edit = new NamedContainer<String, ObjectMapValue>(edit.name(), section.get("."));
-        this.perm = permanent;
+        this.edit = new ContainedPair<String, ObjectMapValue>(edit.key(), section.get("."));
     }
 
     /**
@@ -58,19 +57,10 @@ public class SubEditServerEvent extends Event implements SubEvent, Cancellable {
      *
      * @return Edit to be made
      */
-    public NamedContainer<String, ObjectMapValue> getEdit() {
+    public Pair<String, ObjectMapValue> getEdit() {
         return edit;
     }
 
-    /**
-     * Gets if the edit is permanent
-     *
-     * @return Permanent Status
-     */
-    public boolean isPermanent() {
-        return perm;
-    }
-
     /**
      * Gets the Cancelled Status
      *

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

@@ -1,16 +1,13 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.DataClient;
 import net.ME1312.SubData.Server.DataServer;
-import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubData.Server.SubDataServer;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
-import java.net.InetAddress;
-
 /**
  * SubData Network Connect Event
  */
@@ -23,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

@@ -1,12 +1,11 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.DataClient;
 import net.ME1312.SubData.Server.DataServer;
 import net.ME1312.SubData.Server.Library.DisconnectReason;
-import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubData.Server.SubDataServer;
+
 import net.md_5.bungee.api.plugin.Event;
 
 /**
@@ -21,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

@@ -4,7 +4,7 @@ import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.DataClient;
 import net.ME1312.SubData.Server.DataServer;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.md_5.bungee.api.plugin.Cancellable;
+
 import net.md_5.bungee.api.plugin.Event;
 
 /**
@@ -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

@@ -1,8 +1,9 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -23,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

@@ -1,8 +1,9 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.Proxy;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Event;
 
 /**
@@ -17,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

@@ -1,9 +1,10 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.Host.Server;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -26,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,8 +1,9 @@
 package net.ME1312.SubServers.Bungee.Event;
 
-import net.ME1312.SubServers.Bungee.Host.SubServer;
-import net.ME1312.SubServers.Bungee.Library.SubEvent;
 import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubServers.Bungee.Host.Server;
+import net.ME1312.SubServers.Bungee.Library.SubEvent;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -14,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;
     }
 
     /**
@@ -35,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
@@ -62,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

@@ -1,8 +1,9 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -23,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

@@ -3,10 +3,8 @@ package net.ME1312.SubServers.Bungee.Event;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.md_5.bungee.api.plugin.Cancellable;
-import net.md_5.bungee.api.plugin.Event;
 
-import java.util.UUID;
+import net.md_5.bungee.api.plugin.Event;
 
 /**
  * Server Started Event
@@ -21,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

@@ -1,8 +1,9 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Cancellable;
 import net.md_5.bungee.api.plugin.Event;
 
@@ -25,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

@@ -1,8 +1,9 @@
 package net.ME1312.SubServers.Bungee.Event;
 
+import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.Library.SubEvent;
-import net.ME1312.Galaxi.Library.Util;
+
 import net.md_5.bungee.api.plugin.Event;
 
 /**
@@ -17,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,70 +1,87 @@
 package net.ME1312.SubServers.Bungee.Host;
 
-import net.ME1312.SubServers.Bungee.Library.Compatibility.JNA;
+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.util.stream.Stream;
 
 /**
  * Executable Handler Class
  */
 public class Executable {
     private Executable() {}
+    private static final boolean USE_SESSION_TRACKING;
 
     /**
      * Format a command to be executed
      *
      * @param gitbash Git Bash location (optional)
      * @param exec Executable String
-     * @return
+     * @return Formatted Executable
      */
     public static String[] parse(String gitbash, String exec) {
-        if (exec.startsWith("java ")) {
+        if (exec.startsWith("java "))
             exec = '\"' + System.getProperty("java.home") + File.separator + "bin" + File.separator + "java" + '\"' + exec.substring(4);
-        }
 
         String[] cmd;
-        if (System.getProperty("os.name").toLowerCase().startsWith("windows")) {
+        if (Platform.getSystem() == Platform.WINDOWS) {
             if (gitbash != null && (exec.toLowerCase().startsWith("bash ") || exec.toLowerCase().startsWith("sh ")))
                 exec = '"' + gitbash + ((gitbash.endsWith(File.separator))?"":File.separator) + "bin" + File.separatorChar + "sh.exe\" -lc \"" +
                         exec.replace("\\", "/\\").replace("\"", "\\\"").replace("^", "^^").replace("%", "^%").replace("&", "^&").replace("<", "^<").replace(">", "^>").replace("|", "^|") + '"';
             cmd = new String[]{"cmd.exe", "/q", "/c", '"'+exec+'"'};
+        } else if (USE_SESSION_TRACKING) {
+            cmd = new String[]{"setsid", "sh", "-lc", exec};
         } else {
             cmd = new String[]{"sh", "-lc", exec};
         }
         return cmd;
     }
 
+    static {
+        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;
+        }, false);
+    }
+
     /**
      * Get the PID of a currently running process
      *
      * @param process Process
      * @return Process ID (null if unknown)
      */
+    @SuppressWarnings("JavaReflectionMemberAccess")
     public static Long pid(Process process) {
         if (process.isAlive()) {
-            try {
-                return (long) Process.class.getDeclaredMethod("pid").invoke(process);
-            } catch (Throwable ex) {
-                try {
-                    if (process.getClass().getName().equals("java.lang.Win32Process") || process.getClass().getName().equals("java.lang.ProcessImpl")) {
+            try { // Java 9 Standard
+                return (long) Process.class.getMethod("pid").invoke(process);
+            } catch (Throwable e) {
+                try { // Java 8 Not-so-standard
+                    Object response = Util.reflect(process.getClass().getDeclaredField("pid"), process);
+
+                    if (response instanceof Number) {
+                        return ((Number) response).longValue();
+                    } else throw e;
+                } catch (Throwable e2) {
+                    if (Platform.getSystem() == Platform.WINDOWS) try {
                         long handle = Util.reflect(process.getClass().getDeclaredField("handle"), process);
 
                         ClassLoader jna = JNA.get();
                         Class<?> pc = jna.loadClass("com.sun.jna.Pointer"),
                                 ntc = jna.loadClass("com.sun.jna.platform.win32.WinNT$HANDLE"),
-                                k32c = jna.loadClass("com.sun.jna.platform.win32.Kernel32");
+                               k32c = jna.loadClass("com.sun.jna.platform.win32.Kernel32");
                         Object k32 = k32c.getField("INSTANCE").get(null),
                                 nt = ntc.getConstructor().newInstance();
                         ntc.getMethod("setPointer", pc).invoke(nt, pc.getMethod("createConstant", long.class).invoke(null, handle));
                         return ((Number) k32c.getMethod("GetProcessId", ntc).invoke(k32, nt)).longValue();
-                    } else if (process.getClass().getName().equals("java.lang.UNIXProcess")) {
-                        Object response = Util.reflect(process.getClass().getDeclaredField("pid"), process);
-
-                        if (response instanceof Number)
-                            return ((Number) response).longValue();
+                    } catch (Throwable e3) {
+                        // No way to find pid, I suppose.
                     }
-                } catch (Throwable e) {}
+                }
             }
         }
         return null;
@@ -77,14 +94,28 @@ public class Executable {
      */
     public static void terminate(Process process) {
         if (process.isAlive()) {
-            if (System.getProperty("os.name").toLowerCase().startsWith("windows")) {
-                Long pid = pid(process);
-                if (pid != null) try {
-                    Process terminator = Runtime.getRuntime().exec(new String[]{"taskkill.exe", "/T", "/F", "/PID", pid.toString()});
-                    terminator.waitFor();
-                } catch (Throwable 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()) process.destroyForcibly();
+
+            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,8 @@
 package net.ME1312.SubServers.Bungee.Host.External;
 
-import com.google.common.collect.Range;
+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;
 import net.ME1312.SubData.Server.Protocol.PacketOut;
@@ -10,16 +12,15 @@ import net.ME1312.SubServers.Bungee.Event.SubRemoveServerEvent;
 import net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.Host.SubCreator;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
-import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
-import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Network.Packet.PacketExAddServer;
 import net.ME1312.SubServers.Bungee.Network.Packet.PacketExDeleteServer;
 import net.ME1312.SubServers.Bungee.Network.Packet.PacketExRemoveServer;
 import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExReset;
 import net.ME1312.SubServers.Bungee.SubProxy;
-import net.md_5.bungee.BungeeCord;
+
+import com.google.common.collect.Range;
 
 import java.net.InetAddress;
 import java.util.*;
@@ -69,17 +70,18 @@ public class ExternalHost extends Host implements ClientHandler {
 
     @Override
     public DataClient[] getSubData() {
-        LinkedList<Integer> keys = new LinkedList<Integer>(subdata.keySet());
-        LinkedList<SubDataClient> channels = new LinkedList<SubDataClient>();
-        Collections.sort(keys);
-        for (Integer channel : keys) channels.add(subdata.get(channel));
-        return channels.toArray(new DataClient[0]);
+        Integer[] keys = subdata.keySet().toArray(new Integer[0]);
+        DataClient[] channels = new DataClient[keys.length];
+        Arrays.sort(keys);
+        for (int i = 0; i < keys.length; ++i) channels[i] = subdata.get(keys[i]);
+        return channels;
     }
 
     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(server.getName(), server.isEnabled(), server.getAddress().getPort(), server.isLogging(), server.getPath(), ((ExternalSubServer) server).exec, server.getStopCommand(), (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,42 +173,52 @@ 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
-    public SubServer addSubServer(UUID player, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException {
-        if (plugin.api.getServers().keySet().contains(name.toLowerCase())) throw new InvalidServerException("A Server already exists with this name!");
-        ExternalSubServer server = ExternalSubServer.construct(this, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
+    public SubServer constructSubServer(String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException {
+        return ExternalSubServer.construct(this, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
+    }
+
+    @Override
+    public boolean addSubServer(UUID player, SubServer server) throws InvalidServerException {
+        if (server.getHost() != this) throw new IllegalArgumentException("That Server does not belong to this Host!");
+        if (plugin.api.getServers().containsKey(server.getName().toLowerCase())) throw new InvalidServerException("A Server already exists with this name!");
         SubAddServerEvent event = new SubAddServerEvent(player, this, server);
         plugin.getPluginManager().callEvent(event);
         if (!event.isCancelled()) {
-            queue(new PacketExAddServer(name, enabled, port, log, directory, executable, stopcmd, (server.isRunning())?((ExternalSubLogger) server.getLogger()).getExternalAddress():null, data -> {
-                if (data.contains(0x0002)) server.started(data.getUUID(0x0002));
+            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);
             }));
-            servers.put(name.toLowerCase(), server);
-            return server;
+            servers.put(server.getName().toLowerCase(), server);
+            return true;
         } else {
-            return null;
+            return false;
         }
     }
 
     @Override
-    public boolean removeSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        SubServer server = servers.get(name.toLowerCase());
+    protected boolean removeSubServer(UUID player, String name, boolean forced) throws InterruptedException {
+        Util.nullpo(name);
+        ExternalSubServer server = (ExternalSubServer) servers.get(name.toLowerCase());
 
         SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, server);
         plugin.getPluginManager().callEvent(event);
-        if (!event.isCancelled()) {
+        if (forced || !event.isCancelled()) {
+            server.registered(false);
             if (server.isRunning()) {
                 server.stop();
                 server.waitFor();
             }
+
+            servers.remove(name.toLowerCase());
             queue(new PacketExRemoveServer(name.toLowerCase(), data -> {
-                if (data.getInt(0x0001) == 0 || data.getInt(0x0001) == 1) {
-                    servers.remove(name.toLowerCase());
+                if (data.getInt(0x0001) != 0 && data.getInt(0x0001) != 1) {
+                    server.registered(true);
+                    servers.put(name.toLowerCase(), server);
                 }
             }));
             return true;
@@ -203,33 +226,15 @@ public class ExternalHost extends Host implements ClientHandler {
     }
 
     @Override
-    public boolean forceRemoveSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        SubServer server = servers.get(name.toLowerCase());
-
-        SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, server);
-        plugin.getPluginManager().callEvent(event);
-        if (server.isRunning()) {
-            server.stop();
-            server.waitFor();
-        }
-        queue(new PacketExRemoveServer(name.toLowerCase(), data -> {
-            if (data.getInt(0x0001) == 0 || data.getInt(0x0001) == 1) {
-                servers.remove(name.toLowerCase());
-            }
-        }));
-        return true;
-    }
-
-    @Override
-    public boolean recycleSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        SubServer s = servers.get(name.toLowerCase());
+    protected boolean recycleSubServer(UUID player, String name, boolean forced) throws InterruptedException {
+        Util.nullpo(name);
+        ExternalSubServer s = (ExternalSubServer) servers.get(name.toLowerCase());
         String server = s.getName();
 
         SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, s);
         plugin.getPluginManager().callEvent(event);
-        if (!event.isCancelled()) {
+        if (forced || !event.isCancelled()) {
+            s.registered(false);
             if (s.isRunning()) {
                 s.stop();
                 s.waitFor();
@@ -254,6 +259,7 @@ public class ExternalHost extends Host implements ClientHandler {
                     servers.remove(server.toLowerCase());
                     Logger.get("SubServers").info("Deleted SubServer: " + server);
                 } else {
+                    s.registered(true);
                     Logger.get("SubServers").info("Couldn't remove " + server + " from memory. See " + getName() + " console for more details");
                 }
             }));
@@ -262,52 +268,15 @@ public class ExternalHost extends Host implements ClientHandler {
     }
 
     @Override
-    public boolean forceRecycleSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        SubServer s = servers.get(name.toLowerCase());
-        String server = s.getName();
-
-        SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, s);
-        plugin.getPluginManager().callEvent(event);
-        if (s.isRunning()) {
-            s.stop();
-            s.waitFor();
-        }
-
-        Logger.get("SubServers").info("Saving...");
-        ObjectMap<String> info = (plugin.servers.get().getMap("Servers").getKeys().contains(server))?plugin.servers.get().getMap("Servers").getMap(server).clone():new ObjectMap<String>();
-        info.set("Name", server);
-        info.set("Timestamp", Calendar.getInstance().getTime().getTime());
-        try {
-            if (plugin.servers.get().getMap("Servers").getKeys().contains(server)) {
-                plugin.servers.get().getMap("Servers").remove(server);
-                plugin.servers.save();
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        Logger.get("SubServers").info("Moving Files...");
-        queue(new PacketExDeleteServer(server, info, true, data -> {
-            if (data.getInt(0x0001) == 0 || data.getInt(0x0001) == 1) {
-                servers.remove(server.toLowerCase());
-                Logger.get("SubServers").info("Deleted SubServer: " + server);
-            } else {
-                Logger.get("SubServers").info("Couldn't remove " + server + " from memory. See " + getName() + " console for more details");
-            }
-        }));
-        return true;
-    }
-
-    @Override
-    public boolean deleteSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        SubServer s = servers.get(name.toLowerCase());
+    protected boolean deleteSubServer(UUID player, String name, boolean forced) throws InterruptedException {
+        Util.nullpo(name);
+        ExternalSubServer s = (ExternalSubServer) servers.get(name.toLowerCase());
         String server = s.getName();
 
         SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, getSubServer(server));
         plugin.getPluginManager().callEvent(event);
-        if (!event.isCancelled()) {
+        if (forced || !event.isCancelled()) {
+            s.registered(false);
             if (s.isRunning()) {
                 s.stop();
                 s.waitFor();
@@ -332,6 +301,7 @@ public class ExternalHost extends Host implements ClientHandler {
                     servers.remove(server.toLowerCase());
                     Logger.get("SubServers").info("Deleted SubServer: " + server);
                 } else {
+                    s.registered(true);
                     Logger.get("SubServers").info("Couldn't remove " + server + " from memory. See " + getName() + " console for more details");
                 }
             }));
@@ -339,47 +309,9 @@ public class ExternalHost extends Host implements ClientHandler {
         } else return false;
     }
 
-    @Override
-    public boolean forceDeleteSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        SubServer s = servers.get(name.toLowerCase());
-        String server = s.getName();
-
-        SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, getSubServer(server));
-        plugin.getPluginManager().callEvent(event);
-        if (s.isRunning()) {
-            s.stop();
-            s.waitFor();
-        }
-
-        Logger.get("SubServers").info("Saving...");
-        ObjectMap<String> info = (plugin.servers.get().getMap("Servers").getKeys().contains(server))?plugin.servers.get().getMap("Servers").getMap(server).clone():new ObjectMap<String>();
-        info.set("Name", server);
-        info.set("Timestamp", Calendar.getInstance().getTime().getTime());
-        try {
-            if (plugin.servers.get().getMap("Servers").getKeys().contains(server)) {
-                plugin.servers.get().getMap("Servers").remove(server);
-                plugin.servers.save();
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        Logger.get("SubServers").info("Removing Files...");
-        queue(new PacketExDeleteServer(server, info, false, data -> {
-            if (data.getInt(0x0001) == 0 || data.getInt(0x0001) == 1) {
-                servers.remove(server.toLowerCase());
-                Logger.get("SubServers").info("Deleted SubServer: " + server);
-            } else {
-                Logger.get("SubServers").info("Couldn't remove " + server + " from memory. See " + getName() + " console for more details");
-            }
-        }));
-        return true;
-    }
-
     @Override
     public boolean destroy() {
-        if (Util.getDespiteException(() -> Util.reflect(BungeeCord.class.getDeclaredField("isRunning"), 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,17 +1,22 @@
 package net.ME1312.SubServers.Bungee.Host.External;
 
-import com.google.common.collect.Range;
-import net.ME1312.Galaxi.Library.*;
-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.NamedContainer;
+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.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.Galaxi.Library.Config.YAMLConfig;
-import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.Galaxi.Library.Version.Version;
+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;
 import net.ME1312.SubServers.Bungee.Network.Packet.PacketExCreateServer;
@@ -19,12 +24,15 @@ import net.ME1312.SubServers.Bungee.Network.Packet.PacketExDownloadTemplates;
 import net.ME1312.SubServers.Bungee.Network.Packet.PacketExUploadTemplates;
 import net.ME1312.SubServers.Bungee.SubAPI;
 import net.ME1312.SubServers.Bungee.SubProxy;
+
+import com.google.common.collect.Range;
 import net.md_5.bungee.api.ChatColor;
 
 import java.io.File;
 import java.lang.reflect.InvocationTargetException;
 import java.net.InetSocketAddress;
 import java.util.*;
+import java.util.function.Consumer;
 
 /**
  * External SubCreator Class
@@ -36,9 +44,9 @@ public class ExternalSubCreator extends SubCreator {
     private Boolean enableRT = false;
     private ExternalHost host;
     private Range<Integer> ports;
-    private Container<Boolean> log;
+    private Value<Boolean> log;
     private String gitBash;
-    private TreeMap<String, NamedContainer<Integer, ExternalSubLogger>> thread;
+    private TreeMap<String, Pair<Integer, ExternalSubLogger>> thread;
 
     /**
      * Creates an External SubCreator
@@ -50,58 +58,58 @@ 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);
         this.gitBash = gitBash;
-        this.thread = new TreeMap<String, NamedContainer<Integer, ExternalSubLogger>>();
+        this.thread = new TreeMap<String, Pair<Integer, ExternalSubLogger>>();
         reload();
     }
 
     @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 = new ServerTemplate(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);
                 port = Util.getNew(getAllReservedAddresses(), () -> {
                     do {
-                        i.set(i.get() + 1);
-                        if (i.get() > ports.upperEndpoint()) throw new IllegalStateException("There are no more ports available in range: " + ports.toString());
-                    } while (!ports.contains(i.get()));
-                    return new InetSocketAddress(host.getAddress(), i.get());
+                        ++i.value;
+                        if (i.value > ports.upperEndpoint()) throw new IllegalStateException("There are no more ports available in range: " + ports.toString());
+                    } while (!ports.contains(i.value));
+                    return new InetSocketAddress(host.getAddress(), i.value);
                 }).getPort();
             }
             String prefix = name + File.separator + "Creator";
             ExternalSubLogger logger = new ExternalSubLogger(this, prefix, log, null);
-            thread.put(name.toLowerCase(), new NamedContainer<>(port, logger));
+            thread.put(name.toLowerCase(), new ContainedPair<>(port, logger));
 
             final int fport = port;
             final SubCreateEvent event = new SubCreateEvent(player, host, name, template, version, port);
@@ -109,59 +117,7 @@ public class ExternalSubCreator extends SubCreator {
             if (!event.isCancelled()) {
                 logger.start();
                 host.queue(new PacketExCreateServer(player, name, template, version, port, logger.getExternalAddress(), data -> {
-                    try {
-                        if (data.getInt(0x0001) == 0) {
-                            Logger.get(prefix).info("Saving...");
-                            if (host.plugin.exServers.keySet().contains(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));
-
-                            server.set("Enabled", true);
-                            server.set("Display", "");
-                            server.set("Host", host.getName());
-                            server.set("Template", template.getName());
-                            server.set("Group", new ArrayList<String>());
-                            server.set("Port", fport);
-                            server.set("Motd", "Some SubServer");
-                            server.set("Log", true);
-                            server.set("Directory", "./" + name);
-                            server.set("Executable", "java -Xmx1024M -jar " + template.getType().toString() + ".jar");
-                            server.set("Stop-Command", "stop");
-                            server.set("Stop-Action", "NONE");
-                            server.set("Run-On-Launch", false);
-                            server.set("Restricted", false);
-                            server.set("Incompatible", new ArrayList<String>());
-                            server.set("Hidden", false);
-                            server.setAll(config);
-
-                            SubServer subserver = host.addSubServer(player, name, server.getBoolean("Enabled"), fport, 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 (server.getString("Display").length() > 0) subserver.setDisplayName(server.getString("Display"));
-                            subserver.setTemplate(server.getRawString("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);
-                            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));
-                            host.plugin.servers.get().getMap("Servers").set(name, server);
-                            host.plugin.servers.save();
-                            if (template.getBuildOptions().getBoolean("Run-On-Finish", true))
-                                subserver.start();
-
-                            host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, fport, subserver, false, true));
-                            callback(origin, callback, subserver);
-                        } else {
-                            Logger.get(prefix).info(data.getString(0x0003));
-                            host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, fport, null, false, false));
-                            callback(origin, callback, null);
-                        }
-                    } catch (Exception e) {
-                        e.printStackTrace();
-                        callback(origin, callback, null);
-                    }
-                    logger.stop();
+                    finish(player, null, name, template, version, fport, prefix, origin, data, callback);
                     this.thread.remove(name.toLowerCase());
                 }));
                 return true;
@@ -170,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);
@@ -181,38 +137,27 @@ public class ExternalSubCreator extends SubCreator {
     }
 
     @Override
-    public boolean update(UUID player, SubServer server, Version version, Callback<Boolean> callback) {
-        if (Util.isNull(server)) throw new NullPointerException();
-        if (host.isAvailable() && host.isEnabled() && host == server.getHost() && server.isAvailable() && !server.isRunning() && server.getTemplate() != null && server.getTemplate().isEnabled() && server.getTemplate().canUpdate() && (version != null || !server.getTemplate().requiresVersion())) {
-            StackTraceElement[] origin = new Exception().getStackTrace();
+    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 Throwable().getStackTrace();
 
             String name = server.getName();
             String prefix = name + File.separator + "Updater";
-            Util.isException(() -> Util.reflect(SubServerImpl.class.getDeclaredField("updating"), server, true));
+            ((ExternalSubServer) server).updating(true);
             ExternalSubLogger logger = new ExternalSubLogger(this, prefix, log, null);
-            thread.put(name.toLowerCase(), new NamedContainer<>(server.getAddress().getPort(), logger));
+            thread.put(name.toLowerCase(), new ContainedPair<>(server.getAddress().getPort(), logger));
 
-            final SubCreateEvent event = new SubCreateEvent(player, server, version);
+            final SubCreateEvent event = new SubCreateEvent(player, server, ft, version);
             host.plugin.getPluginManager().callEvent(event);
             if (!event.isCancelled()) {
                 logger.start();
-                host.queue(new PacketExCreateServer(player, server, version, logger.getExternalAddress(), data -> {
-                    Util.isException(() -> Util.reflect(SubServerImpl.class.getDeclaredField("updating"), server, false));
-                    if (data.getInt(0x0001) == 0) {
-                        Logger.get(prefix).info("Saving...");
-                    } else {
-                        Logger.get(prefix).info(data.getString(0x0003));
-                    }
-
-                    host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, server.getTemplate(), version, server.getAddress().getPort(), server, true, data.getInt(0x0001) == 0));
-                    if (callback != null) try {
-                        callback.run(data.getInt(0x0001) == 0);
-                    } catch (Throwable e) {
-                        Throwable ew = new InvocationTargetException(e);
-                        ew.setStackTrace(origin);
-                        ew.printStackTrace();
-                    }
-                    logger.stop();
+                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.accept(s != null);
+                    });
                     this.thread.remove(name.toLowerCase());
                 }));
                 return true;
@@ -223,9 +168,87 @@ 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, 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.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);
+                        server.set("Display", "");
+                        server.set("Host", host.getName());
+                        server.set("Template", template.getName());
+                        server.set("Group", new ArrayList<String>());
+                        server.set("Port", port);
+                        server.set("Motd", "Some SubServer");
+                        server.set("Log", true);
+                        server.set("Directory", "./" + name);
+                        server.set("Executable", "java -Xmx1024M -jar " + template.getType().toString() + ".jar");
+                        server.set("Stop-Command", "stop");
+                        server.set("Stop-Action", "NONE");
+                        server.set("Run-On-Launch", false);
+                        server.set("Restricted", false);
+                        server.set("Incompatible", new ArrayList<String>());
+                        server.set("Hidden", false);
+                    } else {
+                        server.setAll(host.plugin.servers.get().getMap("Servers").getMap(name, new HashMap<>()));
+                        server.set("Template", template.getName());
+                    }
+                    server.setAll(config);
+
+                    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(Util.unescapeJavaString(server.getString("Display")));
+                    subserver.setTemplate(server.getString("Template"));
+                    for (String group : server.getStringList("Group")) subserver.addGroup(group);
+                    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));
+
+                    if ((update != null && host.plugin.servers.get().getMap("Servers").contains(name)) ||
+                            !(subserver.getStopAction() == StopAction.REMOVE_SERVER || subserver.getStopAction() == StopAction.RECYCLE_SERVER || subserver.getStopAction() == StopAction.DELETE_SERVER)) {
+                        host.plugin.servers.get().getMap("Servers").set(name, server);
+                        host.plugin.servers.save();
+                    }
+
+                    host.addSubServer(subserver);
+                    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));
+                callback(origin, callback, subserver);
+            } else {
+                Logger.get(prefix).info(data.getString(0x0003));
+                host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, port, update, update != null, false));
+                callback(origin, callback, null);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            callback(origin, callback, null);
+        }
+    }
+
     @Override
     public void terminate() {
-        HashMap<String, NamedContainer<Integer, ExternalSubLogger>> thread = new HashMap<String, NamedContainer<Integer, ExternalSubLogger>>();
+        HashMap<String, Pair<Integer, ExternalSubLogger>> thread = new HashMap<String, Pair<Integer, ExternalSubLogger>>();
         thread.putAll(this.thread);
         for (String i : thread.keySet()) {
             terminate(i);
@@ -234,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());
         }
@@ -242,7 +265,7 @@ public class ExternalSubCreator extends SubCreator {
 
     @Override
     public void waitFor() throws InterruptedException {
-        HashMap<String, NamedContainer<Integer, ExternalSubLogger>> thread = new HashMap<String, NamedContainer<Integer, ExternalSubLogger>>();
+        HashMap<String, Pair<Integer, ExternalSubLogger>> thread = new HashMap<String, Pair<Integer, ExternalSubLogger>>();
         thread.putAll(this.thread);
         for (String i : thread.keySet()) {
             waitFor(i);
@@ -251,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);
         }
     }
@@ -280,7 +303,7 @@ public class ExternalSubCreator extends SubCreator {
     @Override
     public List<SubLogger> getLoggers() {
         List<SubLogger> loggers = new ArrayList<SubLogger>();
-        HashMap<String, NamedContainer<Integer, ExternalSubLogger>> temp = new HashMap<String, NamedContainer<Integer, ExternalSubLogger>>();
+        HashMap<String, Pair<Integer, ExternalSubLogger>> temp = new HashMap<String, Pair<Integer, ExternalSubLogger>>();
         temp.putAll(thread);
         for (String i : temp.keySet()) {
             loggers.add(getLogger(i));
@@ -290,18 +313,18 @@ public class ExternalSubCreator extends SubCreator {
 
     @Override
     public SubLogger getLogger(String name) {
-        return this.thread.get(name.toLowerCase()).get();
+        return this.thread.get(name.toLowerCase()).value();
     }
 
     @Override
     public boolean isLogging() {
-        return log.get();
+        return log.value();
     }
 
     @Override
     public void setLogging(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        log.set(value);
+        Util.nullpo(value);
+        log.value(value);
     }
 
     @Override
@@ -312,21 +335,33 @@ public class ExternalSubCreator extends SubCreator {
     @Override
     public List<Integer> getReservedPorts() {
         List<Integer> ports = new ArrayList<Integer>();
-        for (NamedContainer<Integer, ExternalSubLogger> task : thread.values()) ports.add(task.name());
+        for (Pair<Integer, ExternalSubLogger> task : thread.values()) ports.add(task.key());
         return ports;
     }
 
     @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,26 +1,26 @@
 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;
-import net.ME1312.Galaxi.Library.Container.Container;
-import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.Network.Packet.PacketInExLogMessage;
 import net.ME1312.SubServers.Bungee.SubAPI;
-import net.md_5.bungee.api.ProxyServer;
 
 import java.io.File;
 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
@@ -29,7 +29,7 @@ public class ExternalSubLogger extends SubLogger {
     private Object handle;
     UUID id = null;
     String name;
-    Container<Boolean> log;
+    Value<Boolean> log;
     private List<SubLogFilter> filters = new CopyOnWriteArrayList<>();
     File file;
     private PrintWriter writer = null;
@@ -43,7 +43,7 @@ public class ExternalSubLogger extends SubLogger {
      * @param log Console Logging Status
      * @param file File to log to (or null for disabled)
      */
-    ExternalSubLogger(Object user, String name, Container<Boolean> log, File file) {
+    ExternalSubLogger(Object user, String name, Value<Boolean> log, File file) {
         this.handle = user;
         this.name = name;
         this.log = log;
@@ -73,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:
@@ -103,7 +94,7 @@ public class ExternalSubLogger extends SubLogger {
             }
 
             // Filter Message
-            boolean allow = (SubAPI.getInstance().getInternals().sudo == getHandler() && SubAPI.getInstance().getInternals().canSudo) || (log.get() && (SubAPI.getInstance().getInternals().sudo == null || !SubAPI.getInstance().getInternals().canSudo));
+            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)
@@ -118,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();
             }
         }
@@ -135,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>();
@@ -161,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);
@@ -182,6 +172,6 @@ public class ExternalSubLogger extends SubLogger {
 
     @Override
     public boolean isLogging() {
-        return log.get();
+        return log.value();
     }
 }

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

@@ -1,25 +1,31 @@
 package net.ME1312.SubServers.Bungee.Host.External;
 
-import net.ME1312.Galaxi.Library.Callback.ReturnRunnable;
-import net.ME1312.SubServers.Bungee.Event.*;
-import net.ME1312.SubServers.Bungee.Host.*;
+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.Container.Container;
+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.Galaxi.Library.Container.NamedContainer;
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubServers.Bungee.Network.Packet.PacketExEditServer;
-import net.md_5.bungee.BungeeServerInfo;
+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.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
@@ -27,7 +33,7 @@ import java.util.UUID;
 public class ExternalSubServer extends SubServerImpl {
     private ExternalHost host;
     private boolean enabled;
-    private Container<Boolean> log;
+    private Value<Boolean> log;
     private String dir;
     String exec;
     private String stopcmd;
@@ -80,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);
@@ -95,28 +101,40 @@ public class ExternalSubServer extends SubServerImpl {
         this.lock = false;
     }
 
+    void registered(boolean value) {
+        registered = value;
+    }
+
+    void updating(boolean value) {
+        updating = value;
+    }
+
     @Override
     public boolean start(UUID player) {
         if (!lock && isAvailable() && isEnabled() && !running && getCurrentIncompatibilities().size() == 0) {
             lock = true;
             SubStartEvent event = new SubStartEvent(player, this);
             host.plugin.getPluginManager().callEvent(event);
-            lock = false;
             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 return false;
+            } else {
+                lock = false;
+                return false;
+            }
         } else return false;
     }
     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));
             }
         }
@@ -134,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");
@@ -187,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;
@@ -195,32 +217,26 @@ 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;
         } else return false;
     }
 
-    public int edit(UUID player, ObjectMap<String> edit) {
-        return edit(player, edit, false);
-    }
-
-    public int permaEdit(UUID player, ObjectMap<String> edit) {
-        return edit(player, edit, true);
-    }
-
     @SuppressWarnings({"deprecation", "unchecked"})
-    private int edit(UUID player, ObjectMap<String> edit, boolean perma) {
+    @Override
+    protected int edit(UUID player, ObjectMap<String> edit, boolean perma) {
         if (isAvailable()) {
             int c = 0;
             boolean state = isRunning();
@@ -229,14 +245,18 @@ public class ExternalSubServer extends SubServerImpl {
             for (String key : edit.getKeys()) {
                 pending.remove(key);
                 ObjectMapValue value = edit.get(key);
-                SubEditServerEvent event = new SubEditServerEvent(player, this, new NamedContainer<String, ObjectMapValue>(key, value), perma);
-                host.plugin.getPluginManager().callEvent(event);
-                if (!event.isCancelled()) {
+                boolean allowed = true;
+                if (perma) {
+                    SubEditServerEvent event = new SubEditServerEvent(player, this, new ContainedPair<String, ObjectMapValue>(key, value));
+                    host.plugin.getPluginManager().callEvent(event);
+                    allowed = !event.isCancelled();
+                }
+                if (allowed) {
                     try {
                         switch (key.toLowerCase()) {
                             case "name":
                                 if (value.isString() && host.removeSubServer(player, getName())) {
-                                    SubServer server = host.addSubServer(player, 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());
@@ -251,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())) {
@@ -273,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());
@@ -295,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()).addSubServer(player, 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());
@@ -308,7 +321,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "template":
                                 if (value.isString()) {
-                                    Util.reflect(SubServerImpl.class.getDeclaredField("template"), this, value.asString());
+                                    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();
@@ -319,7 +332,7 @@ public class ExternalSubServer extends SubServerImpl {
                             case "port":
                                 if (value.isNumber() && host.removeSubServer(player, getName())) {
                                     waitFor(() -> host.getSubServer(getName()), null);
-                                    SubServer server = host.addSubServer(player, getName(), isEnabled(), value.asInt(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
+                                    SubServer server = host.constructSubServer(getName(), isEnabled(), value.asInt(), 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("Port", server.getAddress().getPort());
@@ -332,7 +345,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "motd":
                                 if (value.isString()) {
-                                    Util.reflect(BungeeServerInfo.class.getDeclaredField("motd"), this, 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();
@@ -342,8 +355,8 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "log":
                                 if (value.isBoolean()) {
-                                    if (log.get() != value.asBoolean()) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_LOGGING, (Boolean) value.asBoolean()));
-                                    log.set(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());
                                         this.host.plugin.servers.save();
@@ -355,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.addSubServer(player, 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());
@@ -370,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.addSubServer(player, 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;
@@ -389,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();
@@ -400,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())) {
@@ -437,7 +450,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "restricted":
                                 if (value.isBoolean()) {
-                                    Util.reflect(BungeeServerInfo.class.getDeclaredField("restricted"), this, value.asBoolean());
+                                    setRestricted(value.asBoolean());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Restricted", isRestricted());
                                         this.host.plugin.servers.save();
@@ -447,7 +460,7 @@ public class ExternalSubServer extends SubServerImpl {
                                 break;
                             case "hidden":
                                 if (value.isBoolean()) {
-                                    Util.reflect(ServerImpl.class.getDeclaredField("hidden"), this, value.asBoolean());
+                                    setHidden(value.asBoolean());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Hidden", isHidden());
                                         this.host.plugin.servers.save();
@@ -458,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;
@@ -466,7 +482,7 @@ public class ExternalSubServer extends SubServerImpl {
                             forward.setStopAction(getStopAction());
                             if (!getName().equals(getDisplayName())) forward.setDisplayName(getDisplayName());
                             List<String> groups = new ArrayList<String>();
-                            Util.reflect(SubServerImpl.class.getDeclaredField("template"), forward, Util.reflect(SubServerImpl.class.getDeclaredField("template"), this));
+                            forward.setTemplate(getTemplate());
                             groups.addAll(getGroups());
                             for (String group : groups) {
                                 removeGroup(group);
@@ -490,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);
         }
     }
@@ -505,14 +521,13 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public boolean isRunning() {
-        return running;
+        return running || lock;
     }
 
     @Override
     public void setDisplayName(String value) {
         super.setDisplayName(value);
         logger.name = getDisplayName();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("display", value), false));
     }
 
     @Override
@@ -527,23 +542,21 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public void setEnabled(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("enabled", value), false));
-        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;
     }
 
     @Override
     public boolean isLogging() {
-        return log.get();
+        return log.value();
     }
 
     @Override
     public void setLogging(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("log", value), false));
-        if (log.get() != value) host.queue(new PacketExEditServer(this, PacketExEditServer.UpdateType.SET_LOGGING, (Boolean) value));
-        log.set(value);
+        Util.nullpo(value);
+        if (log.value() != value) host.queue(new PacketExControlServer(this, Action.SET_LOGGING, (Boolean) value));
+        log.value(value);
     }
 
     @Override
@@ -573,9 +586,8 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public void setStopCommand(String value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("stop-cmd", value), false));
-        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;
     }
 
@@ -586,8 +598,7 @@ public class ExternalSubServer extends SubServerImpl {
 
     @Override
     public void setStopAction(StopAction action) {
-        if (Util.isNull(action)) throw new NullPointerException();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("stop-action", action), false));
+        Util.nullpo(action);
         stopaction = action;
     }
 }

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

@@ -1,24 +1,29 @@
 package net.ME1312.SubServers.Bungee.Host;
 
-import com.google.common.collect.Range;
+import net.ME1312.Galaxi.Library.ExtraDataHandler;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
+import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidHostException;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
-import net.ME1312.Galaxi.Library.ExtraDataHandler;
-import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.SubAPI;
 import net.ME1312.SubServers.Bungee.SubProxy;
+
+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;
 
@@ -38,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());
     }
@@ -127,10 +132,10 @@ public abstract class Host implements ExtraDataHandler {
      *
      * @return Remote Player Collection
      */
-    public Collection<RemotePlayer> getGlobalPlayers() {
+    public Collection<RemotePlayer> getRemotePlayers() {
         LinkedList<RemotePlayer> players = new LinkedList<RemotePlayer>();
         for (SubServer server : getSubServers().values()) {
-            players.addAll(server.getGlobalPlayers());
+            players.addAll(server.getRemotePlayers());
         }
         return players;
     }
@@ -260,9 +265,8 @@ public abstract class Host implements ExtraDataHandler {
     public abstract SubServer getSubServer(String name);
 
     /**
-     * Adds a SubServer
+     * Constructs a SubServer (but doesn't add it to the server manager)
      *
-     * @param player Player who Added
      * @param name Name of Server
      * @param enabled Enabled Status
      * @param port Port Number
@@ -276,7 +280,7 @@ public abstract class Host implements ExtraDataHandler {
      * @return The SubServer
      * @throws InvalidServerException
      */
-    public abstract SubServer addSubServer(UUID player, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException;
+    public abstract SubServer constructSubServer(String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException;
 
     /**
      * Adds a SubServer
@@ -298,6 +302,47 @@ public abstract class Host implements ExtraDataHandler {
         return addSubServer(null, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
     }
 
+    /**
+     * Adds a SubServer
+     *
+     * @param player Player who Added
+     * @param name Name of Server
+     * @param enabled Enabled Status
+     * @param port Port Number
+     * @param motd Motd of the Server
+     * @param log Logging Status
+     * @param directory Directory
+     * @param executable Executable String
+     * @param stopcmd Command to Stop the Server
+     * @param hidden if the server should be hidden from players
+     * @param restricted Players will need a permission to join if true
+     * @return The SubServer
+     * @throws InvalidServerException
+     */
+    public SubServer addSubServer(UUID player, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException {
+        SubServer server = constructSubServer(name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
+        return (addSubServer(player, server))?server:null;
+    }
+
+    /**
+     * Adds a SubServer
+     *
+     * @param server SubServer to add
+     * @return Success status
+     */
+    public boolean addSubServer(SubServer server) throws InvalidServerException {
+        return addSubServer(null, server);
+    }
+
+    /**
+     * Adds a SubServer
+     *
+     * @param player Player who added
+     * @param server SubServer to add
+     * @return Success status
+     */
+    public abstract boolean addSubServer(UUID player, SubServer server) throws InvalidServerException;
+
     /**
      * Removes a SubServer
      *
@@ -317,7 +362,20 @@ public abstract class Host implements ExtraDataHandler {
      * @throws InterruptedException
      * @return Success Status
      */
-    public abstract boolean removeSubServer(UUID player, String name) throws InterruptedException;
+    public boolean removeSubServer(UUID player, String name) throws InterruptedException {
+        return removeSubServer(player, name, false);
+    }
+
+    /**
+     * Removes a SubServer
+     *
+     * @param player Player Removing
+     * @param name SubServer Name
+     * @param forced Forces the Removal
+     * @throws InterruptedException
+     * @return Success Status
+     */
+    protected abstract boolean removeSubServer(UUID player, String name, boolean forced) throws InterruptedException;
 
     /**
      * Forces the Removal of a SubServer
@@ -330,16 +388,18 @@ public abstract class Host implements ExtraDataHandler {
     }
 
     /**
-     * Forces the Removal of a SubServer (will move to 'Recently Deleted')
+     * Forces the Removal of a SubServer
      *
      * @param player Player Removing
      * @param name SubServer Name
      * @return Success Status
      */
-    public abstract boolean forceRemoveSubServer(UUID player, String name) throws InterruptedException;
+    public boolean forceRemoveSubServer(UUID player, String name) throws InterruptedException {
+        return removeSubServer(player, name, true);
+    }
 
     /**
-     * Delete a SubServer (will move to 'Recently Deleted')
+     * Deletes a SubServer (will move to 'Recently Deleted')
      *
      * @param name SubServer Name
      * @return Success Status
@@ -349,16 +409,28 @@ public abstract class Host implements ExtraDataHandler {
     }
 
     /**
-     * Delete a SubServer
+     * Deletes a SubServer (will move to 'Recently Deleted')
      *
      * @param player Player Deleting
      * @param name SubServer Name
      * @return Success Status
      */
-    public abstract boolean recycleSubServer(UUID player, String name) throws InterruptedException;
+    public boolean recycleSubServer(UUID player, String name) throws InterruptedException {
+        return recycleSubServer(player, name, false);
+    }
 
     /**
-     * Forced the Deletion of a SubServer (will move to 'Recently Deleted')
+     * Deletes a SubServer (will move to 'Recently Deleted')
+     *
+     * @param player Player Deleting
+     * @param name SubServer Name
+     * @param forced Forces the Deletion
+     * @return Success Status
+     */
+    protected abstract boolean recycleSubServer(UUID player, String name, boolean forced) throws InterruptedException;
+
+    /**
+     * Forces the Deletion of a SubServer (will move to 'Recently Deleted')
      *
      * @param name SubServer Name
      * @return Success Status
@@ -374,10 +446,12 @@ public abstract class Host implements ExtraDataHandler {
      * @param name SubServer Name
      * @return Success Status
      */
-    public abstract boolean forceRecycleSubServer(UUID player, String name) throws InterruptedException;
+    public boolean forceRecycleSubServer(UUID player, String name) throws InterruptedException {
+        return recycleSubServer(player, name, true);
+    }
 
     /**
-     * Delete a SubServer
+     * Deletes a SubServer
      *
      * @param name SubServer Name
      * @return Success Status
@@ -387,16 +461,28 @@ public abstract class Host implements ExtraDataHandler {
     }
 
     /**
-     * Delete a SubServer
+     * Deletes a SubServer
      *
      * @param player Player Deleting
      * @param name SubServer Name
      * @return Success Status
      */
-    public abstract boolean deleteSubServer(UUID player, String name) throws InterruptedException;
+    public boolean deleteSubServer(UUID player, String name) throws InterruptedException {
+        return deleteSubServer(player, name, false);
+    }
 
     /**
-     * Forced the Deletion of a SubServer
+     * Deletes a SubServer
+     *
+     * @param player Player Deleting
+     * @param name SubServer Name
+     * @param forced Forces the Deletion
+     * @return Success Status
+     */
+    protected abstract boolean deleteSubServer(UUID player, String name, boolean forced) throws InterruptedException;
+
+    /**
+     * Forces the Deletion of a SubServer
      *
      * @param name SubServer Name
      * @return Success Status
@@ -412,22 +498,24 @@ public abstract class Host implements ExtraDataHandler {
      * @param name SubServer Name
      * @return Success Status
      */
-    public abstract boolean forceDeleteSubServer(UUID player, String name) throws InterruptedException;
+    public boolean forceDeleteSubServer(UUID player, String name) throws InterruptedException {
+        return deleteSubServer(player, name, true);
+    }
 
     /**
      * Resets this Host object
      *
      * @return Success Status
      */
+    @SuppressWarnings("unchecked")
     public boolean destroy() {
         try {
-            List<String> subservers = new ArrayList<String>();
-            subservers.addAll(getSubServers().keySet());
+            Map.Entry<String, SubServer>[] subservers = getSubServers().entrySet().toArray(new Map.Entry[0]);
 
-            for (String server : subservers) {
-                forceRemoveSubServer(server);
+            for (Map.Entry<String, SubServer> entry : subservers) {
+                if (entry.getValue().isRunning()) Logger.get("SubServers").info("Stopping " + entry.getValue().getName());
+                forceRemoveSubServer(entry.getKey());
             }
-            subservers.clear();
             getCreator().terminate();
             getCreator().waitFor();
             return true;
@@ -446,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);
     }
 
@@ -471,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,20 +1,22 @@
 package net.ME1312.SubServers.Bungee.Host.Internal;
 
-import com.dosse.upnp.UPnP;
-import com.google.common.collect.Range;
 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.Util;
 import net.ME1312.SubServers.Bungee.Event.SubAddServerEvent;
 import net.ME1312.SubServers.Bungee.Event.SubRemoveServerEvent;
-import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
-import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
 import net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.Host.SubCreator;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
-import net.ME1312.Galaxi.Library.UniversalFile;
-import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
+import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
 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;
 import java.net.InetAddress;
@@ -93,122 +95,81 @@ 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
-    public SubServer addSubServer(UUID player, String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException {
-        if (plugin.api.getServers().keySet().contains(name.toLowerCase())) throw new InvalidServerException("A Server already exists with this name!");
-        SubServer server = InternalSubServer.construct(this, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
+    public SubServer constructSubServer(String name, boolean enabled, int port, String motd, boolean log, String directory, String executable, String stopcmd, boolean hidden, boolean restricted) throws InvalidServerException {
+        return InternalSubServer.construct(this, name, enabled, port, motd, log, directory, executable, stopcmd, hidden, restricted);
+    }
+
+    @Override
+    public boolean addSubServer(UUID player, SubServer server) throws InvalidServerException {
+        if (server.getHost() != this) throw new IllegalArgumentException("That Server does not belong to this Host!");
+        if (plugin.api.getServers().containsKey(server.getName().toLowerCase())) throw new InvalidServerException("A Server already exists with this name!");
         SubAddServerEvent event = new SubAddServerEvent(player, this, server);
         plugin.getPluginManager().callEvent(event);
         if (!event.isCancelled()) {
-            servers.put(name.toLowerCase(), server);
-            if (UPnP.isUPnPAvailable() && plugin.config.get().getMap("Settings").getMap("UPnP", new ObjectMap<String>()).getBoolean("Forward-Servers", false)) UPnP.openPortTCP(port);
-            return server;
+            ((InternalSubServer) server).registered(true);
+            servers.put(server.getName().toLowerCase(), server);
+            if (UPnP.isUPnPAvailable() && plugin.config.get().getMap("Settings").getMap("UPnP", new ObjectMap<String>()).getBoolean("Forward-Servers", false)) UPnP.openPortTCP(server.getAddress().getPort());
+            return true;
         } else {
-            return null;
+            return false;
         }
     }
 
     @Override
-    public boolean removeSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        SubServer server = servers.get(name.toLowerCase());
+    protected boolean removeSubServer(UUID player, String name, boolean forced) throws InterruptedException {
+        Util.nullpo(name);
+        InternalSubServer server = (InternalSubServer) servers.get(name.toLowerCase());
         SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, server);
         plugin.getPluginManager().callEvent(event);
-        if (!event.isCancelled()) {
+        if (forced || !event.isCancelled()) {
+            server.registered(false);
             if (server.isRunning()) {
                 server.stop();
                 server.waitFor();
             }
+            servers.remove(name.toLowerCase());
             if (UPnP.isUPnPAvailable() && UPnP.isMappedTCP(server.getAddress().getPort()))
                 UPnP.closePortTCP(server.getAddress().getPort());
-            servers.remove(name.toLowerCase());
             return true;
         } else return false;
     }
 
     @Override
-    public boolean forceRemoveSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        SubServer server = servers.get(name.toLowerCase());
-        SubRemoveServerEvent event = new SubRemoveServerEvent(player, this, server);
-        plugin.getPluginManager().callEvent(event);
-        if (server.isRunning()) {
-            server.stop();
-            server.waitFor();
-        }
-        if (UPnP.isUPnPAvailable() && UPnP.isMappedTCP(server.getAddress().getPort()))
-            UPnP.closePortTCP(server.getAddress().getPort());
-        servers.remove(name.toLowerCase());
-        return true;
+    protected boolean recycleSubServer(UUID player, String name, boolean forced) throws InterruptedException {
+        return recycleSubServer(player, name, forced, true);
     }
 
-    @Override
-    public boolean recycleSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
+    /**
+     * Deletes a SubServer (will move to 'Recently Deleted')
+     *
+     * @param player Player Deleting
+     * @param name SubServer Name
+     * @param forced Forces the Deletion
+     * @param multithreading Uses Multithreading for I/O
+     * @return Success Status
+     */
+    protected boolean recycleSubServer(UUID player, String name, boolean forced, boolean multithreading) throws InterruptedException {
+        Util.nullpo(name);
         String server = servers.get(name.toLowerCase()).getName();
         File from = new File(getPath(), servers.get(server.toLowerCase()).getPath());
-        if (removeSubServer(player, server)) {
-            new Thread(() -> {
-                UniversalFile to = new UniversalFile(plugin.dir, "SubServers:Recently Deleted:" + server.toLowerCase());
+        if (removeSubServer(player, server, forced)) {
+            Runnable method = () -> {
+                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);
-                    }
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-
-                Logger.get("SubServers").info("Saving...");
-                YAMLSection info = (plugin.servers.get().getMap("Servers").getKeys().contains(server))?new YAMLSection(plugin.servers.get().getMap("Servers").getMap(server).get()):new YAMLSection();
-                info.set("Name", server);
-                info.set("Timestamp", Calendar.getInstance().getTime().getTime());
-                try {
-                    if (plugin.servers.get().getMap("Servers").getKeys().contains(server)) {
-                        plugin.servers.get().getMap("Servers").remove(server);
-                        plugin.servers.save();
-                    }
-                    if (!to.exists()) to.mkdirs();
-                    FileWriter writer = new FileWriter(new File(to, "info.json"));
-                    writer.write(info.toJSON().toString());
-                    writer.close();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-                Logger.get("SubServers").info("Deleted SubServer: " + server);
-            }, "SubServers.Bungee::Internal_Server_Recycler(" + name + ')').start();
-            return true;
-        } else return false;
-    }
-
-    @Override
-    public boolean forceRecycleSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        String server = servers.get(name.toLowerCase()).getName();
-        File from = new File(getPath(), servers.get(server.toLowerCase()).getPath());
-        if (forceRemoveSubServer(player, server)) {
-            new Thread(() -> {
-                UniversalFile to = new UniversalFile(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);
-                            else to.delete();
-                        }
-                        to.mkdirs();
-                        Util.copyDirectory(from, to);
-                        Util.deleteDirectory(from);
+                        Directories.copy(from, to);
+                        Directories.delete(from);
                     }
                 } catch (Exception e) {
                     e.printStackTrace();
@@ -225,28 +186,45 @@ 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();
                 }
                 Logger.get("SubServers").info("Deleted SubServer: " + server);
-            }, "SubServers.Bungee::Internal_Server_Recycler(" + name + ')').start();
+            };
+
+            if (multithreading) {
+                new Thread(method, "SubServers.Bungee::Internal_Server_Recycler(" + name + ')').start();
+            } else method.run();
             return true;
         } else return false;
     }
 
     @Override
-    public boolean deleteSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
+    protected boolean deleteSubServer(UUID player, String name, boolean forced) throws InterruptedException {
+        return deleteSubServer(player, name, forced, true);
+    }
+
+    /**
+     * Deletes a SubServer
+     *
+     * @param player Player Deleting
+     * @param name SubServer Name
+     * @param forced Forces the Deletion
+     * @param multithreading Uses Multithreading for I/O
+     * @return Success Status
+     */
+    protected boolean deleteSubServer(UUID player, String name, boolean forced, boolean multithreading) throws InterruptedException {
+        Util.nullpo(name);
         String server = servers.get(name.toLowerCase()).getName();
         File from = new File(getPath(), servers.get(server.toLowerCase()).getPath());
-        if (removeSubServer(player, server)) {
-            new Thread(() -> {
+        if (removeSubServer(player, server, forced)) {
+            Runnable method = () -> {
                 try {
                     if (from.exists()) {
                         Logger.get("SubServers").info("Removing Files...");
-                        Util.deleteDirectory(from);
+                        Directories.delete(from);
                     }
                 } catch (Exception e) {
                     e.printStackTrace();
@@ -262,38 +240,11 @@ public class InternalHost extends Host {
                     e.printStackTrace();
                 }
                 Logger.get("SubServers").info("Deleted SubServer: " + server);
-            }, "SubServers.Bungee::Internal_Server_Deletion(" + name + ')').start();
-            return true;
-        } else return false;
-    }
+            };
 
-    @Override
-    public boolean forceDeleteSubServer(UUID player, String name) throws InterruptedException {
-        if (Util.isNull(name)) throw new NullPointerException();
-        String server = servers.get(name.toLowerCase()).getName();
-        File from = new File(getPath(), servers.get(server.toLowerCase()).getPath());
-        if (forceRemoveSubServer(player, server)) {
-            new Thread(() -> {
-                try {
-                    if (from.exists()) {
-                        Logger.get("SubServers").info("Removing Files...");
-                        Util.deleteDirectory(from);
-                    }
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-
-                Logger.get("SubServers").info("Saving...");
-                try {
-                    if (plugin.servers.get().getMap("Servers").getKeys().contains(server)) {
-                        plugin.servers.get().getMap("Servers").remove(server);
-                        plugin.servers.save();
-                    }
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-                Logger.get("SubServers").info("Deleted SubServer: " + server);
-            }, "SubServers.Bungee::Internal_Server_Deletion(" + name + ')').start();
+            if (multithreading) {
+                new Thread(method, "SubServers.Bungee::Internal_Server_Deletion(" + name + ')').start();
+            } else method.run();
             return true;
         } else return false;
     }

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

@@ -1,25 +1,30 @@
 package net.ME1312.SubServers.Bungee.Host.Internal;
 
-import com.google.common.collect.Range;
-import com.google.gson.Gson;
-import net.ME1312.Galaxi.Library.*;
-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.NamedContainer;
+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.Try;
+import net.ME1312.Galaxi.Library.Util;
+import net.ME1312.Galaxi.Library.Version.Version;
 import net.ME1312.SubServers.Bungee.Event.SubCreateEvent;
 import net.ME1312.SubServers.Bungee.Event.SubCreatedEvent;
 import net.ME1312.SubServers.Bungee.Host.*;
-import net.ME1312.Galaxi.Library.Config.YAMLConfig;
-import net.ME1312.Galaxi.Library.Map.ObjectMap;
+import net.ME1312.SubServers.Bungee.Host.SubServer.StopAction;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
 import net.ME1312.SubServers.Bungee.Library.Exception.SubCreatorException;
-import net.ME1312.Galaxi.Library.Version.Version;
 import net.ME1312.SubServers.Bungee.Library.ReplacementScanner;
 import net.ME1312.SubServers.Bungee.SubAPI;
 import net.ME1312.SubServers.Bungee.SubProxy;
+
+import com.google.common.collect.Range;
+import com.google.gson.Gson;
 import net.md_5.bungee.api.ChatColor;
 
 import java.io.*;
@@ -32,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
  */
@@ -42,7 +51,7 @@ public class InternalSubCreator extends SubCreator {
     private HashMap<String, ServerTemplate> templates = new HashMap<String, ServerTemplate>();
     private InternalHost host;
     private Range<Integer> ports;
-    private Container<Boolean> log;
+    private Value<Boolean> log;
     private String gitBash;
     private TreeMap<String, CreatorTask> thread;
 
@@ -55,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;
@@ -68,67 +79,74 @@ 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, 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;
             this.name = server.getName();
-            this.template = server.getTemplate();
+            this.template = template;
             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: " + 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: " + 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);
                 var.put("java", System.getProperty("java.home") + File.separator + "bin" + File.separator + "java");
-                var.put("mode", (update == null)?"CREATE":"UPDATE");
+                var.put("mode", (update == null)? "CREATE" : ((CreatorTask.this.template.equals(update.getTemplate()))?"UPDATE":"SWITCH"));
                 if (player != null) var.put("player", player.toString().toUpperCase());
                 else var.remove("player");
                 var.put("name", name);
@@ -143,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());
                             }
@@ -173,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) {
@@ -207,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;
         }
@@ -233,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();
@@ -267,58 +279,72 @@ public class InternalSubCreator extends SubCreator {
                 try {
                     Logger.get(prefix).info("Saving...");
                     SubServer subserver = update;
-                    if (update == null) {
-                        if (host.plugin.exServers.keySet().contains(name.toLowerCase()))
+                    if (update == null || update.getTemplate() != template || template.getBuildOptions().getBoolean("Update-Settings", false)) {
+                        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");
 
-                        server.set("Enabled", true);
-                        server.set("Display", "");
-                        server.set("Host", host.getName());
-                        server.set("Template", template.getName());
-                        server.set("Group", new ArrayList<String>());
-                        server.set("Port", port);
-                        server.set("Motd", "Some SubServer");
-                        server.set("Log", true);
-                        server.set("Directory", "./" + name);
-                        server.set("Executable", "java -Xmx1024M -jar " + template.getType().toString() + ".jar");
-                        server.set("Stop-Command", "stop");
-                        server.set("Stop-Action", "NONE");
-                        server.set("Run-On-Launch", false);
-                        server.set("Restricted", false);
-                        server.set("Incompatible", new ArrayList<String>());
-                        server.set("Hidden", false);
+                        if (update == null) {
+                            server.set("Enabled", true);
+                            server.set("Display", "");
+                            server.set("Host", host.getName());
+                            server.set("Template", template.getName());
+                            server.set("Group", new ArrayList<String>());
+                            server.set("Port", port);
+                            server.set("Motd", "Some SubServer");
+                            server.set("Log", true);
+                            server.set("Directory", "./" + name);
+                            server.set("Executable", "java -Xmx1024M -jar " + template.getType().toString() + ".jar");
+                            server.set("Stop-Command", "stop");
+                            server.set("Stop-Action", "NONE");
+                            server.set("Run-On-Launch", false);
+                            server.set("Restricted", false);
+                            server.set("Incompatible", new ArrayList<String>());
+                            server.set("Hidden", false);
+                        } else {
+                            server.setAll(host.plugin.servers.get().getMap("Servers").getMap(name, new HashMap<>()));
+                            server.set("Template", template.getName());
+                        }
                         server.setAll(config);
 
-                        subserver = host.addSubServer(player, 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 (server.getString("Display").length() > 0) subserver.setDisplayName(server.getString("Display"));
-                        subserver.setTemplate(server.getRawString("Template"));
+                        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(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));
-                        host.plugin.servers.get().getMap("Servers").set(name, server);
-                        host.plugin.servers.save();
-                        if (template.getBuildOptions().getBoolean("Run-On-Finish", true))
+
+                        if ((update != null && host.plugin.servers.get().getMap("Servers").contains(name)) ||
+                                !(subserver.getStopAction() == StopAction.REMOVE_SERVER || subserver.getStopAction() == StopAction.RECYCLE_SERVER || subserver.getStopAction() == StopAction.DELETE_SERVER)) {
+                            host.plugin.servers.get().getMap("Servers").set(name, server);
+                            host.plugin.servers.save();
+                        }
+
+                        host.addSubServer(subserver);
+                        if (update == null && template.getBuildOptions().getBoolean("Run-On-Finish", true))
                             subserver.start();
                     }
 
                     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());
         }
@@ -334,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);
@@ -347,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 = new ServerTemplate(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();
                 }
             }
@@ -365,25 +391,25 @@ 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) {
-                Container<Integer> i = new Container<Integer>(ports.lowerEndpoint() - 1);
+                Value<Integer> i = new Container<Integer>(ports.lowerEndpoint() - 1);
                 port = Util.getNew(getAllReservedAddresses(), () -> {
                     do {
-                        i.set(i.get() + 1);
-                        if (i.get() > ports.upperEndpoint()) throw new IllegalStateException("There are no more ports available in range: " + ports.toString());
-                    } while (!ports.contains(i.get()));
-                    return new InetSocketAddress(host.getAddress(), i.get());
+                        i.value(i.value() + 1);
+                        if (i.value() > ports.upperEndpoint()) throw new IllegalStateException("There are no more ports available in range: " + ports.toString());
+                    } while (!ports.contains(i.value()));
+                    return new InetSocketAddress(host.getAddress(), i.value());
                 }).getPort();
             }
 
             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);
@@ -406,17 +432,17 @@ public class InternalSubCreator extends SubCreator {
 
     @SuppressWarnings("deprecation")
     @Override
-    public boolean update(UUID player, SubServer server, Version version, Callback<Boolean> callback) {
-        if (Util.isNull(server)) throw new NullPointerException();
-        if (host.isAvailable() && host.isEnabled() && host == server.getHost() && server.isAvailable() && !server.isRunning() && server.getTemplate() != null && server.getTemplate().isEnabled() && server.getTemplate().canUpdate() && (version != null || !server.getTemplate().requiresVersion())) {
-            StackTraceElement[] origin = new Exception().getStackTrace();
+    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 Throwable().getStackTrace();
 
-            Util.isException(() -> Util.reflect(SubServerImpl.class.getDeclaredField("updating"), server, true));
-
-            CreatorTask task = new CreatorTask(player, server, version, x -> {
-                Util.isException(() -> Util.reflect(SubServerImpl.class.getDeclaredField("updating"), server, false));
+            ((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);
@@ -425,7 +451,7 @@ public class InternalSubCreator extends SubCreator {
             });
             this.thread.put(server.getName().toLowerCase(), task);
 
-            final SubCreateEvent event = new SubCreateEvent(player, server, version);
+            final SubCreateEvent event = new SubCreateEvent(player, server, ft, version);
             host.plugin.getPluginManager().callEvent(event);
             if (!event.isCancelled()) {
                 task.start();
@@ -448,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()) {
@@ -469,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);
         }
     }
@@ -513,13 +539,13 @@ public class InternalSubCreator extends SubCreator {
 
     @Override
     public boolean isLogging() {
-        return log.get();
+        return log.value();
     }
 
     @Override
     public void setLogging(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        log.set(value);
+        Util.nullpo(value);
+        log.value(value);
     }
 
     @Override
@@ -536,73 +562,80 @@ 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 NamedContainer<YAMLSection, Map<String, Object>> subdata = null;
+    private static Pair<YAMLSection, Map<String, Object>> subdata = null;
     private Map<String, Object> getSubData() {
-        if (subdata == null || host.plugin.config.get() != subdata.name()) {
+        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"));
-            subdata = new NamedContainer<>(host.plugin.config.get(), map);
+            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.get();
+        return subdata.value();
     }
 
     private void generateClient(File dir, ServerType type, String name) throws IOException {
         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);
@@ -614,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,12 +1,12 @@
 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;
-import net.ME1312.Galaxi.Library.Container.Container;
-import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
 import net.ME1312.SubServers.Bungee.SubAPI;
-import net.md_5.bungee.api.ProxyServer;
 
 import java.io.*;
 import java.lang.reflect.InvocationTargetException;
@@ -24,7 +24,7 @@ public class InternalSubLogger extends SubLogger {
     Process process;
     private Object handle;
     String name;
-    Container<Boolean> log;
+    Value<Boolean> log;
     private List<SubLogFilter> filters = new CopyOnWriteArrayList<>();
     File file;
     private PrintWriter writer = null;
@@ -41,7 +41,7 @@ public class InternalSubLogger extends SubLogger {
      * @param log Console Logging Status
      * @param file File to log to (or null for disabled)
      */
-    InternalSubLogger(Process process, Object user, String name, Container<Boolean> log, File file) {
+    InternalSubLogger(Process process, Object user, String name, Value<Boolean> log, File file) {
         this.process = process;
         this.handle = user;
         this.name = name;
@@ -49,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;
@@ -63,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")
@@ -91,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.get() && (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) {
@@ -142,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
@@ -199,6 +219,6 @@ public class InternalSubLogger extends SubLogger {
 
     @Override
     public boolean isLogging() {
-        return log.get();
+        return log.value();
     }
 }

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

@@ -1,22 +1,29 @@
 package net.ME1312.SubServers.Bungee.Host.Internal;
 
-import net.ME1312.SubServers.Bungee.Event.*;
-import net.ME1312.SubServers.Bungee.Host.*;
+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.Container.Container;
-import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
-import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
-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.*;
-import java.lang.reflect.Field;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
@@ -30,7 +37,7 @@ import java.util.jar.JarInputStream;
 public class InternalSubServer extends SubServerImpl {
     private InternalHost host;
     private boolean enabled;
-    private Container<Boolean> log;
+    private Value<Boolean> log;
     private String dir;
     private File directory;
     private String executable;
@@ -87,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);
@@ -101,49 +108,48 @@ public class InternalSubServer extends SubServerImpl {
         this.logger = new InternalSubLogger(null, this, getName(), this.log, null);
         this.thread = null;
         this.command = null;
+        final File[] locations = new File[] {
+                new File(this.directory, "plugins/SubServers.Client.jar"),
+                new File(this.directory, "mods/SubServers.Client.jar")
+        };
 
-        if (new UniversalFile(this.directory, "plugins:SubServers.Client.jar").exists()) {
-            try {
-                JarInputStream updated = new JarInputStream(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/client.jar"));
-                JarFile existing = new JarFile(new UniversalFile(this.directory, "plugins:SubServers.Client.jar"));
+        for (File location : locations) {
+            if (location.exists()) {
+                try {
+                    JarInputStream updated = new JarInputStream(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/client.jar"));
+                    JarFile existing = new JarFile(location);
 
-                if (existing.getManifest().getMainAttributes().getValue("Implementation-Title") != null && existing.getManifest().getMainAttributes().getValue("Implementation-Title").startsWith("SubServers.Client") && existing.getManifest().getMainAttributes().getValue("Specification-Title") != null &&
-                        updated.getManifest().getMainAttributes().getValue("Implementation-Title") != null && updated.getManifest().getMainAttributes().getValue("Implementation-Title").startsWith("SubServers.Client") && updated.getManifest().getMainAttributes().getValue("Specification-Title") != null) {
-                    if (new Version(existing.getManifest().getMainAttributes().getValue("Specification-Title")).compareTo(new Version(updated.getManifest().getMainAttributes().getValue("Specification-Title"))) < 0) {
-                        new UniversalFile(this.directory, "plugins:SubServers.Client.jar").delete();
-                        Util.copyFromJar(SubProxy.class.getClassLoader(), "net/ME1312/SubServers/Bungee/Library/Files/client.jar", new UniversalFile(this.directory, "plugins:SubServers.Client.jar").getPath());
+                    if (existing.getManifest().getMainAttributes().getValue("Implementation-Title") != null && existing.getManifest().getMainAttributes().getValue("Implementation-Title").startsWith("SubServers.Client") && existing.getManifest().getMainAttributes().getValue("Specification-Title") != null &&
+                            updated.getManifest().getMainAttributes().getValue("Implementation-Title") != null && updated.getManifest().getMainAttributes().getValue("Implementation-Title").startsWith("SubServers.Client") && updated.getManifest().getMainAttributes().getValue("Specification-Title") != null) {
+                        if (new Version(existing.getManifest().getMainAttributes().getValue("Specification-Title")).compareTo(new Version(updated.getManifest().getMainAttributes().getValue("Specification-Title"))) < 0) {
+                            location.delete();
+                            Util.copyFromJar(SubProxy.class.getClassLoader(), "net/ME1312/SubServers/Bungee/Library/Files/client.jar", location.getPath());
+                        }
                     }
+                    existing.close();
+                    updated.close();
+                } catch (Throwable e) {
+                    System.out.println("Couldn't auto-update SubServers.Client for subserver: " + name);
+                    e.printStackTrace();
                 }
-                existing.close();
-                updated.close();
-            } catch (Throwable e) {
-                System.out.println("Couldn't auto-update SubServers.Client.jar for " + name);
-                e.printStackTrace();
-            }
-        } else if (new UniversalFile(this.directory, "mods:SubServers.Client.jar").exists()) {
-            try {
-                JarInputStream updated = new JarInputStream(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/client.jar"));
-                JarFile existing = new JarFile(new UniversalFile(this.directory, "mods:SubServers.Client.jar"));
-
-                if (existing.getManifest().getMainAttributes().getValue("Implementation-Title") != null && existing.getManifest().getMainAttributes().getValue("Implementation-Title").startsWith("SubServers.Client") && existing.getManifest().getMainAttributes().getValue("Specification-Title") != null &&
-                        updated.getManifest().getMainAttributes().getValue("Implementation-Title") != null && updated.getManifest().getMainAttributes().getValue("Implementation-Title").startsWith("SubServers.Client") && updated.getManifest().getMainAttributes().getValue("Specification-Title") != null) {
-                    if (new Version(existing.getManifest().getMainAttributes().getValue("Specification-Title")).compareTo(new Version(updated.getManifest().getMainAttributes().getValue("Specification-Title"))) < 0) {
-                        new UniversalFile(this.directory, "mods:SubServers.Client.jar").delete();
-                        Util.copyFromJar(SubProxy.class.getClassLoader(), "net/ME1312/SubServers/Bungee/Library/Files/client.jar", new UniversalFile(this.directory, "mods:SubServers.Client.jar").getPath());
-                    }
-                }
-                existing.close();
-                updated.close();
-            } catch (Throwable e) {
-                System.out.println("Couldn't auto-update SubServers.Client.jar for " + name);
-                e.printStackTrace();
             }
         }
+
         this.lock = false;
     }
 
+    void registered(boolean value) {
+        registered = value;
+    }
+
+    void updating(boolean value) {
+        updating = value;
+    }
+
     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);
@@ -152,10 +158,12 @@ 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;
             logger.start();
+            lock = locked = false;
             command = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
             for (LoggedCommand command : history) if (process.isAlive()) {
                 this.command.write(command.getCommand());
@@ -166,12 +174,16 @@ public class InternalSubServer extends SubServerImpl {
             if (process.isAlive()) process.waitFor();
         } catch (IOException | InterruptedException e) {
             e.printStackTrace();
+            if (locked) lock = false;
             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);
@@ -180,9 +192,9 @@ public class InternalSubServer extends SubServerImpl {
         if (stopaction == StopAction.REMOVE_SERVER || stopaction == StopAction.RECYCLE_SERVER || stopaction == StopAction.DELETE_SERVER) {
             try {
                 if (stopaction == StopAction.RECYCLE_SERVER) {
-                    host.recycleSubServer(getName());
+                    host.recycleSubServer(null, getName(), false, false);
                 } else if (stopaction == StopAction.DELETE_SERVER) {
-                    host.deleteSubServer(getName());
+                    host.deleteSubServer(null, getName(), false, false);
                 } else {
                     try {
                         if (host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
@@ -219,11 +231,13 @@ public class InternalSubServer extends SubServerImpl {
             lock = true;
             SubStartEvent event = new SubStartEvent(player, this);
             host.plugin.getPluginManager().callEvent(event);
-            lock = false;
             if (!event.isCancelled()) {
                 (thread = new Thread(this::run, "SubServers.Bungee::Internal_Server_Process_Handler(" + getName() + ')')).start();
                 return true;
-            } else return false;
+            } else {
+                lock = false;
+                return false;
+            }
         } else return false;
     }
 
@@ -234,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()) {
@@ -256,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;
@@ -265,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());
@@ -287,16 +306,9 @@ public class InternalSubServer extends SubServerImpl {
         } else return false;
     }
 
-    public int edit(UUID player, ObjectMap<String> edit) {
-        return edit(player, edit, false);
-    }
-
-    public int permaEdit(UUID player, ObjectMap<String> edit) {
-        return edit(player, edit, true);
-    }
-
     @SuppressWarnings({"deprecation", "unchecked"})
-    private int edit(UUID player, ObjectMap<String> edit, boolean perma) {
+    @Override
+    protected int edit(UUID player, ObjectMap<String> edit, boolean perma) {
         if (isAvailable()) {
             int c = 0;
             boolean state = isRunning();
@@ -305,14 +317,18 @@ public class InternalSubServer extends SubServerImpl {
             for (String key : edit.getKeys()) {
                 pending.remove(key);
                 ObjectMapValue value = edit.get(key);
-                SubEditServerEvent event = new SubEditServerEvent(player, this, new NamedContainer<String, ObjectMapValue>(key, value), perma);
-                host.plugin.getPluginManager().callEvent(event);
-                if (!event.isCancelled()) {
+                boolean allowed = true;
+                if (perma) {
+                    SubEditServerEvent event = new SubEditServerEvent(player, this, new ContainedPair<String, ObjectMapValue>(key, value));
+                    host.plugin.getPluginManager().callEvent(event);
+                    allowed = !event.isCancelled();
+                }
+                if (allowed) {
                     try {
                         switch (key.toLowerCase()) {
                             case "name":
                                 if (value.isString() && host.removeSubServer(player, getName())) {
-                                    SubServer server = host.addSubServer(player, 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());
@@ -327,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())) {
@@ -359,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++;
@@ -369,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()).addSubServer(player, 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());
@@ -382,9 +391,9 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "template":
                                 if (value.isString()) {
-                                    Util.reflect(SubServerImpl.class.getDeclaredField("template"), this, 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++;
@@ -392,7 +401,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "port":
                                 if (value.isNumber() && host.removeSubServer(player, getName())) {
-                                    SubServer server = host.addSubServer(player, getName(), isEnabled(), value.asInt(), getMotd(), isLogging(), getPath(), getExecutable(), getStopCommand(), isHidden(), isRestricted());
+                                    SubServer server = host.constructSubServer(getName(), isEnabled(), value.asInt(), 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("Port", server.getAddress().getPort());
@@ -405,7 +414,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "motd":
                                 if (value.isString()) {
-                                    Util.reflect(BungeeServerInfo.class.getDeclaredField("motd"), this, 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();
@@ -415,7 +424,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "log":
                                 if (value.isBoolean()) {
-                                    log.set(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());
                                         this.host.plugin.servers.save();
@@ -430,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();
@@ -446,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++;
@@ -457,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();
@@ -467,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())) {
@@ -509,7 +518,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "restricted":
                                 if (value.isBoolean()) {
-                                    Util.reflect(BungeeServerInfo.class.getDeclaredField("restricted"), this, value.asBoolean());
+                                    setRestricted(value.asBoolean());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Restricted", isRestricted());
                                         this.host.plugin.servers.save();
@@ -519,7 +528,7 @@ public class InternalSubServer extends SubServerImpl {
                                 break;
                             case "hidden":
                                 if (value.isBoolean()) {
-                                    Util.reflect(ServerImpl.class.getDeclaredField("hidden"), this, value.asBoolean());
+                                    setHidden(value.asBoolean());
                                     if (perma && this.host.plugin.servers.get().getMap("Servers").getKeys().contains(getName())) {
                                         this.host.plugin.servers.get().getMap("Servers").getMap(getName()).set("Hidden", isHidden());
                                         this.host.plugin.servers.save();
@@ -530,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;
@@ -537,7 +549,7 @@ public class InternalSubServer extends SubServerImpl {
                         if (forward != null) {
                             forward.setStopAction(getStopAction());
                             if (!getName().equals(getDisplayName())) forward.setDisplayName(getDisplayName());
-                            Util.reflect(SubServerImpl.class.getDeclaredField("template"), forward, Util.reflect(SubServerImpl.class.getDeclaredField("template"), this));
+                            forward.setTemplate(getTemplate());
                             List<String> groups = new ArrayList<String>();
                             groups.addAll(getGroups());
                             for (String group : groups) {
@@ -549,6 +561,7 @@ public class InternalSubServer extends SubServerImpl {
                                 forward.toggleCompatibility(server);
                             }
                             for (String extra : getExtra().getKeys()) forward.addExtra(extra, getExtra(extra));
+                            forward.getHost().addSubServer(player, forward);
 
                             if (state) pending.set("state", true);
                             c += (perma)?forward.permaEdit(player, pending):forward.edit(player, pending);
@@ -573,7 +586,7 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public boolean isRunning() {
-        return process != null && process.isAlive();
+        return (process != null && process.isAlive()) || lock;
     }
 
     @Override
@@ -594,21 +607,19 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public void setEnabled(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("enabled", value), false));
+        Util.nullpo(value);
         enabled = value;
     }
 
     @Override
     public boolean isLogging() {
-        return log.get();
+        return log.value();
     }
 
     @Override
     public void setLogging(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("log", value), false));
-        log.set(value);
+        Util.nullpo(value);
+        log.value(value);
     }
 
     @Override
@@ -638,8 +649,7 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public void setStopCommand(String value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("stop-cmd", value), false));
+        Util.nullpo(value);
         stopcmd = value;
     }
 
@@ -650,8 +660,7 @@ public class InternalSubServer extends SubServerImpl {
 
     @Override
     public void setStopAction(StopAction action) {
-        if (Util.isNull(action)) throw new NullPointerException();
-        host.plugin.getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("stop-action", action), false));
+        Util.nullpo(action);
         stopaction = action;
     }
 }

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

@@ -1,38 +1,34 @@
 package net.ME1312.SubServers.Bungee.Host;
 
+import net.ME1312.Galaxi.Library.ExtraDataHandler;
+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.ClientHandler;
 import net.ME1312.SubData.Server.DataClient;
 import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.SubServers.Bungee.Event.SubRemoveProxyEvent;
-import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
-import net.ME1312.Galaxi.Library.ExtraDataHandler;
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubData.Server.ClientHandler;
+import net.ME1312.SubServers.Bungee.Network.Packet.PacketExSyncPlayer;
 import net.ME1312.SubServers.Bungee.SubAPI;
 import net.ME1312.SubServers.Bungee.SubProxy;
+
 import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 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 = true;
+    private boolean persistent = false;
     private String nick = null;
     private final String name;
 
-    @SuppressWarnings("deprecation")
     public Proxy(String name) throws IllegalArgumentException {
-        if (name == null) {
-            name = Util.getNew(SubAPI.getInstance().getInternals().proxies.keySet(), () -> UUID.randomUUID().toString());
-            persistent = false;
-        }
+        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.signature = SubAPI.getInstance().signAnonymousObject();
@@ -42,21 +38,22 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
 
     @Override
     public DataClient[] getSubData() {
-        LinkedList<Integer> keys = new LinkedList<Integer>(subdata.keySet());
-        LinkedList<SubDataClient> channels = new LinkedList<SubDataClient>();
-        Collections.sort(keys);
-        for (Integer channel : keys) channels.add(subdata.get(channel));
-        return channels.toArray(new DataClient[0]);
+        Integer[] keys = subdata.keySet().toArray(new Integer[0]);
+        DataClient[] channels = new DataClient[keys.length];
+        Arrays.sort(keys);
+        for (int i = 0; i < keys.length; ++i) channels[i] = subdata.get(keys[i]);
+        return channels;
     }
 
+    @SuppressWarnings("deprecation")
     public void setSubData(SubDataClient client, int channel) {
         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);
+                subdata.put(channel, client);
+                if (client != null && (client.getHandler() == null || !equals(client.getHandler()))) client.setHandler(this);
             }
         } else {
             update = true;
@@ -65,9 +62,20 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
 
         if (update) {
             DataClient[] subdata = getSubData();
-            if (subdata[0] == null && subdata.length <= 1 && !persistent) {
-                ProxyServer.getInstance().getPluginManager().callEvent(new SubRemoveProxyEvent(this));
-                SubAPI.getInstance().getInternals().proxies.remove(getName().toLowerCase());
+            if (subdata[0] == null && subdata.length <= 1) {
+                SubProxy plugin = SubAPI.getInstance().getInternals();
+                for (UUID id : Util.getBackwards(plugin.rPlayerLinkP, this)) {
+                    plugin.rPlayerLinkS.remove(id);
+                    plugin.rPlayerLinkP.remove(id);
+                    plugin.rPlayers.remove(id);
+                }
+                for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null && proxy != this) {
+                    ((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketExSyncPlayer(getName(), null, (RemotePlayer[]) null));
+                }
+                if (!persistent) {
+                    ProxyServer.getInstance().getPluginManager().callEvent(new SubRemoveProxyEvent(this));
+                    SubAPI.getInstance().getInternals().proxies.remove(getName().toLowerCase());
+                }
             }
         }
     }
@@ -108,17 +116,6 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
         }
     }
 
-    /**
-     * Determine if the proxy is connected to RedisBungee's server
-     *
-     * @return Redis Status
-     */
-    @SuppressWarnings({"deprecation", "unchecked"})
-    public boolean isRedis() {
-        SubProxy plugin = SubAPI.getInstance().getInternals();
-        return plugin.redis != null && Util.getDespiteException(() -> plugin.redis("getPlayersOnProxy", new NamedContainer<>(String.class, getName())) != null, false);
-    }
-
     /**
      * Determine if the proxy is the Master Proxy
      *
@@ -129,28 +126,27 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
     }
 
     /**
-     * Get the players on this proxy (via RedisBungee)
+     * Get the players on this proxy
      *
      * @return Remote Player Collection
      */
-    @SuppressWarnings({"deprecation", "unchecked"})
+    @SuppressWarnings("deprecation")
     public Collection<RemotePlayer> getPlayers() {
-        List<RemotePlayer> players = new LinkedList<RemotePlayer>();
-        //List<UUID> used = new ArrayList<UUID>();
         SubProxy plugin = SubAPI.getInstance().getInternals();
-        if (plugin.redis != null) {
-            try {
-                for (UUID id : (Set<UUID>) plugin.redis("getPlayersOnProxy", new NamedContainer<>(String.class, getName()))) {
-                  //if (!used.contains(id)) {
-                        players.add(new RemotePlayer(id));
-                  //    used.add(id);
-                  //}
-                }
-            } catch (Exception e) {}
+        ArrayList<RemotePlayer> players = new ArrayList<RemotePlayer>();
+        for (UUID id : Util.getBackwards(plugin.rPlayerLinkP, this)) {
+            players.add(plugin.rPlayers.get(id));
         }
         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
      *
@@ -160,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);
     }
 
@@ -185,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);
     }
 
@@ -199,7 +200,6 @@ public class Proxy implements ClientHandler, ExtraDataHandler {
         for (RemotePlayer player : getPlayers())
             players.set(player.getUniqueId().toString(), player.getName());
         info.set("players", players);
-        info.set("redis", isRedis());
         info.set("master", isMaster());
         ObjectMap<Integer> subdata = new ObjectMap<Integer>();
         for (int channel : this.subdata.keySet()) subdata.set(channel, (this.subdata.get(channel) == null)?null:this.subdata.get(channel).getID());

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

@@ -1,24 +1,35 @@
 package net.ME1312.SubServers.Bungee.Host;
 
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
+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.ME1312.SubServers.Bungee.SubProxy;
+
+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.net.InetAddress;
+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
  */
-public class RemotePlayer implements SubDataSerializable {
+public class RemotePlayer implements net.ME1312.SubServers.Bungee.Library.Compatibility.RemotePlayer, SubDataSerializable {
     private ProxiedPlayer local;
     private UUID id;
     private String name;
-    private InetAddress ip;
+    private InetSocketAddress ip;
     private Proxy proxy;
     private Server server;
 
@@ -28,84 +39,69 @@ public class RemotePlayer implements SubDataSerializable {
      * @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;
     }
 
     /**
      * Search for a Remote Player using their ID
      *
-     * @param player Remote Player ID
+     * @param name Player Name
+     * @param id Player UUID
+     * @param proxy Proxy the player is on
+     * @param server Server the player is on
+     * @param ip Player IP Address
      */
-    public RemotePlayer(UUID player) {
-        if (Util.isNull(player)) throw new NullPointerException();
-
-        id = player;
-        refresh();
+    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 instanceof Server)? (Server) server : null;
     }
 
-    /**
-     * Download a new copy of the data
-     */
-    @SuppressWarnings({"deprecation", "unchecked"})
-    public void refresh() {
-        SubProxy plugin = SubAPI.getInstance().getInternals();
-        UUID player = id;
-
-        this.local = plugin.getPlayer(player);
-        if (local == null) {
-            if (plugin.redis != null && Util.getDespiteException(() -> (boolean) plugin.redis("isPlayerOnline", new NamedContainer<>(UUID.class, player)), false)) {
-                server = Util.getDespiteException(() -> (Server) plugin.redis("getServerFor", new NamedContainer<>(UUID.class, player)), null);
-                proxy = Util.getDespiteException(() -> plugin.api.getProxy((String) plugin.redis("getProxy", new NamedContainer<>(UUID.class, player))), null);
-                ip = Util.getDespiteException(() -> (InetAddress) plugin.redis("getPlayerIp", new NamedContainer<>(UUID.class, player)), null);
-                name = Util.getDespiteException(() -> (String) plugin.redis("getNameFromUuid", new NamedContainer<>(UUID.class, player), new NamedContainer<>(boolean.class, false)), null);
-            }
-
-            if (name == null) throw new IllegalStateException("Player " + id.toString() + " not found!");
-        }
-    }
-
-    /**
-     * Get Local Player
-     *
-     * @return Local Player (or null when not local)
-     */
+    @Override
     public ProxiedPlayer get() {
         return local;
     }
 
-    /**
-     * Get the UUID of this player.
-     *
-     * @return the UUID
-     */
+    private static ProxiedPlayer get(UUID player) {
+        return ProxyServer.getInstance().getPlayer(player);
+    }
+
+    @Override
     public UUID getUniqueId() {
         if (local != null) {
             return local.getUniqueId();
         } else return id;
     }
 
-    /**
-     * Get the unique name of this player.
-     *
-     * @return the players username
-     */
+    @Override
     public String getName() {
         if (local != null) {
             return local.getName();
         } else return name;
     }
 
-    /**
-     * Gets the remote address of this connection.
-     *
-     * @return the remote address
-     */
     @SuppressWarnings("deprecation")
-    public InetAddress getAddress() {
+    @Override
+    public InetSocketAddress getAddress() {
         if (local != null) {
-            return local.getAddress().getAddress();
+            return local.getAddress();
         } else return ip;
     }
 
@@ -120,15 +116,26 @@ public class RemotePlayer implements SubDataSerializable {
         } else return proxy;
     }
 
-    /**
-     * Gets the server this player is connected to.
-     *
-     * @return the server this player is connected to
-     */
+    @Override
+    public String getProxyName() {
+        Proxy proxy = getProxy();
+        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
+    public String getServerName() {
+        Server server = getServer();
+        return (server == null)? null : server.getName();
     }
 
     @Override
@@ -141,8 +148,167 @@ public class RemotePlayer implements SubDataSerializable {
         ObjectMap<String> pinfo = new ObjectMap<String>();
         pinfo.set("name", getName());
         pinfo.set("id", getUniqueId());
+        pinfo.set("address", getAddress().getAddress().getHostAddress() + ':' + getAddress().getPort());
         if (getServer() != null) pinfo.set("server", getServer().getName());
         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

@@ -1,9 +1,9 @@
 package net.ME1312.SubServers.Bungee.Host;
 
 import net.ME1312.Galaxi.Library.ExtraDataHandler;
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
 import net.ME1312.SubData.Server.ClientHandler;
 import net.ME1312.SubData.Server.DataClient;
+
 import net.md_5.bungee.api.config.ServerInfo;
 
 import java.util.Collection;
@@ -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,12 +58,40 @@ 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
      *
      * @return Remote Player Collection
      */
-    Collection<RemotePlayer> getGlobalPlayers();
+    Collection<RemotePlayer> getRemotePlayers();
 
     /**
      * If the server is hidden from players
@@ -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.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.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Map.ObjectMapValue;
-import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
 import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExRunEvent;
-import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExUpdateWhitelist;
+import net.ME1312.SubData.Server.DataClient;
+import net.ME1312.SubData.Server.SubDataClient;
+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.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.ME1312.SubServers.Bungee.SubProxy;
+
 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,20 +82,30 @@ 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() {
-        LinkedList<Integer> keys = new LinkedList<Integer>(subdata.keySet());
-        LinkedList<SubDataClient> channels = new LinkedList<SubDataClient>();
-        Collections.sort(keys);
-        for (Integer channel : keys) channels.add(subdata.get(channel));
-        return channels.toArray(new DataClient[0]);
+        Integer[] keys = subdata.keySet().toArray(new Integer[0]);
+        DataClient[] channels = new DataClient[keys.length];
+        Arrays.sort(keys);
+        for (int i = 0; i < keys.length; ++i) channels[i] = subdata.get(keys[i]);
+        return channels;
     }
 
     public void setSubData(DataClient client, int channel) {
         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());
+                }
+            }
         }
     }
 
@@ -126,12 +146,13 @@ public class ServerImpl extends BungeeServerInfo implements Server {
     @SuppressWarnings("deprecation")
     public void setDisplayName(String value) {
         if (value == null || value.length() == 0 || getName().equals(value)) {
-            SubAPI.getInstance().getInternals().getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("display", getName()), false));
             this.nick = null;
         } else {
-            SubAPI.getInstance().getInternals().getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("display", value), false));
             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
@@ -142,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);
@@ -152,32 +173,28 @@ 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);
     }
 
-    @SuppressWarnings({"deprecation", "unchecked"})
     @Override
-    public Collection<RemotePlayer> getGlobalPlayers() {
-        List<RemotePlayer> players = new LinkedList<RemotePlayer>();
-        List<UUID> used = new ArrayList<UUID>();
-        SubProxy plugin = SubAPI.getInstance().getInternals();
-        for (ProxiedPlayer player : getPlayers()) {
-            players.add(new RemotePlayer(player));
-            used.add(player.getUniqueId());
-        }
-        if (plugin.redis != null) {
-            try {
-                for (UUID id : (Set<UUID>) plugin.redis("getPlayersOnServer", new NamedContainer<>(String.class, getName()))) {
-                    if (!used.contains(id)) {
-                        players.add(new RemotePlayer(id));
-                        used.add(id);
-                    }
-                }
-            } catch (Exception e) {}
-        }
-        return players;
+    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();
     }
 
     @Override
@@ -186,40 +203,38 @@ public class ServerImpl extends BungeeServerInfo implements Server {
     }
 
     @Override
-    @SuppressWarnings("deprecation")
     public void setHidden(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        SubAPI.getInstance().getInternals().getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("hidden", value), false));
         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()));
+        }
     }
 
-    @SuppressWarnings("deprecation")
     public void setMotd(String value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        SubAPI.getInstance().getInternals().getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("motd", value), false));
+        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();
         }
     }
 
-    @SuppressWarnings("deprecation")
     public void setRestricted(boolean value) {
-        if (Util.isNull(value)) throw new NullPointerException();
-        SubAPI.getInstance().getInternals().getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("restricted", value), false));
+        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();
         }
     }
 
-    @Override
-    public Collection<UUID> getWhitelist() {
-        return new ArrayList<UUID>(whitelist);
-    }
-
     /**
      * See if a player can access this server
      *
@@ -228,7 +243,12 @@ 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
+    public Collection<UUID> getWhitelist() {
+        return new ArrayList<UUID>(whitelist);
     }
 
     @Override
@@ -238,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
@@ -255,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);
     }
 
@@ -280,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);
     }
 
@@ -297,7 +331,7 @@ public class ServerImpl extends BungeeServerInfo implements Server {
         info.set("restricted", isRestricted());
         info.set("hidden", isHidden());
         ObjectMap<String> players = new ObjectMap<String>();
-        for (RemotePlayer player : getGlobalPlayers())
+        for (RemotePlayer player : getRemotePlayers())
             players.set(player.getUniqueId().toString(), player.getName());
         info.set("players", players);
         ObjectMap<Integer> subdata = new ObjectMap<Integer>();

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

@@ -1,25 +1,28 @@
 package net.ME1312.SubServers.Bungee.Host;
 
-import com.google.common.collect.Range;
-import net.ME1312.Galaxi.Library.Callback.Callback;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.SubServers.Bungee.Library.Exception.InvalidTemplateException;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.Galaxi.Library.Version.Version;
+import net.ME1312.SubServers.Bungee.Library.Exception.InvalidTemplateException;
 import net.ME1312.SubServers.Bungee.SubAPI;
 
+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
  */
 public abstract class SubCreator {
     public static class ServerTemplate {
+        private final boolean dynamic;
         private String name;
         private String nick = null;
         private boolean enabled;
+        private boolean internal;
         private String icon;
         private File directory;
         private ServerType type;
@@ -30,20 +33,28 @@ public abstract class SubCreator {
          * Create a SubCreator Template
          *
          * @param name Template Name
+         * @param enabled Template Enabled Status
+         * @param icon Template Item Icon Name
          * @param directory Template Directory
          * @param build Build Options
          * @param options Configuration Options
          */
         public ServerTemplate(String name, boolean enabled, String icon, File directory, ObjectMap<String> build, ObjectMap<String> options) {
-            if (Util.isNull(name, enabled, directory, build, options)) throw new NullPointerException();
+            this(name, enabled, false, icon, directory, build, options, true);
+        }
+
+        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;
         }
 
         /**
@@ -95,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
          *
@@ -149,6 +169,15 @@ public abstract class SubCreator {
             return getBuildOptions().getBoolean("Can-Update", false);
         }
 
+        /**
+         * Get whether this Template was generated by a SubCreator instance
+         *
+         * @return Dynamic Status
+         */
+        public boolean isDynamic() {
+            return dynamic;
+        }
+
         /**
          * Get the Build Options for this Template
          *
@@ -204,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
@@ -230,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);
     }
 
@@ -252,11 +281,50 @@ public abstract class SubCreator {
      *
      * @param player Player Updating
      * @param server Server to Update
+     * @param template Server Template
      * @param version Server Version (may be null)
      * @param callback Callback
      * @return Success Status
      */
-    public abstract boolean update(UUID player, SubServer server, Version version, Callback<Boolean> callback);
+    public abstract boolean update(UUID player, SubServer server, ServerTemplate template, Version version, Consumer<Boolean> callback);
+
+    /**
+     * Update a SubServer
+     *
+     * @param player Player Updating
+     * @param server Server to Update
+     * @param template Server Template
+     * @param version Server Version (may be null)
+     * @return Success Status
+     */
+    public boolean update(UUID player, SubServer server, ServerTemplate template, Version version) {
+        return update(player, server, template, version, null);
+    }
+
+    /**
+     * Update a SubServer
+     *
+     * @param server Server to Update
+     * @param template Server Template
+     * @param version Server Version (may be null)
+     * @param callback Callback
+     * @return Success Status
+     */
+    public boolean update(SubServer server, ServerTemplate template, Version version, Consumer<Boolean> callback) {
+        return update(null, server, template, version, callback);
+    }
+
+    /**
+     * Update a SubServer
+     *
+     * @param server Server to Update
+     * @param template Server Template
+     * @param version Server Version (may be null)
+     * @return Success Status
+     */
+    public boolean update(SubServer server, ServerTemplate template, Version version) {
+        return update(null, server, template, version);
+    }
 
     /**
      * Update a SubServer
@@ -267,19 +335,7 @@ public abstract class SubCreator {
      * @return Success Status
      */
     public boolean update(UUID player, SubServer server, Version version) {
-        return update(player, server, version, null);
-    }
-
-    /**
-     * Update a SubServer
-     *
-     * @param server Server to Update
-     * @param version Server Version (may be null)
-     * @param callback Callback
-     * @return Success Status
-     */
-    public boolean update(SubServer server, Version version, Callback<Boolean> callback) {
-        return update(null, server, version, callback);
+        return update(player, server, null, version);
     }
 
     /**
@@ -462,8 +518,28 @@ public abstract class SubCreator {
      */
     public abstract ServerTemplate getTemplate(String name);
 
+    /**
+     * Create a SubCreator Template
+     *
+     * @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, 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
@@ -219,6 +209,22 @@ public interface SubServer extends Server {
      */
     boolean isRunning();
 
+    /**
+     * If the Server is Online<br>
+     * <b>This method can only be true when a SubData connection is made!</b>
+     *
+     * @return Online Status
+     */
+    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
      *
@@ -317,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

@@ -3,7 +3,8 @@ package net.ME1312.SubServers.Bungee.Host;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
 
-import java.util.*;
+import java.util.LinkedList;
+import java.util.UUID;
 
 /**
  * API-Safe SubServer Layout Class
@@ -87,13 +88,8 @@ public abstract class SubServerController {
         }
 
         @Override
-        public int permaEdit(ObjectMap<String> edit) {
-            return SubServerController.this.edit(edit);
-        }
-
-        @Override
-        public int permaEdit(UUID player, ObjectMap<String> edit) {
-            return SubServerController.this.edit(player, edit);
+        public int edit(UUID player, ObjectMap<String> edit, boolean perma) {
+            return SubServerController.this.edit(player, edit, perma);
         }
 
         @Override
@@ -235,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
      */
@@ -256,19 +252,10 @@ public abstract class SubServerController {
      *
      * @param player Player Editing
      * @param edit Edits
+     * @param perma Saves Changes
      * @return Success Status
      */
-    public int edit(UUID player, ObjectMap<String> edit) {
-        return -1;
-    }
-
-    /**
-     * Edits the Server
-     *
-     * @param edit Edits
-     * @return Success Status
-     */
-    public int edit(ObjectMap<String> edit) {
+    protected int edit(UUID player, ObjectMap<String> edit, boolean perma) {
         return -1;
     }
 

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

@@ -1,25 +1,28 @@
 package net.ME1312.SubServers.Bungee.Host;
 
+import net.ME1312.Galaxi.Library.Container.ContainedPair;
+import net.ME1312.Galaxi.Library.Container.Pair;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.SubServers.Bungee.Event.SubEditServerEvent;
 import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
 import net.ME1312.SubServers.Bungee.SubAPI;
 
 import java.io.File;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
-import java.util.*;
+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 {
-    private List<NamedContainer<String, String>> incompatibilities = new ArrayList<NamedContainer<String, String>>();
+    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 started;
-    private boolean updating;
+    protected boolean registered, started, stopping, updating;
 
     /**
      * Creates a SubServer
@@ -55,46 +58,54 @@ 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);
+    public int edit(UUID player, ObjectMap<String> edit) {
+        return edit(player, edit, false);
+    }
+
+    public int permaEdit(UUID player, ObjectMap<String> edit) {
+        return edit(player, edit, true);
+    }
+
+    /**
+     * Edits the Server
+     *
+     * @param player Player Editing
+     * @param edit Edits
+     * @param perma Saves Changes
+     * @return Success Status
+     */
+    protected int edit(UUID player, ObjectMap<String> edit, boolean perma) {
+        return -1;
     }
 
     @Override
-    public boolean stop() {
-        return stop(null);
-    }
-
-    @Override
-    public boolean terminate() {
-        return terminate(null);
-    }
-
-    @Override
-    public boolean command(String command) {
-        return command(null, command);
-    }
-
-    @Override
-    public int permaEdit(ObjectMap<String> edit) {
-        return permaEdit(null, edit);
+    protected final boolean isRegistered() {
+        return registered;
     }
 
     @Override
     public boolean isAvailable() {
-        return !updating && getHost().isAvailable();
+        return registered && !updating && getHost().isAvailable();
+    }
+
+    @Override
+    public boolean isOnline() {
+        return isRunning() && started;
+    }
+
+    @Override
+    public boolean isStopping() {
+        return isRunning() && stopping;
     }
 
     @Override
     public void setTemplate(String template) {
-        SubAPI.getInstance().getInternals().getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("template", template), false));
         this.templateV = null;
         this.templateS = template;
     }
 
     @Override
     public void setTemplate(SubCreator.ServerTemplate template) {
-        SubAPI.getInstance().getInternals().getPluginManager().callEvent(new SubEditServerEvent(null, this, new NamedContainer<String, Object>("template", (template != null)?template.getName():null), false));
         this.templateV = template;
         this.templateS = (template != null)?template.getName():null;
     }
@@ -103,23 +114,18 @@ 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) {
             if (!equals(s)) {
-                NamedContainer<String, String> info = new NamedContainer<String, String>(s.getHost().getName(), s.getName());
+                Pair<String, String> info = new ContainedPair<String, String>(s.getHost().getName(), s.getName());
                 if (isCompatible(s)) {
                     incompatibilities.add(info);
                     if (s.isCompatible(this)) toggleCompatibility(this);
@@ -133,17 +139,17 @@ public abstract class SubServerImpl extends ServerImpl implements SubServer {
 
     @Override
     public boolean isCompatible(SubServer server) {
-        return !incompatibilities.contains(new NamedContainer<String, String>(server.getHost().getName(), server.getName()));
+        return !incompatibilities.contains(new ContainedPair<String, String>(server.getHost().getName(), server.getName()));
     }
 
     @Override
     public List<SubServer> getIncompatibilities() {
         List<SubServer> servers = new ArrayList<SubServer>();
-        List<NamedContainer<String, String>> temp = new ArrayList<NamedContainer<String, String>>();
+        List<Pair<String, String>> temp = new ArrayList<Pair<String, String>>();
         temp.addAll(incompatibilities);
-        for (NamedContainer<String, String> info : temp) {
+        for (Pair<String, String> info : temp) {
             try {
-                SubServer server = SubAPI.getInstance().getHost(info.name()).getSubServer(info.get());
+                SubServer server = SubAPI.getInstance().getHost(info.key()).getSubServer(info.value());
                 if (server == null) throw new NullPointerException();
                 servers.add(server);
             } catch (Throwable e) {
@@ -162,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();
@@ -176,6 +187,8 @@ public abstract class SubServerImpl extends ServerImpl implements SubServer {
         sinfo.set("dir", getPath());
         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,15 +1,12 @@
 package net.ME1312.SubServers.Bungee;
 
 import net.ME1312.Galaxi.Library.Platform;
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.Galaxi.Library.Version.Version;
-import net.ME1312.SubServers.Bungee.Library.Compatibility.Galaxi.GalaxiInfo;
+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
@@ -25,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 ***");
@@ -49,62 +47,52 @@ public final class Launch {
             parser.accepts("noconsole");
             joptsimple.OptionSet options = parser.parse(args);
             if(options.has("version") || options.has("v")) {
-                Version galaxi = GalaxiInfo.getVersion();
-                Version galaxibuild = GalaxiInfo.getSignature();
-
                 System.out.println("");
-                System.out.println(Platform.getSystemName() + ' ' + Platform.getSystemVersion() + ((!Platform.getSystemArchitecture().equals("unknown"))?" [" + Platform.getSystemArchitecture() + ']':"") + ',');
+                System.out.println(Platform.getSystemName() + ' ' + Platform.getSystemVersion() + ((Platform.getSystemBuild() != null)?" (" + Platform.getSystemBuild() + ')':"") + ((!Platform.getSystemArchitecture().equals("unknown"))?" [" + Platform.getSystemArchitecture() + ']':"") + ',');
                 System.out.println("Java " + Platform.getJavaVersion() + ((!Platform.getJavaArchitecture().equals("unknown"))?" [" + Platform.getJavaArchitecture() + ']':"") + ',');
-                if (galaxi != null) System.out.println("GalaxiEngine v" + galaxi.toExtendedString() + ((galaxibuild != null)?" (" + galaxibuild + ')':"") + ',');
-                System.out.println("BungeeCord" + net.md_5.bungee.Bootstrap.class.getPackage().getImplementationVersion() + ((patched)?" [Patched]":"") + ',');
+                System.out.println("BungeeCord " + net.md_5.bungee.Bootstrap.class.getPackage().getImplementationVersion() + ((patched)?" [Patched]":"") + ',');
                 System.out.println("SubServers.Bungee v" + SubProxy.version.toExtendedString() + ((SubProxy.class.getPackage().getSpecificationTitle() != null)?" (" + SubProxy.class.getPackage().getSpecificationTitle() + ')':""));
                 System.out.println("");
             } else {
-                boolean gb = Util.getDespiteException(() -> Class.forName("net.md_5.bungee.util.GalaxiBungeeInfo").getMethod("get").getReturnType().equals(Class.forName("net.ME1312.Galaxi.Plugin.PluginInfo")), false);
-                if (gb) {
-                    Util.reflect(net.md_5.bungee.log.LoggingOutputStream.class.getMethod("setLogger", Logger.class, String.class), null,
-                            Util.reflect(net.md_5.bungee.log.BungeeLogger.class.getMethod("get", String.class), null, "SubServers"), "net.ME1312.SubServers.Bungee.");
-                } else {
-                    System.out.println("");
-                    System.out.println("*******************************************");
-                    System.out.println("***  Warning: this build is unofficial  ***");
+                System.out.println("");
+                System.out.println("*******************************************");
+                System.out.println("***  Warning: this build is unofficial  ***");
+                System.out.println("***                                     ***");
+                System.out.println("*** Please report all issues to ME1312, ***");
+                System.out.println("***   NOT the Spigot Team. Thank You!   ***");
+                System.out.println("*******************************************");
+                try {
+                    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(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:  ***");
+                            System.out.println("***  http://ci.md-5.net/job/BungeeCord  ***");
+                            System.out.println("*** Errors may arise on older versions! ***");
+                            System.out.println("*******************************************");
+                        }
+                    } else throw new Exception();
+                } catch (Exception e) {
+                    System.out.println("*** Problem checking BungeeCord version ***");
+                    System.out.println("***    BungeeCord could be outdated.    ***");
                     System.out.println("***                                     ***");
-                    System.out.println("*** Please report all issues to ME1312, ***");
-                    System.out.println("***   NOT the Spigot Team. Thank You!   ***");
+                    System.out.println("*** Errors may arise on older versions! ***");
                     System.out.println("*******************************************");
-                    try {
-                        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);
-                            if (date.before(line.getTime())) {
-                                System.out.println("***   Warning: BungeeCord is outdated   ***");
-                                System.out.println("***  Please download a new build from:  ***");
-                                System.out.println("***  http://ci.md-5.net/job/BungeeCord  ***");
-                                System.out.println("*** Errors may arise on older versions! ***");
-                                System.out.println("*******************************************");
-                            }
-                        } else throw new Exception();
-                    } catch (Exception e) {
-                        System.out.println("*** Problem checking BungeeCord version ***");
-                        System.out.println("***    BungeeCord could be outdated.    ***");
-                        System.out.println("***                                     ***");
-                        System.out.println("*** Errors may arise on older versions! ***");
-                        System.out.println("*******************************************");
-                    }
-                    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);
-                if (!gb) plugin.getLogger().info("Enabled " + plugin.getBungeeName() + " version " + plugin.getVersion());
+                plugin.getLogger().info("Enabled " + plugin.getBungeeName() + " version " + plugin.getVersion());
                 plugin.start();
 
                 if (!options.has("noconsole")) {
-                    if (!gb) try {
-                        if (Util.getDespiteException(() -> Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole").getMethod("readCommands") != null, false)) { // Waterfall Setup
+                    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 (Util.getDespiteException(() -> Class.forName("io.github.waterfallmc.waterfall.console.WaterfallConsole").getMethod("start") != null, false)) {
+                        } 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 {

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

@@ -1,55 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library.Compatibility;
-
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.plugin.Command;
-import net.md_5.bungee.api.plugin.TabExecutor;
-
-import java.util.List;
-
-/**
- * Command Layout Class that implements all possible features (Base Version)
- */
-public abstract class CommandX extends Command implements TabExecutor {
-
-    /**
-     * Create a Command
-     *
-     * @param name Command Name
-     */
-    public CommandX(String name) {
-        super(name);
-    }
-
-    /**
-     * Create a Command
-     *
-     * @param name Command Name
-     * @param permission Command Permission
-     * @param aliases Command Aliases
-     */
-    public CommandX(String name, String permission, String... aliases) {
-        super(name, permission, aliases);
-    }
-
-    /**
-     * Suggest Arguments
-     *
-     * @param sender Sender
-     * @param args Arguments (including the final unfinished one)
-     * @return An Error Message (if there was one, otherwise null) and a List of Suggestions
-     */
-    public abstract NamedContainer<String, List<String>> suggestArguments(CommandSender sender, String[] args);
-
-    /**
-     * Override the BungeeCord Method of {@link #suggestArguments(CommandSender, String[])}
-     *
-     * @param sender Sender
-     * @param args Arguments (including the final unfinished one)
-     * @return A Collection of Suggestions
-     */
-    @Override
-    public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
-        return suggestArguments(sender, args).get();
-    }
-}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/Compatibility/Galaxi/GalaxiCommand.java

@@ -1,57 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library.Compatibility.Galaxi;
-
-import net.ME1312.Galaxi.Library.Util;
-import net.md_5.bungee.api.plugin.Command;
-
-/**
- * Galaxi Command Compatibility Class
- */
-public class GalaxiCommand {
-
-    /**
-     * Group similar Commands
-     *
-     * @param commands Command Classes
-     */
-    @SafeVarargs
-    public static void group(Class<? extends Command>... commands) {
-        Util.isException(() -> Util.reflect(GalaxiCommandWrapper.class.getDeclaredConstructor(Class[].class), (Object) commands));
-    }
-
-    /**
-     * Set the Description of a Command
-     *
-     * @param command Command
-     * @param value Value
-     * @return The Command
-     */
-    public static Command description(Command command, String value) {
-        Util.isException(() -> Util.reflect(Class.forName("net.ME1312.Galaxi.Plugin.Command.Command").getMethod("description", String.class), command, value));
-        return command;
-    }
-
-    /**
-     * Set the Help Page for a Command
-     *
-     * @param command Command
-     * @param lines Help Page Lines
-     * @return The Command
-     */
-    public static Command help(Command command, String... lines) {
-        Util.isException(() -> Util.reflect(Class.forName("net.ME1312.Galaxi.Plugin.Command.Command").getMethod("help", String[].class), command, (Object) lines));
-        return command;
-    }
-
-    /**
-     * Set the Usage of a Command
-     *
-     * @param command Command
-     * @param args Argument Placeholders
-     * @return The Command
-     */
-    public static Command usage(Command command, String... args) {
-        Util.isException(() -> Util.reflect(Class.forName("net.ME1312.Galaxi.Plugin.Command.Command").getMethod("usage", String[].class), command, (Object) args));
-        return command;
-    }
-
-}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/Compatibility/Galaxi/GalaxiCommandWrapper.java

@@ -1,75 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library.Compatibility.Galaxi;
-
-import net.ME1312.Galaxi.Galaxi;
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.Galaxi.Plugin.Command.Command;
-import net.ME1312.Galaxi.Plugin.Command.CommandSender;
-import net.ME1312.Galaxi.Plugin.Command.CompletionHandler;
-import net.ME1312.Galaxi.Plugin.PluginManager;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-class GalaxiCommandWrapper extends Command implements CompletionHandler {
-    private HashMap<String, Command> forwards = new HashMap<String, Command>();
-    private Command data;
-
-    @SafeVarargs
-    GalaxiCommandWrapper(Class<? extends Command>... commands) {
-        super(Galaxi.getInstance().getAppInfo());
-
-        Map<String, Command> registered = Util.getDespiteException(() -> Util.reflect(PluginManager.class.getDeclaredField("commands"), Galaxi.getInstance().getPluginManager()), null);
-        ArrayList<String> tmp = new ArrayList<String>();
-        tmp.addAll(registered.keySet());
-        for (String alias : tmp) {
-            Command command = registered.get(alias);
-            for (Class<? extends Command> type : commands) {
-                if (type.isInstance(command)) {
-                    forwards.put(alias, command);
-                    if (data == null) data = command;
-                    registered.remove(alias);
-                    break;
-                }
-            }
-        }
-
-        register(forwards.keySet().toArray(new String[0]));
-    }
-
-    @Override
-    public void command(CommandSender sender, String label, String[] args) {
-        if (forwards.keySet().contains(label.toLowerCase())) {
-            forwards.get(label.toLowerCase()).command(sender, label, args);
-        } else {
-            throw new IllegalStateException("Command label not recognised in group: " + forwards.keySet());
-        }
-    }
-
-    @Override
-    public String[] complete(CommandSender sender, String label, String[] args) {
-        if (forwards.keySet().contains(label.toLowerCase())) {
-            Command command = forwards.get(label.toLowerCase());
-            if (command.autocomplete() != null) {
-                return command.autocomplete().complete(sender, label, args);
-            } else return new String[0];
-        } else {
-            throw new IllegalStateException("Command label not recognised in group: " + forwards.keySet());
-        }
-    }
-
-    @Override
-    public String description() {
-        return (data == null)?super.description():data.description();
-    }
-
-    @Override
-    public String[] help() {
-        return (data == null)?super.help():data.help();
-    }
-
-    @Override
-    public String[] usage() {
-        return (data == null)?super.usage():data.usage();
-    }
-}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/Compatibility/Galaxi/GalaxiEventListener.java

@@ -1,40 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library.Compatibility.Galaxi;
-
-import net.ME1312.Galaxi.Event.ConsoleInputEvent;
-import net.ME1312.Galaxi.Galaxi;
-import net.ME1312.Galaxi.Library.Event.ListenerOrder;
-import net.ME1312.Galaxi.Library.Event.Subscribe;
-import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
-import net.ME1312.SubServers.Bungee.SubProxy;
-
-/**
- * Galaxi Event Listener Class
- */
-public class GalaxiEventListener {
-    private SubProxy plugin;
-
-    /**
-     * Create & Register a Galaxi Event Listener
-     *
-     * @param plugin Plugin
-     */
-    public GalaxiEventListener(SubProxy plugin) throws Throwable {
-        this.plugin = plugin;
-
-        Galaxi.getInstance().getPluginManager().registerListeners(Galaxi.getInstance().getAppInfo(), this);
-        plugin.canSudo = true;
-    }
-
-    @Subscribe(order = ListenerOrder.FIRST, override = true)
-    public void sudo(ConsoleInputEvent e) {
-        if (plugin.sudo != null) {
-            e.setCancelled(true);
-            if (e.getInput().equalsIgnoreCase("exit")) {
-                plugin.sudo = null;
-                Logger.get("SubServers").info("Reverting to the BungeeCord Console");
-            } else {
-                plugin.sudo.command(e.getInput());
-            }
-        }
-    }
-}

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/Compatibility/Galaxi/GalaxiInfo.java

@@ -1,47 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library.Compatibility.Galaxi;
-
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.Galaxi.Library.Version.Version;
-
-import java.lang.annotation.Annotation;
-import java.util.jar.Manifest;
-
-/**
- * Galaxi Info Class
- */
-public class GalaxiInfo {
-    private GalaxiInfo() {}
-
-    @SuppressWarnings("unchecked")
-    private static <A extends Annotation> Class<A> asAnnotation(Class<?> clazz) {
-        return (Class<A>) clazz;
-    }
-
-    /**
-     * Get the Galaxi Version
-     *
-     * @return Galaxi Version
-     */
-    public static Version getVersion() {
-        return Util.getDespiteException(() -> Version.fromString((String) Class.forName("net.ME1312.Galaxi.Plugin.App").getMethod("version").invoke(
-                Class.forName("net.ME1312.Galaxi.Engine.GalaxiEngine").getAnnotation(asAnnotation(Class.forName("net.ME1312.Galaxi.Plugin.App"))))), null);
-    }
-
-    /**
-     * Get the Galaxi Build Signature
-     *
-     * @return Galaxi Build Signature
-     */
-    public static Version getSignature() {
-        try {
-            Manifest manifest = new Manifest(Class.forName("net.ME1312.Galaxi.Engine.GalaxiEngine").getResourceAsStream("/META-INF/GalaxiEngine.MF"));
-            if (manifest.getMainAttributes().getValue("Implementation-Version") != null && manifest.getMainAttributes().getValue("Implementation-Version").length() > 0) {
-                return new Version(manifest.getMainAttributes().getValue("Implementation-Version"));
-            } else {
-                return null;
-            }
-        } catch (Throwable e) {
-            return null;
-        }
-    }
-}

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

@@ -1,13 +1,19 @@
 package net.ME1312.SubServers.Bungee.Library.Compatibility;
 
-import com.google.common.io.Resources;
-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
@@ -27,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) {
@@ -40,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);
@@ -53,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

@@ -1,30 +1,23 @@
 package net.ME1312.SubServers.Bungee.Library.Compatibility;
 
 import net.ME1312.SubServers.Bungee.SubAPI;
-import net.md_5.bungee.api.config.ServerInfo;
 
-import java.util.Collection;
+import net.md_5.bungee.api.config.ServerInfo;
+import net.md_5.bungee.util.CaseInsensitiveMap;
+
 import java.util.Map;
-import java.util.Set;
+import java.util.Map.Entry;
 
 /**
  * Legacy Server Map Translation Class
  */
-public class LegacyServerMap implements Map<String, ServerInfo> {
-    private final Map<String, ServerInfo> m;
+public class LegacyServerMap extends CaseInsensitiveMap<ServerInfo> {
+    public LegacyServerMap() {
 
-    /**
-     * Translate Legacy Server Map Modifications
-     *
-     * @param map Legacy Server Map
-     */
-    public LegacyServerMap(Map<String, ServerInfo> map) {
-        this.m = map;
     }
 
-    @Override
-    public ServerInfo get(Object key) {
-        return m.get(key);
+    public LegacyServerMap(Map<String, ServerInfo> map) {
+        for (Entry<String, ServerInfo> e : map.entrySet()) super.put(e.getKey(), e.getValue());
     }
 
     @SuppressWarnings("deprecation")
@@ -35,7 +28,7 @@ public class LegacyServerMap implements Map<String, ServerInfo> {
                    s = getOrDefault(key, null);
 
         if (n != null)
-            m.put(n.getName(), n);
+            super.put(n.getName(), n);
         return s;
     }
 
@@ -45,60 +38,14 @@ public class LegacyServerMap implements Map<String, ServerInfo> {
             ServerInfo s = getOrDefault(key, null);
             if (s != null) {
                 if (SubAPI.getInstance().removeServer((String) key))
-                    m.remove(key);
+                    super.remove(key);
                 return s;
             } else return null;
         } else return null;
     }
 
-    @Override
-    public void putAll(Map<? extends String, ? extends ServerInfo> m) {
-        if (m.size() > 0) {
-            for (Map.Entry<? extends String, ? extends ServerInfo> e : m.entrySet()) {
-                put(e.getKey(), e.getValue());
-            }
-        }
-    }
-
     @Override
     public void clear() {
         // Disallow removing all servers
     }
-
-    @Override
-    public int size() {
-        return m.size();
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return m.isEmpty();
-    }
-
-    @Override
-    public boolean containsKey(Object key) {
-        return m.containsKey(key);
-    }
-
-    @Override
-    public boolean containsValue(Object value) {
-        return m.containsValue(value);
-    }
-
-    @Override
-    public Set<String> keySet() {
-        return m.keySet();
-    }
-
-    @Override
-    public Collection<ServerInfo> values() {
-        return m.values();
-    }
-
-    @Override
-    public Set<Entry<String, ServerInfo>> entrySet() {
-        return m.entrySet();
-    }
-
-
 }

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

@@ -1,56 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library.Compatibility;
-
-import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubServers.Bungee.SubProxy;
-
-import java.util.HashMap;
-import java.util.logging.Handler;
-import java.util.logging.LogRecord;
-
-/**
- * Logger Compatibility Class
- */
-public class Logger {
-    private static final HashMap<String, java.util.logging.Logger> existing = new HashMap<String, java.util.logging.Logger>();
-    private static SubProxy plugin;
-
-    /**
-     * Get a logger
-     *
-     * @param prefix Prefix
-     * @return Logger
-     */
-    @SuppressWarnings("deprecation")
-    public static java.util.logging.Logger get(String prefix) {
-        if (!existing.keySet().contains(prefix)) {
-            java.util.logging.Logger log = Util.getDespiteException(() -> Util.reflect(Class.forName("net.ME1312.Galaxi.Library.Log.Logger").getDeclaredMethod("toPrimitive"),
-                    Util.reflect(Class.forName("net.ME1312.Galaxi.Library.Log.Logger").getConstructor(String.class), prefix)), null);
-
-            if (log == null) {
-                log = java.util.logging.Logger.getAnonymousLogger();
-                log.setUseParentHandlers(false);
-                log.addHandler(new Handler() {
-                    private boolean open = true;
-
-                    @Override
-                    public void publish(LogRecord record) {
-                        if (open)
-                            plugin.getLogger().log(record.getLevel(), prefix + " > " + record.getMessage(), record.getParameters());
-                    }
-
-                    @Override
-                    public void flush() {
-
-                    }
-
-                    @Override
-                    public void close() throws SecurityException {
-                        open = false;
-                    }
-                });
-            }
-            existing.put(prefix, log);
-        }
-        return existing.get(prefix);
-    }
-}

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

@@ -1,9 +1,9 @@
 package net.ME1312.SubServers.Bungee.Library.Compatibility;
 
-public class Plugin extends net.md_5.bungee.api.plugin.Plugin {
+public final class Plugin extends net.md_5.bungee.api.plugin.Plugin {
 
-    @Override
-    public void onEnable() {
-        throw new IllegalStateException("SubServers.Bungee does not run as a plugin, but a wrapper. For more information on how to install, visit this page: https://github.com/ME1312/SubServers-2/wiki/Install");
+    @Deprecated
+    public Plugin() {
+        throw new IllegalStateException("SubServers.Bungee does not run as a plugin, but a wrapper. For more information on how to install, please visit this page: https://github.com/ME1312/SubServers-2/wiki/Installation");
     }
 }

SubServers.Bungee/src/net/ME1312/SubServers/Bungee/Library/Compatibility/mc1_13/CommandX.java

@@ -1,74 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library.Compatibility.mc1_13;
-
-import net.ME1312.Galaxi.Library.Container.NamedContainer;
-import net.md_5.bungee.api.CommandSender;
-
-import java.util.LinkedList;
-import java.util.List;
-
-/**
- * Command Layout Class that implements all possible features (1.13 Version)
- */
-public class CommandX extends net.ME1312.SubServers.Bungee.Library.Compatibility.CommandX/* implements TabValidator */ {
-    public final net.ME1312.SubServers.Bungee.Library.Compatibility.CommandX command;
-
-    /**
-     * Create a Command
-     *
-     * @param other CommandX from previous version
-     */
-    public CommandX(net.ME1312.SubServers.Bungee.Library.Compatibility.CommandX other) {
-        super(other.getName());
-        command = other;
-    }
-
-    /**
-     * Override BungeeCord Method for the previously used one
-     *
-     * @param sender Sender
-     * @param args Arguments
-     */
-    @Override
-    public void execute(CommandSender sender, String[] args) {
-        command.execute(sender, args);
-    }
-
-    @Override
-    public NamedContainer<String, List<String>> suggestArguments(CommandSender sender, String[] args) {
-        return command.suggestArguments(sender, args);
-    }
-
-    /**
-     * Validate a Command (Override for custom)
-     *
-     * @param sender Sender
-     * @param command Command to validate
-     * @return NamedContainer with a String error message and a Integer that represents where the command was deemed invalid
-     */
-    public NamedContainer<String, Integer> validateCommand(CommandSender sender, String command) {
-        List<NamedContainer<String, Integer>> split = new LinkedList<NamedContainer<String, Integer>>();
-        String cmd = command;
-        int i;
-        while ((i = cmd.indexOf((int) ' ')) < 0) {
-            i++;
-            String arg = cmd.substring(i);
-            split.add(new NamedContainer<>(arg.contains(" ")?arg.substring(0, arg.indexOf((int) ' ')):arg, i));
-            cmd = arg;
-        }
-
-        List<String> args = new LinkedList<String>();
-        NamedContainer<String, Integer> response = null;
-        i = 0;
-        for (NamedContainer<String, Integer> arg : split) {
-            if (i > 0) {
-                args.add(arg.name());
-                NamedContainer<String, List<String>> suggestions = suggestArguments(sender, args.toArray(new String[args.size() - 1]));
-                if (suggestions.name() != null) response = new NamedContainer<>(suggestions.name(), arg.get());
-            }
-            i++;
-        }
-        return response;
-    }
-
-    // TODO Override the original validator method
-}

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

@@ -113,13 +113,36 @@ 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");
                     }
                 }
 
                 existing = updated.clone();
                 i++;
+            } if (was.compareTo(new Version("20w34a")) <= 0) {
+                if (existing.getMap("Settings", new YAMLSection()).contains("Smart-Fallback") && existing.getMap("Settings").isBoolean("Smart-Fallback")) {
+                    YAMLSection smart_fallback = new YAMLSection();
+                    smart_fallback.set("Enabled", existing.getMap("Settings").getBoolean("Smart-Fallback"));
+                    smart_fallback.set("Fallback", existing.getMap("Settings").getBoolean("Smart-Fallback"));
+                    updated.getMap("Settings").set("Smart-Fallback", smart_fallback);
+                }
+                if (existing.getMap("Settings", new YAMLSection()).contains("Override-Bungee-Commands") && existing.getMap("Settings").isBoolean("Override-Bungee-Commands")) {
+                    List<String> overrides = new LinkedList<>();
+                    if (!existing.getMap("Settings").getBoolean("Override-Bungee-Commands")) {
+                        overrides.add("/server");
+                        overrides.add("/glist");
+                    }
+                    updated.getMap("Settings").set("Disabled-Overrides", overrides);
+                }
+
+                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();
@@ -132,8 +155,16 @@ public class ConfigUpdater {
         if (i > 0) {
             YAMLSection settings = new YAMLSection();
             settings.set("Version", ((now.compareTo(was) <= 0)?was:now).toString());
-            settings.set("Smart-Fallback", updated.getMap("Settings", new YAMLSection()).getBoolean("Smart-Fallback", true));
-            settings.set("Override-Bungee-Commands", updated.getMap("Settings", new YAMLSection()).getBoolean("Override-Bungee-Commands", true));
+            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));
+            smart_fallback.set("Fallback", updated.getMap("Settings", new YAMLSection()).getMap("Smart-Fallback", new YAMLSection()).getBoolean("Fallback", true));
+            smart_fallback.set("Reconnect", updated.getMap("Settings", new YAMLSection()).getMap("Smart-Fallback", new YAMLSection()).getBoolean("Reconnect", false));
+            smart_fallback.set("DNS-Forward", updated.getMap("Settings", new YAMLSection()).getMap("Smart-Fallback", new YAMLSection()).getBoolean("DNS-Forward", false));
+            settings.set("Smart-Fallback", smart_fallback);
 
             YAMLSection upnp = new YAMLSection();
             upnp.set("Forward-Proxy", updated.getMap("Settings", new YAMLSection()).getMap("UPnP", new YAMLSection()).getBoolean("Forward-Proxy", true));
@@ -142,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);
@@ -155,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);
@@ -202,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");
                     }
                 }
@@ -229,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);
@@ -278,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();
@@ -291,6 +322,13 @@ public class ConfigUpdater {
                     }
                 }
 
+                existing = updated.clone();
+                i++;
+            } if (was.compareTo(new Version("22w07c")) <= 0) {
+                if (existing.contains("Lang")) {
+                    updated.getMap("Lang").remove("Command.Teleport");
+                }
+
                 existing = updated.clone();
                 i++;
             }// if (was.compareTo(new Version("99w99a")) <= 0) {
@@ -310,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:");
@@ -322,19 +361,26 @@ 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$");
             def.put("Command.Generic.Exception", "&cSubServers &4&l\\u00BB&c An unexpected exception has occurred while parsing this command");
-            def.put("Command.Generic.Invalid-Subcommand", "&cSubServers &4&l\\u00BB&c Unknown sub-command: $str$");
+            def.put("Command.Generic.Invalid-Subcommand", "&cSubServers &4&l\\u00BB&c Unknown sub-command: &4$str$");
             def.put("Command.Generic.Invalid-Permission", "&cSubServers &4&l\\u00BB&c You need &4&n$str$&c to use this command");
             def.put("Command.Generic.Invalid-Select-Permission", "&cSubServers &4&l\\u00BB&c You don't have permission to select &4$str$");
-            def.put("Command.Generic.Unknown-Proxy", "&cSubServers &4&l\\u00BB&c There is no proxy with name &4$str$");
-            def.put("Command.Generic.Unknown-Host", "&cSubServers &4&l\\u00BB&c There is no host with name &4$str$");
-            def.put("Command.Generic.Unknown-Group", "&cSubServers &4&l\\u00BB&c There is no group with name &4$str$");
-            def.put("Command.Generic.Unknown-Server", "&cSubServers &4&l\\u00BB&c There is no server with name &4$str$");
-            def.put("Command.Generic.Unknown-SubServer", "&cSubServers &4&l\\u00BB&c There is no subserver with name &4$str$");
-            def.put("Command.Generic.Unknown-Player", "&cSubServers &4&l\\u00BB&c There is no player with name &4$str$");
+            def.put("Command.Generic.Unknown-Proxy", "&cSubServers &4&l\\u00BB&c There is no proxy named &4$str$");
+            def.put("Command.Generic.Unknown-Host", "&cSubServers &4&l\\u00BB&c There is no host named &4$str$");
+            def.put("Command.Generic.Unknown-Group", "&cSubServers &4&l\\u00BB&c There is no group named &4$str$");
+            def.put("Command.Generic.Unknown-Server", "&cSubServers &4&l\\u00BB&c There is no server named &4$str$");
+            def.put("Command.Generic.Unknown-SubServer", "&cSubServers &4&l\\u00BB&c There is no subserver named &4$str$");
+            def.put("Command.Generic.Unknown-Player", "&cSubServers &4&l\\u00BB&c There is no player named &4$str$");
             def.put("Command.Generic.No-Servers-On-Host", "&7SubServers &8&l\\u00BB&7 There are no servers on host &f$str$");
             def.put("Command.Generic.No-SubServers-On-Host", "&7SubServers &8&l\\u00BB&7 There are no subservers on host &f$str$");
             def.put("Command.Generic.No-Servers-In-Group", "&7SubServers &8&l\\u00BB&7 There are no servers in group &f$str$");
@@ -363,7 +409,7 @@ public class ConfigUpdater {
             def.put("Command.List.Header", "&7: ");
             def.put("Command.List.Divider", "&7, ");
             def.put("Command.List.Empty", "&7(none)");
-            def.put("Command.Info", "&7SubServers &8&l\\u00BB&7 Info on $str$&7: &r");
+            def.put("Command.Info", "&7SubServers &8&l\\u00BB&7 Info on $str$: &r");
             def.put("Command.Info.Unknown", "&cSubServers &4&l\\u00BB&c There is no object with that name");
             def.put("Command.Info.Unknown-Type", "&cSubServers &4&l\\u00BB&c There is no object type with that name");
             def.put("Command.Info.Unknown-Proxy", "&cSubServers &4&l\\u00BB&c There is no proxy with that name");
@@ -394,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");
@@ -404,6 +451,7 @@ public class ConfigUpdater {
             def.put("Command.Creator.Host-Disabled", "&cSubServers &4&l\\u00BB&c That host is not enabled");
             def.put("Command.Creator.Unknown-Template", "&cSubServers &4&l\\u00BB&c There is no template with that name");
             def.put("Command.Creator.Template-Disabled", "&cSubServers &4&l\\u00BB&c That template is not enabled");
+            def.put("Command.Creator.Template-Invalid", "&cSubServers &4&l\\u00BB&c That template does not support subserver updating");
             def.put("Command.Creator.Version-Required", "&cSubServers &4&l\\u00BB&c That template requires a Minecraft version to be specified");
             def.put("Command.Creator.Invalid-Port", "&cSubServers &4&l\\u00BB&c Invalid port number");
             def.put("Command.Update", "&aSubServers &2&l\\u00BB&a Updating &2$int$&a subserver(s)");
@@ -416,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<--");
@@ -430,8 +482,6 @@ public class ConfigUpdater {
             def.put("Interface.Generic.Invalid-Permission", "&4You need &n$str$");
             def.put("Interface.Proxy-Menu.Proxy-Player-Count", "&2$int$ Player(s) Online");
             def.put("Interface.Proxy-Menu.Proxy-Master", "&8Master Proxy");
-            def.put("Interface.Proxy-Menu.Proxy-SubData", "&9SubData Only");
-            def.put("Interface.Proxy-Menu.Proxy-Redis", "&7Redis Only");
             def.put("Interface.Proxy-Menu.Proxy-Disconnected", "&4Disconnected");
             def.put("Interface.Host-Menu.Title", "Host Menu");
             def.put("Interface.Host-Menu.Host-Unavailable", "&4Unavailable");
@@ -470,9 +520,10 @@ public class ConfigUpdater {
             def.put("Interface.Host-SubServer.Title", "Host/$str$/SubServers");
             def.put("Interface.Group-Menu.Title", "Group Menu");
             def.put("Interface.Group-Menu.Group-Server-Count", "&9$int$ Server(s)");
-            def.put("Interface.Group-Menu.No-Groups", "&c&oThere are No Groups");
+            def.put("Interface.Group-Menu.Ungrouped", "&7(ungrouped)");
             def.put("Interface.Group-Menu.Server-Menu", "&a&lView All Servers");
             def.put("Interface.Group-SubServer.Title", "Group/$str$/Servers");
+            def.put("Interface.Group-SubServer.Title-Ungrouped", "Ungrouped Server Menu");
             def.put("Interface.Server-Menu.Title", "Server Menu");
             def.put("Interface.Server-Menu.Server-Player-Count", "&2$int$ Player(s) Online");
             def.put("Interface.Server-Menu.Server-External", "&7External Server");
@@ -481,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

@@ -0,0 +1,135 @@
+package net.ME1312.SubServers.Bungee.Library;
+
+import net.ME1312.Galaxi.Library.Directories;
+
+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;
+
+/**
+ * File Scanner Base Class
+ */
+public abstract class FileScanner {
+
+    /**
+     * Scan a Directory
+     *
+     * @param dir Directory
+     * @param whitelist File Whitelist
+     */
+    protected void scan(File dir, String... whitelist) throws IOException {
+        List<String> files = Directories.search(dir);
+        if (files.size() <= 0 || whitelist.length <= 0)
+            return;
+
+        boolean csfs = false;
+        {
+            long stamp = Math.round(Math.random() * 100000);
+            File test1 = new File(dir, '.' + stamp + ".ss_fsc");
+            File test2 = new File(dir, '.' + stamp + ".SS_FSC");
+
+            test1.createNewFile();
+            if (test2.createNewFile()) {
+                csfs = true;
+                test2.delete();
+            }
+            test1.delete();
+        }
+
+        LinkedHashMap<Pattern, Boolean> rules = new LinkedHashMap<Pattern, Boolean>();
+        for (String entry : whitelist) {
+            boolean mode = !entry.startsWith("!");
+            if (!mode) entry = entry.substring(1);
+
+            String pattern;
+            if (!entry.startsWith("%")) {
+                if (entry.startsWith("./"))
+                    entry = entry.substring(1);
+
+                StringBuilder rule = new StringBuilder();
+                if (entry.startsWith("**")) {
+                    entry = entry.substring(2);
+                    rule.append("^.*");
+                } else if (entry.startsWith("/")) {
+                    rule.append("^");
+                }
+
+                boolean greedyEnding = false;
+                if (entry.endsWith("**")) {
+                    entry = entry.substring(0, entry.length() - 2);
+                    greedyEnding = true;
+                } else if (entry.endsWith("/")) {
+                    greedyEnding = true;
+                }
+
+                StringBuilder literal = new StringBuilder();
+                for (PrimitiveIterator.OfInt i = entry.codePoints().iterator(); i.hasNext(); ) {
+                    int c = i.next();
+                    if ((c == '*' || c == '?' || c == '[') && literal.length() > 0) {
+                        rule.append(Pattern.quote(literal.toString()));
+                        literal = new StringBuilder();
+                    }
+                    switch (c) {
+                        case '[':
+                            for (boolean escaped = false; i.hasNext() && (c != ']' || escaped); c = i.next()) {
+                                if (c == '\\') escaped = !escaped;
+                                else escaped = false;
+                                literal.appendCodePoint(c);
+                            }
+                            if (c == ']' && literal.length() > 1) {
+                                literal.appendCodePoint(c);
+                                rule.append(literal.toString());
+                            }
+                            literal = new StringBuilder();
+                            break;
+                        case '*':
+                            rule.append("[^/]+");
+                            break;
+                        case '?':
+                            rule.append("[^/]");
+                            break;
+                        case '\\':
+                            if (i.hasNext()) c = i.next();
+                        default:
+                            literal.appendCodePoint(c);
+                            break;
+                    }
+                }
+                if (literal.length() > 0)
+                    rule.append(Pattern.quote(literal.toString()));
+
+                if (greedyEnding)
+                    rule.append(".*");
+                rule.append("$");
+                pattern = rule.toString();
+            } else {
+                pattern = entry.substring(1);
+            }
+
+            if (csfs) rules.put(Pattern.compile(pattern), mode);
+            else rules.put(Pattern.compile(pattern, Pattern.CASE_INSENSITIVE), mode);
+        }
+
+        for (String file : files) {
+            boolean act = false;
+
+            for (Map.Entry<Pattern, Boolean> rule : rules.entrySet()) {
+                if (rule.getKey().matcher('/' + file.replace(File.separatorChar, '/')).find()) act = rule.getValue();
+            }
+
+            if (act) act(dir, file);
+        }
+    }
+
+    /**
+     * Perform an action on an included file
+     *
+     * @param dir Parent Directory
+     * @param name File Name
+     */
+    protected abstract void act(File dir, String name) throws IOException;
+}

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

@@ -1,456 +0,0 @@
-package net.ME1312.SubServers.Bungee.Library;
-
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
-import net.ME1312.SubServers.Bungee.SubProxy;
-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.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.ByteArrayOutputStream;
-import java.io.DataOutputStream;
-import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-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,21 +3,19 @@ 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
  */
-public class ReplacementScanner {
+public class ReplacementScanner extends FileScanner {
     private final Map<String, String> replacements = new LinkedHashMap<>();
 
     public ReplacementScanner(Map<String, String> replacements) {
         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);
         }
 
@@ -44,122 +42,29 @@ public class ReplacementScanner {
      * @param whitelist File Whitelist
      */
     public void replace(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);
-        }
-        if (files.size() <= 0 || whitelist.length <= 0)
-            return;
+        super.scan(dir, whitelist);
+    }
 
-        boolean csfs = false;
-        {
-            long stamp = Math.round(Math.random() * 100000);
-            File test1 = new File(dir, '.' + stamp + ".ss_fsc");
-            File test2 = new File(dir, '.' + stamp + ".SS_FSC");
-
-            test1.createNewFile();
-            if (test2.createNewFile()) {
-                csfs = true;
-                test2.delete();
-            }
-            test1.delete();
-        }
-
-        LinkedHashMap<Pattern, Boolean> rules = new LinkedHashMap<Pattern, Boolean>();
-        for (String entry : whitelist) {
-            boolean mode = !entry.startsWith("!");
-            if (!mode) entry = entry.substring(1);
-
-            String pattern;
-            if (!entry.startsWith("%")) {
-                if (entry.startsWith("./"))
-                    entry = entry.substring(1);
-
-                StringBuilder rule = new StringBuilder();
-                if (entry.startsWith("**")) {
-                    entry = entry.substring(2);
-                    rule.append("^.*");
-                } else if (entry.startsWith("/")) {
-                    rule.append("^");
-                }
-
-                boolean greedyEnding = false;
-                if (entry.endsWith("**")) {
-                    entry = entry.substring(0, entry.length() - 2);
-                    greedyEnding = true;
-                } else if (entry.endsWith("/")) {
-                    greedyEnding = true;
-                }
-
-                StringBuilder literal = new StringBuilder();
-                for (PrimitiveIterator.OfInt i = entry.codePoints().iterator(); i.hasNext(); ) {
-                    int c = i.next();
-                    if ((c == '*' || c == '?' || c == '[') && literal.length() > 0) {
-                        rule.append(Pattern.quote(literal.toString()));
-                        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;
-                                else escaped = false;
-                                literal.appendCodePoint(c);
-                            }
-                            if (c == ']' && literal.length() > 1) {
-                                literal.appendCodePoint(c);
-                                rule.append(literal.toString());
-                            }
-                            literal = new StringBuilder();
-                            break;
-                        case '*':
-                            rule.append("[^/]+");
-                            break;
-                        case '?':
-                            rule.append("[^/]");
-                            break;
-                        default:
-                            literal.appendCodePoint(c);
-                            break;
-                    }
-                }
-                if (literal.length() > 0)
-                    rule.append(Pattern.quote(literal.toString()));
-
-                if (greedyEnding)
-                    rule.append(".*");
-                rule.append("$");
-                pattern = rule.toString();
-            } else {
-                pattern = entry.substring(1);
-            }
-
-            if (csfs) rules.put(Pattern.compile(pattern), mode);
-            else rules.put(Pattern.compile(pattern, Pattern.CASE_INSENSITIVE), mode);
-        }
-
-        for (String file : files) {
-            boolean act = false;
-
-            for (Map.Entry<Pattern, Boolean> rule : rules.entrySet()) {
-                if (rule.getKey().matcher('/' + file.replace(File.separatorChar, '/')).find()) act = rule.getValue();
-            }
-
-            if (act) replaceFile(new File(dir, file));
-        }
-    } private void replaceFile(File file) throws IOException {
+    protected void act(File dir, String name) throws IOException {
+        File file = new File(dir, name);
         FileInputStream stream = new FileInputStream(file);
         String string = Util.readAll(new InputStreamReader(stream));
         stream.close();
 
-        for (Map.Entry<String, String> replacement : replacements.entrySet()) string = string.replace("SubServers::" + replacement.getKey(), replacement.getValue());
-        FileWriter writer = new FileWriter(file, false);
-        writer.write(string);
-        writer.close();
+        boolean update = false;
+        for (Map.Entry<String, String> replacement : replacements.entrySet()) {
+            String placeholder = "SubServers::" + replacement.getKey();
+            if (string.contains(placeholder)) {
+                string = string.replace(placeholder, replacement.getValue());
+                update = true;
+            }
+        }
+
+        if (update) {
+            FileWriter writer = new FileWriter(file, false);
+            writer.write(string);
+            writer.close();
+        }
     }
 
 

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

@@ -6,6 +6,7 @@ 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.SubProxy;
+
 import net.md_5.bungee.api.ChatColor;
 
 import java.net.InetAddress;
@@ -27,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);
     }
 
     /**
@@ -56,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));
@@ -87,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,14 +1,15 @@
 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;
+
 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;
 
@@ -33,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;
     }
 
@@ -47,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

@@ -1,12 +1,12 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubServers.Bungee.Host.Server;
-import net.ME1312.SubServers.Bungee.Host.SubServer;
 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 net.ME1312.SubServers.Bungee.Host.Server;
+import net.ME1312.SubServers.Bungee.Host.SubServer;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
 import java.util.Map;
@@ -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

@@ -1,11 +1,11 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubServers.Bungee.Host.SubCreator;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Version.Version;
 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.SubCreator;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
 import java.util.UUID;
@@ -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

@@ -0,0 +1,101 @@
+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.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.connection.ProxiedPlayer;
+
+import java.util.*;
+import java.util.function.IntConsumer;
+
+/**
+ * Disconnect Player Packet
+ */
+public class PacketDisconnectPlayer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
+    private int response;
+    private UUID tracker;
+
+    /**
+     * New PacketDisconnectPlayer (In)
+     */
+    public PacketDisconnectPlayer() {
+
+    }
+
+    /**
+     * New PacketDisconnectPlayer (Out)
+     *
+     * @param response Response ID
+     * @param tracker Receiver ID
+     */
+    public PacketDisconnectPlayer(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.getUUIDList(0x0001), data.contains(0x0002)?data.getString(0x0002):null, i -> {
+            client.sendPacket(new PacketDisconnectPlayer(i, tracker));
+        });
+    }
+
+    @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 {
+                    ++failures.value;
+                }
+            }
+
+            if (requests.size() == 0) {
+                callback.accept(failures.value);
+            } else {
+                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) {
+            e.printStackTrace();
+            callback.accept(-1);
+        }
+    }
+}

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

@@ -1,17 +1,14 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubServers.Bungee.Host.Server;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubData.Server.SubDataClient;
 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.Server;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
+import java.util.*;
 
 /**
  * Download Group Info Packet
@@ -27,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);
     }
 
     /**
@@ -39,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) {
@@ -55,27 +50,32 @@ public class PacketDownloadGroupInfo implements PacketObjectIn<Integer>, PacketO
         ObjectMap<Integer> data = new ObjectMap<Integer>();
         if (tracker != null) data.set(0x0000, tracker);
 
-        ObjectMap<String> groups = new ObjectMap<String>();
-        for (Map.Entry<String, List<Server>> group : plugin.api.getGroups().entrySet()) {
-            if (this.groups == null || this.groups.length <= 0 || Arrays.binarySearch(this.groups, group.getKey().toLowerCase()) >= 0) {
-                ObjectMap<String> servers = new ObjectMap<String>();
-                for (Server server : group.getValue()) {
-                    servers.set(server.getName(), server.forSubData());
+        if (this.groups == null || this.groups.length > 0) {
+            ObjectMap<String> groups = new ObjectMap<String>();
+            for (Map.Entry<String, List<Server>> group : plugin.api.getGroups().entrySet()) {
+                if (this.groups == null || Arrays.binarySearch(this.groups, group.getKey().toLowerCase()) >= 0) {
+                    ObjectMap<String> servers = new ObjectMap<String>();
+                    for (Server server : group.getValue()) {
+                        servers.set(server.getName(), server.forSubData());
+                    }
+                    groups.set(group.getKey(), servers);
                 }
-                groups.set(group.getKey(), servers);
             }
+            data.set(0x0001, groups);
+        } else {
+            ObjectMap<String> ungrouped = new ObjectMap<String>();
+            for (Server server : plugin.api.getServers().values()) {
+                if (server.getGroups().size() <= 0) ungrouped.set(server.getName(), server.forSubData());
+            }
+
+            data.set(0x0001, Collections.emptyMap());
+            data.set(0x0002, ungrouped);
         }
-        data.set(0x0001, groups);
         return data;
     }
 
     @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

@@ -1,11 +1,11 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubServers.Bungee.Host.Host;
 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 net.ME1312.SubServers.Bungee.Host.Host;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
 import java.util.Arrays;
@@ -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

@@ -1,9 +1,9 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
 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.SubProxy;
 
 import java.util.LinkedHashMap;
@@ -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

@@ -1,11 +1,12 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Version.Version;
-import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
 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.SubProxy;
+
 import net.md_5.bungee.api.config.ListenerInfo;
 
 import java.util.LinkedList;
@@ -43,13 +44,18 @@ public class PacketDownloadPlatformInfo implements PacketObjectIn<Integer>, Pack
         ObjectMap<Integer> data = new ObjectMap<Integer>();
         if (tracker != null) data.set(0x0000, tracker);
         ObjectMap<String> info = new ObjectMap<String>();
+
+
         ObjectMap<String> subservers = new ObjectMap<String>();
         subservers.set("version", plugin.api.getWrapperVersion().toString());
         if (plugin.api.getWrapperBuild() != null) subservers.set("build", plugin.api.getWrapperBuild().toString());
         subservers.set("last-reload", plugin.resetDate);
+        subservers.set("proxies", plugin.api.getProxies().size());
         subservers.set("hosts", plugin.api.getHosts().size());
         subservers.set("subservers", plugin.api.getSubServers().size());
         info.set("subservers", subservers);
+
+
         ObjectMap<String> bungee = new ObjectMap<String>();
         bungee.set("version", plugin.api.getProxyVersion().toString());
         bungee.set("disabled-cmds", plugin.getConfig().getDisabledCommands());
@@ -66,12 +72,16 @@ public class PacketDownloadPlatformInfo implements PacketObjectIn<Integer>, Pack
         }
         bungee.set("listeners", listeners);
         info.set("bungee", bungee);
+
+
         ObjectMap<String> minecraft = new ObjectMap<String>();
         LinkedList<String> mcversions = new LinkedList<String>();
         for (Version version : plugin.api.getGameVersion()) mcversions.add(version.toString());
         minecraft.set("version", mcversions);
-        minecraft.set("players", plugin.api.getGlobalPlayers().size());
+        minecraft.set("players", plugin.api.getRemotePlayers().size());
         info.set("minecraft", minecraft);
+
+
         ObjectMap<String> system = new ObjectMap<String>();
         ObjectMap<String> os = new ObjectMap<String>();
         os.set("name", System.getProperty("os.name"));
@@ -81,6 +91,8 @@ public class PacketDownloadPlatformInfo implements PacketObjectIn<Integer>, Pack
         java.set("version",  System.getProperty("java.version"));
         system.set("java", java);
         info.set("system", system);
+
+
         data.set(0x0001, info);
         return data;
     }
@@ -89,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

@@ -1,14 +1,13 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
 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 net.ME1312.SubServers.Bungee.Host.RemotePlayer;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.UUID;
 
@@ -27,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);
     }
 
     /**
@@ -40,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) {
@@ -61,16 +58,16 @@ public class PacketDownloadPlayerInfo implements PacketObjectIn<Integer>, Packet
 
         ObjectMap<String> players = new ObjectMap<String>();
         if (ids == null && names == null) {
-            for (RemotePlayer player : plugin.api.getGlobalPlayers().values()) {
+            for (RemotePlayer player : plugin.api.getRemotePlayers().values()) {
                 players.set(player.getUniqueId().toString(), player.forSubData());
             }
         } else {
             if (ids != null) for (UUID id : ids) {
-                RemotePlayer player = plugin.api.getGlobalPlayer(id);
+                RemotePlayer player = plugin.api.getRemotePlayer(id);
                 if (player != null) players.set(player.getUniqueId().toString(), player.forSubData());
             }
             if (names != null) for (String name : names) {
-                RemotePlayer player = plugin.api.getGlobalPlayer(name);
+                RemotePlayer player = plugin.api.getRemotePlayer(name);
                 if (player != null) players.set(player.getUniqueId().toString(), player.forSubData());
             }
         }
@@ -80,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

@@ -1,11 +1,11 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubServers.Bungee.Host.Proxy;
 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.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.SubProxy;
 
 import java.util.Arrays;
@@ -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) {
@@ -61,17 +59,14 @@ public class PacketDownloadProxyInfo implements PacketObjectIn<Integer>, PacketO
             }
         }
         data.set(0x0001, proxies);
-        if (this.proxies != null && plugin.api.getMasterProxy() != null && (this.proxies.length <= 0 || Arrays.binarySearch(this.proxies, plugin.api.getMasterProxy().getName().toLowerCase()) >= 0)) data.set(0x0002, plugin.api.getMasterProxy().forSubData());
+        if (this.proxies != null && plugin.api.getMasterProxy() != null && (this.proxies.length <= 0 || Arrays.binarySearch(this.proxies, plugin.api.getMasterProxy().getName().toLowerCase()) >= 0)) {
+            data.set(0x0002, plugin.api.getMasterProxy().forSubData());
+        }
         return data;
     }
 
     @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

@@ -1,11 +1,11 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubServers.Bungee.Host.Server;
 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 net.ME1312.SubServers.Bungee.Host.Server;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
 import java.util.Arrays;
@@ -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,20 +1,21 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.Galaxi.Library.Callback.Callback;
 import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubData.Server.SubDataClient;
 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.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;
@@ -32,32 +33,30 @@ public class PacketExAddServer implements PacketObjectIn<Integer>, PacketObjectO
 
     /**
      * New PacketExAddServer (Out)
-     *
-     * @param name Name of Server
-     * @param enabled Enabled Status
-     * @param log Logging Status
-     * @param directory Directory
-     * @param executable Executable
      */
     @SafeVarargs
-    public PacketExAddServer(String name, boolean enabled, int port, boolean log, String directory, String executable, String stopcmd, UUID running, Callback<ObjectMap<Integer>>... callback) {
-        if (Util.isNull(name, enabled, log, directory, executable, callback)) throw new NullPointerException();
-        this.name = name;
-        this.enabled = enabled;
-        this.port = port;
-        this.log = log;
-        this.directory = directory;
-        this.executable = executable;
-        this.stopcmd = stopcmd;
+    public PacketExAddServer(ExternalSubServer server, UUID running, Consumer<ObjectMap<Integer>>... callback) {
+        if (callback == null) throw new NullPointerException();
+        this.name = server.getName();
+        this.enabled = server.isEnabled();
+        this.port = server.getAddress().getPort();
+        this.log = server.isLogging();
+        this.directory = server.getPath();
+        this.executable = server.getExecutable();
+        this.stopcmd = server.getStopCommand();
         this.running = running;
         this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
         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);
@@ -65,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,12 +1,13 @@
 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;
+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.Galaxi.Library.Map.ObjectMap;
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
 /**
@@ -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

@@ -1,26 +1,26 @@
 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 net.ME1312.SubServers.Bungee.Host.External.ExternalSubServer;
 import net.ME1312.SubServers.Bungee.Host.SubServer;
-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.Protocol.PacketObjectIn;
 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,29 +1,29 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubServers.Bungee.Host.SubCreator;
-import net.ME1312.Galaxi.Library.Callback.Callback;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.Galaxi.Library.Version.Version;
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubData.Server.Protocol.PacketObjectOut;
 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.SubCreator;
 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;
     private Version version;
     private int port;
-    private String dir;
+    private Boolean mode;
     private UUID log;
     private UUID tracker = null;
 
@@ -39,19 +39,20 @@ public class PacketExCreateServer implements PacketObjectIn<Integer>, PacketObje
      *
      * @param player Player
      * @param server Server to Update
+     * @param template Server Template
      * @param version Server Version
      * @param log Log Address
      * @param callback Callbacks
      */
     @SafeVarargs
-    public PacketExCreateServer(UUID player, SubServer server, Version version, UUID log, Callback<ObjectMap<Integer>>... callback) {
-        if (Util.isNull(server, 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 = server.getTemplate();
+        this.template = template;
         this.version = version;
         this.port = server.getAddress().getPort();
-        this.dir = server.getPath();
+        this.mode = template == server.getTemplate();
         this.log = log;
         this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
         callbacks.put(tracker, callback);
@@ -69,13 +70,14 @@ 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;
         this.version = version;
         this.port = port;
+        this.mode = null;
         this.log = log;
         this.tracker = Util.getNew(callbacks.keySet(), UUID::randomUUID);
         callbacks.put(tracker, callback);
@@ -89,24 +91,32 @@ public class PacketExCreateServer implements PacketObjectIn<Integer>, PacketObje
         } else {
             data.set(0x0000, tracker);
             data.set(0x0002, name);
-            data.set(0x0003, template.getName());
+            if (template.isDynamic()) {
+                ObjectMap<String> template = new ObjectMap<>();
+                template.set("name", this.template.getName());
+                template.set("display", this.template.getDisplayName());
+                template.set("enabled", this.template.isEnabled());
+                template.set("icon", this.template.getIcon());
+                template.set("dir", this.template.getDirectory().toString());
+                template.set("build", this.template.getBuildOptions().clone());
+                template.set("def", this.template.getConfigOptions().clone());
+                data.set(0x0003, template);
+            } else {
+                data.set(0x0003, template.getName());
+            }
             data.set(0x0004, version);
             data.set(0x0005, port);
             data.set(0x0006, log);
+            if (mode != null)
+                data.set(0x0007, mode);
             if (player != null)
-                data.set(0x0007, player);
+                data.set(0x0008, player);
         }
         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/PacketExDeleteServer.java

@@ -1,20 +1,20 @@
 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.SubDataClient;
 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;
 
 /**
  * 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

@@ -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;
+
+/**
+ * Disconnect External Player Packet
+ */
+public class PacketExDisconnectPlayer 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 reason;
+    private UUID id;
+
+    /**
+     * New PacketExDisconnectPlayer (In)
+     */
+    public PacketExDisconnectPlayer() {}
+
+    /**
+     * New PacketExDisconnectPlayer (Out)
+     *
+     * @param players Players
+     * @param reason Reason
+     * @param callback Callbacks
+     */
+    @SafeVarargs
+    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);
+    }
+
+    @Override
+    public ObjectMap<Integer> send(SubDataClient client) {
+        ObjectMap<Integer> data = new ObjectMap<Integer>();
+        data.set(0x0000, id);
+        data.set(0x0001, players);
+        if (reason != null) data.set(0x0002, reason);
+        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/PacketExDownloadTemplates.java

@@ -1,16 +1,24 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.Galaxi.Library.UniversalFile;
-import net.ME1312.SubServers.Bungee.Host.External.ExternalHost;
+import net.ME1312.Galaxi.Library.Directories;
+import net.ME1312.Galaxi.Library.Try;
 import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.SubData.Server.SubDataClient;
+import net.ME1312.SubData.Server.Library.DataSize;
 import net.ME1312.SubData.Server.Protocol.PacketIn;
 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.*;
+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
@@ -37,10 +45,30 @@ public class PacketExDownloadTemplates implements PacketIn, PacketStreamOut {
     @Override
     public void send(SubDataClient client, OutputStream stream) throws Throwable {
         try {
-            Util.zip(new UniversalFile(plugin.dir, "SubServers:Templates"), stream);
-            stream.close();
+            if (client.getBlockSize() < DataSize.MBB) client.tempBlockSize(DataSize.MBB);
+            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();
@@ -53,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,20 +1,20 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
-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;
 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;
 
 /**
  * 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

@@ -0,0 +1,112 @@
+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 net.ME1312.SubServers.Bungee.Host.Proxy;
+import net.ME1312.SubServers.Bungee.Host.RemotePlayer;
+import net.ME1312.SubServers.Bungee.Host.Server;
+import net.ME1312.SubServers.Bungee.SubAPI;
+import net.ME1312.SubServers.Bungee.SubProxy;
+
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * External Player Sync Packet
+ */
+public class PacketExSyncPlayer implements PacketObjectIn<Integer>, PacketObjectOut<Integer> {
+    private SubProxy plugin;
+    private String name;
+    private Boolean mode;
+    private RemotePlayer[] values;
+
+    /**
+     * New PacketExSyncPlayer (In)
+     *
+     * @param plugin SubPlugin
+     */
+    public PacketExSyncPlayer(SubProxy plugin) {
+        this.plugin = Util.nullpo(plugin);
+    }
+
+    /**
+     * New PacketExSyncPlayer (Out)
+     *
+     * @param name Proxy Name
+     * @param mode Update Mode (true for add, false for remove, null for reset)
+     * @param values RemotePlayers
+     */
+    public PacketExSyncPlayer(String name, Boolean mode, RemotePlayer... values) {
+        this.name = name;
+        this.mode = mode;
+        this.values = values;
+    }
+
+    @Override
+    public ObjectMap<Integer> send(SubDataClient client) {
+        ObjectMap<Integer> data = new ObjectMap<Integer>();
+        data.set(0x0000, name);
+        data.set(0x0001, mode);
+        if (values != null) {
+            ArrayList<ObjectMap<String>> list = new ArrayList<ObjectMap<String>>();
+            for (RemotePlayer value : values) list.add(value.forSubData());
+            data.set(0x0002, list);
+        }
+        return data;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void receive(SubDataClient client, ObjectMap<Integer> data) {
+        if (client.getHandler() instanceof Proxy) {
+            ArrayList<RemotePlayer> forward = new ArrayList<RemotePlayer>();
+            synchronized (plugin.rPlayers) {
+                if (data.getBoolean(0x0001) == null) {
+                    for (UUID id : Util.getBackwards(plugin.rPlayerLinkP, (Proxy) client.getHandler())) {
+                        plugin.rPlayerLinkS.remove(id);
+                        plugin.rPlayerLinkP.remove(id);
+                        plugin.rPlayers.remove(id);
+                    }
+                }
+                if (data.getBoolean(0x0001) != Boolean.FALSE) {
+                    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());
+                        plugin.rPlayers.put(player.getUniqueId(), player);
+                        if (server != null) plugin.rPlayerLinkS.put(player.getUniqueId(), server);
+                    }
+                } else {
+                    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
+                        if (player == null || player.getProxy() == null || client.getHandler().equals(plugin.rPlayerLinkP.get(id))) {
+                            if (player != null) forward.add(player);
+                            plugin.rPlayerLinkS.remove(id);
+                            plugin.rPlayerLinkP.remove(id);
+                            plugin.rPlayers.remove(id);
+                        }
+                    }
+                }
+
+                if (data.getBoolean(0x0001) == null || forward.size() > 0) {
+                    PacketExSyncPlayer packet = new PacketExSyncPlayer(((Proxy) client.getHandler()).getName(), data.getBoolean(0x0001), forward.toArray(new RemotePlayer[0]));
+                    for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null && proxy != client.getHandler()) {
+                        ((SubDataClient) proxy.getSubData()[0]).sendPacket(packet);
+                    }
+                }
+            }
+        }
+    }
+}

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;
@@ -11,7 +11,10 @@ import net.ME1312.SubServers.Bungee.Host.External.ExternalSubCreator;
 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;
 
@@ -19,40 +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 = new SubCreator.ServerTemplate(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

@@ -1,11 +1,10 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubServers.Bungee.Host.External.ExternalSubLogger;
 import net.ME1312.Galaxi.Library.Map.ObjectMap;
 import net.ME1312.Galaxi.Library.Util;
-import net.ME1312.Galaxi.Library.Version.Version;
 import net.ME1312.SubData.Server.Protocol.PacketObjectIn;
+import net.ME1312.SubData.Server.SubDataClient;
+import net.ME1312.SubServers.Bungee.Host.External.ExternalSubLogger;
 
 import java.util.HashMap;
 import java.util.UUID;
@@ -24,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
      *
@@ -55,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

@@ -1,9 +1,9 @@
 package net.ME1312.SubServers.Bungee.Network.Packet;
 
-import net.ME1312.SubData.Server.SubDataClient;
-import net.ME1312.SubServers.Bungee.Host.External.ExternalHost;
 import net.ME1312.Galaxi.Library.Util;
 import net.ME1312.SubData.Server.Protocol.PacketIn;
+import net.ME1312.SubData.Server.SubDataClient;
+import net.ME1312.SubServers.Bungee.Host.External.ExternalHost;
 import net.ME1312.SubServers.Bungee.SubProxy;
 
 import java.lang.reflect.InvocationTargetException;
@@ -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;
-    }
 }