Initial commit

.gitignore

@@ -0,0 +1,38 @@
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/copilot.data.migration.agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.edit.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="EditMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/discord.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DiscordProjectSettings">
+    <option name="show" value="PROJECT_FILES" />
+    <option name="description" value="" />
+  </component>
+</project>

.idea/encodings.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/src/main/resources" charset="UTF-8" />
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="MavenProjectsManager">
+    <option name="originalFiles">
+      <list>
+        <option value="$PROJECT_DIR$/pom.xml" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="23" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

pom.xml

@@ -0,0 +1,48 @@
+<?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>github.openautonomousconnection</groupId>
+    <artifactId>protocol</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>23</maven.compiler.source>
+        <maven.compiler.target>23</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <repositories>
+        <repository>
+            <id>github</id>
+            <url>https://maven.pkg.github.com/unlegitdqrk/unlegitlibrary</url>
+            <snapshots>
+                <enabled>true</enabled>
+            </snapshots>
+        </repository>
+    </repositories>
+
+    <distributionManagement>
+        <repository>
+            <id>github</id>
+            <name>Protocol</name>
+            <url>https://maven.pkg.github.com/open-autonomous-connection/protocol</url>
+        </repository>
+    </distributionManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>me.finn.unlegitlibrary</groupId>
+            <artifactId>unlegitlibrary</artifactId>
+            <version>1.5.13</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.38</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>

src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java

@@ -0,0 +1,93 @@
+package github.openautonomousconnection.protocol;
+
+import github.openautonomousconnection.protocol.handle.ClassicHandler;
+import github.openautonomousconnection.protocol.side.ProtocolClient;
+import github.openautonomousconnection.protocol.side.ProtocolServer;
+import lombok.Getter;
+import lombok.Setter;
+import me.finn.unlegitlibrary.utils.Logger;
+
+import java.io.File;
+import java.io.IOException;
+
+public class ProtocolBridge {
+
+    @Getter
+    private final ProtocolSettings protocolSettings;
+
+    @Getter
+    private final ProtocolVersion protocolVersion;
+
+    @Getter
+    private ProtocolServer protocolServer;
+
+    @Getter
+    private ProtocolClient protocolClient;
+
+    @Getter
+    private final Logger logger;
+
+    @Getter @Setter
+    private ClassicHandler classicHandler;
+
+    public ProtocolBridge(ProtocolServer protocolServer, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) {
+        this.protocolServer = protocolServer;
+        this.protocolSettings = protocolSettings;
+        this.protocolVersion = protocolVersion;
+
+        Logger tmpLogger = null;
+        try {
+            tmpLogger = new Logger(logFolder, false, true);
+        } catch (IOException | NoSuchFieldException | IllegalAccessException exception) {
+            exception.printStackTrace();
+            tmpLogger = null;
+            System.exit(1);
+        }
+
+        this.logger = tmpLogger;
+
+        if (!validateProtocolVersion()) {
+            this.logger.error("Invalid protocol version '" + protocolVersion.toString() + "'!");
+            System.exit(1);
+        }
+    }
+
+    public ProtocolBridge(ProtocolClient protocolClient, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) {
+        this.protocolClient = protocolClient;
+        this.protocolSettings = protocolSettings;
+        this.protocolVersion = protocolVersion;
+
+        Logger tmpLogger = null;
+        try {
+            tmpLogger = new Logger(logFolder, false, true);
+        } catch (IOException | NoSuchFieldException | IllegalAccessException exception) {
+            exception.printStackTrace();
+            tmpLogger = null;
+            System.exit(1);
+        }
+
+        this.logger = tmpLogger;
+
+        if (!validateProtocolVersion()) {
+            this.logger.error("Invalid protocol version '" + protocolVersion.toString() + "'!");
+            System.exit(1);
+        }
+    }
+
+    public boolean isRunningAsServer() {
+        return protocolServer != null;
+    }
+
+    public boolean isRunningAsClient() {
+        return protocolClient != null;
+    }
+
+    private boolean validateProtocolVersion() {
+        return (isRunningAsServer() && protocolVersion.getProtocolSide() != ProtocolVersion.ProtocolSide.CLIENT) ||
+                (isRunningAsClient() && protocolVersion.getProtocolSide() != ProtocolVersion.ProtocolSide.SERVER);
+    }
+
+    public boolean validateProtocolVersion(ProtocolVersion targetVersion) {
+        return protocolVersion == targetVersion || protocolVersion.getCompatibleVersions().contains(targetVersion);
+    }
+}

src/main/java/github/openautonomousconnection/protocol/ProtocolSettings.java

@@ -0,0 +1,14 @@
+package github.openautonomousconnection.protocol;
+
+import me.finn.unlegitlibrary.event.EventManager;
+import me.finn.unlegitlibrary.network.system.packets.PacketHandler;
+import me.finn.unlegitlibrary.utils.DefaultMethodsOverrider;
+
+public class ProtocolSettings extends DefaultMethodsOverrider {
+
+    public String host;
+    public int port;
+    public PacketHandler packetHandler;
+    public EventManager eventManager;
+
+}

src/main/java/github/openautonomousconnection/protocol/ProtocolVersion.java

@@ -0,0 +1,70 @@
+package github.openautonomousconnection.protocol;
+
+import lombok.Getter;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.List;
+
+public enum ProtocolVersion implements Serializable {
+    PV_1_0_0_CLASSIC("1.0.0", ProtocolType.CLASSIC, ProtocolSide.SERVER),
+    PV_1_0_0_BETA("1.0.0", ProtocolType.BETA, ProtocolSide.BOTH, PV_1_0_0_CLASSIC)
+    ;
+
+    @Getter
+    private final String version;
+    @Getter
+    private final ProtocolType protocolType;
+    @Getter
+    private final ProtocolSide protocolSide;
+    @Getter
+    private final List<ProtocolVersion> compatibleVersions;
+
+    ProtocolVersion(String version, ProtocolType protocolType, ProtocolSide protocolSide, ProtocolVersion... compatibleVersions) {
+        this.version = version;
+        this.protocolType = protocolType;
+        this.protocolSide = protocolSide;
+        this.compatibleVersions = Arrays.stream(compatibleVersions).toList();
+        if (!this.compatibleVersions.contains(this)) this.compatibleVersions.add(this);
+    }
+
+    @Override
+    public final String toString() {
+        StringBuilder compatible = new StringBuilder("[");
+        for (ProtocolVersion compatibleVersion : compatibleVersions) compatible.append(compatibleVersion.buildName());
+        compatible.append("]");
+
+        return "{version=" + version + ";type=" + protocolType.toString() + ";side=" + protocolSide.toString() + ";compatible=" + compatible.toString() + "}";
+    }
+
+    public final String buildName() {
+        return version + "-" + protocolType.toString();
+    }
+
+    public enum ProtocolType {
+        CLASSIC, // -> See "_old" Projects on GitHub Organisation https://github.com/Open-Autonomous-Connection/
+        BETA,
+        ALPHA,
+        STABLE
+
+        ;
+
+        @Override
+        public final String toString() {
+            return name().toUpperCase();
+        }
+    }
+
+    public enum ProtocolSide {
+        CLIENT, // Protocol version can only used on Client
+        SERVER, // Protocol version can only used on Server
+        BOTH // Protocol version can only used on Server and Client
+
+        ;
+
+        @Override
+        public final String toString() {
+            return name().toUpperCase();
+        }
+    }
+}

src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java

@@ -0,0 +1,4 @@
+package github.openautonomousconnection.protocol.classic;
+
+public class ClassicConverter {
+}

src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java

@@ -0,0 +1,77 @@
+package github.openautonomousconnection.protocol.classic;
+
+import me.finn.unlegitlibrary.string.StringUtils;
+
+import java.io.Serializable;
+
+public class Classic_Domain implements Serializable {
+    public final String name;
+    public final String topLevelDomain;
+    private final String destination;
+    private final String path;
+
+    public Classic_Domain(String name, String topLevelDomain, String destination, String path) {
+        if (path == null) path = "";
+
+        this.name = name;
+        this.topLevelDomain = topLevelDomain;
+        this.destination = destination;
+        this.path = path;
+    }
+
+    public final String realDestination() {
+        String tmpDestination = destination.endsWith("/") ? destination : destination + "/";
+        String tmpPath = getPath();
+
+        if (tmpPath == null) tmpPath = "";
+        if (tmpPath.startsWith("/")) tmpPath = tmpPath.substring("/".length());
+        if (tmpPath.endsWith("/")) tmpPath = tmpPath.substring(0, tmpPath.length() - "/".length());
+
+        return tmpDestination + tmpPath;
+    }
+
+    public final String getPath() {
+        if (path.endsWith("/")) return path.substring(0, path.length() - "/".length());
+        if (path.startsWith("/")) return path.substring("/".length());
+        return path;
+    }
+
+    public final String parsedDestination() {
+        if (destination.toLowerCase().startsWith("https://github.com/")) {
+            String base = "https://raw.githubusercontent.com/";
+            String username = Classic_DomainUtils.getPath(destination).split("/")[0];
+            String site = Classic_DomainUtils.getPath(destination).split("/")[1];
+
+            String tmpPath = getPath();
+            if (tmpPath == null || StringUtils.isEmptyString(tmpPath)) tmpPath = "index.html";
+            if (tmpPath.startsWith("/")) tmpPath = tmpPath.substring("/".length());
+            if (tmpPath.endsWith("/")) tmpPath = tmpPath.substring(0, tmpPath.length() - "/".length());
+
+            base = base + username + "/" + site + "/main/" + tmpPath;
+            return base;
+        }
+
+        return realDestination();
+    }
+
+    @Override
+    protected final Object clone() throws CloneNotSupportedException {
+        return new Classic_Domain(name, topLevelDomain, destination, path);
+    }
+
+    @Override
+    public final boolean equals(Object obj) {
+        if (!(obj instanceof Classic_Domain other)) return false;
+        return other.name.equalsIgnoreCase(name) && other.topLevelDomain.equalsIgnoreCase(topLevelDomain);
+    }
+
+    @Override
+    public final String toString() {
+        return "{parsed='" + parsedDestination() + "';real='" + realDestination() + "'}";
+    }
+
+    @Override
+    public final int hashCode() {
+        return super.hashCode();
+    }
+}

src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainUtils.java

@@ -0,0 +1,66 @@
+package github.openautonomousconnection.protocol.classic;
+
+import me.finn.unlegitlibrary.utils.DefaultMethodsOverrider;
+
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+class Classic_DomainUtils extends DefaultMethodsOverrider {
+
+    public static String getTopLevelDomain(String url) throws MalformedURLException {
+        URL uri = null;
+        String tldString = null;
+
+        if (url.startsWith(Classic_SiteType.PUBLIC.name + "://")) url = url.substring((Classic_SiteType.PUBLIC.name + "://").length());
+        if (url.startsWith(Classic_SiteType.CLIENT.name + "://")) url = url.substring((Classic_SiteType.CLIENT.name + "://").length());
+        if (url.startsWith(Classic_SiteType.SERVER.name + "://")) url = url.substring((Classic_SiteType.SERVER.name + "://").length());
+        if (url.startsWith(Classic_SiteType.PROTOCOL.name + "://")) url = url.substring((Classic_SiteType.PROTOCOL.name + "://").length());
+        if (url.startsWith(Classic_SiteType.LOCAL.name + "://")) url = url.substring((Classic_SiteType.LOCAL.name + "://").length());
+
+        if (!url.startsWith("https://") && !url.startsWith("http://")) url = "https://" + url;
+
+        uri = new URL(url);
+        String[] domainNameParts = uri.getHost().split("\\.");
+        tldString = domainNameParts[domainNameParts.length - 1];
+
+        return tldString;
+    }
+
+    public static String getDomainName(String url) throws URISyntaxException, MalformedURLException {
+        if (url.startsWith(Classic_SiteType.PUBLIC.name + "://")) url = url.substring((Classic_SiteType.PUBLIC.name + "://").length());
+        if (url.startsWith(Classic_SiteType.CLIENT.name + "://")) url = url.substring((Classic_SiteType.CLIENT.name + "://").length());
+        if (url.startsWith(Classic_SiteType.SERVER.name + "://")) url = url.substring((Classic_SiteType.SERVER.name + "://").length());
+        if (url.startsWith(Classic_SiteType.PROTOCOL.name + "://")) url = url.substring((Classic_SiteType.PROTOCOL.name + "://").length());
+        if (url.startsWith(Classic_SiteType.LOCAL.name + "://")) url = url.substring((Classic_SiteType.LOCAL.name + "://").length());
+
+        if (!url.startsWith("https://") && !url.startsWith("http://")) url = "https://" + url;
+
+        URI uri = new URI(url);
+        String domain = uri.getHost().replace("." + getTopLevelDomain(url), "");
+        return domain;
+    }
+
+
+    public static String getPath(String url) {
+        if (!url.startsWith(Classic_SiteType.PUBLIC.name + "://") && !url.startsWith(Classic_SiteType.CLIENT.name + "://") &&
+                !url.startsWith(Classic_SiteType.SERVER.name + "://") && !url.startsWith(Classic_SiteType.PROTOCOL.name + "://") &&
+                !url.startsWith(Classic_SiteType.LOCAL.name + "://") && !url.startsWith("http") && !url.startsWith("https")) {
+            url = Classic_SiteType.PUBLIC.name + "://" + url;
+        }
+
+        String[] split = url.split("/");
+        if (split.length <= 3) return "";
+
+        StringBuilder path = new StringBuilder();
+
+        for (int i = 3; i < split.length; i++) path.append(split[i]).append("/");
+
+        String pathStr = path.toString();
+        if (pathStr.startsWith("/")) pathStr = pathStr.substring("/".length());
+        if (pathStr.endsWith("/")) pathStr = pathStr.substring(0, pathStr.length() - "/".length());
+
+        return pathStr;
+    }
+}

src/main/java/github/openautonomousconnection/protocol/classic/Classic_LocalDomain.java

@@ -0,0 +1,7 @@
+package github.openautonomousconnection.protocol.classic;
+
+public class Classic_LocalDomain extends Classic_Domain {
+    public Classic_LocalDomain(String name, String endName, String path) {
+        super(name, endName, null, path);
+    }
+}

src/main/java/github/openautonomousconnection/protocol/classic/Classic_ProtocolVersion.java

@@ -0,0 +1,13 @@
+package github.openautonomousconnection.protocol.classic;
+
+import java.io.Serializable;
+
+public enum Classic_ProtocolVersion implements Serializable {
+    PV_1_0_0("1.0.0");
+    ;
+    public final String version;
+
+    Classic_ProtocolVersion(String version) {
+        this.version = version;
+    }
+}

src/main/java/github/openautonomousconnection/protocol/classic/Classic_RequestDomain.java

@@ -0,0 +1,10 @@
+package github.openautonomousconnection.protocol.classic;
+
+import java.io.Serializable;
+
+public class Classic_RequestDomain extends Classic_Domain implements Serializable {
+
+    public Classic_RequestDomain(String name, String topLevelDomain, String path) {
+        super(name, topLevelDomain, null, path);
+    }
+}

src/main/java/github/openautonomousconnection/protocol/classic/Classic_SiteType.java

@@ -0,0 +1,15 @@
+package github.openautonomousconnection.protocol.classic;
+
+import java.io.Serializable;
+
+enum Classic_SiteType implements Serializable {
+    CLIENT("oac-client"), SERVER("oac-server"),
+    PUBLIC("oac"), PROTOCOL("oac-protocol"), LOCAL("oac-local");
+    ;
+
+    public final String name;
+
+    Classic_SiteType(String name) {
+        this.name = name;
+    }
+}

src/main/java/github/openautonomousconnection/protocol/handle/ClassicHandler.java

@@ -0,0 +1,9 @@
+package github.openautonomousconnection.protocol.handle;
+
+import me.finn.unlegitlibrary.network.system.server.ConnectionHandler;
+
+public abstract class ClassicHandler {
+
+    public abstract void handleMessage(ConnectionHandler connectionHandler, String message);
+
+}

src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java

@@ -0,0 +1,19 @@
+package github.openautonomousconnection.protocol.packets;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.ProtocolVersion;
+import lombok.Getter;
+import me.finn.unlegitlibrary.network.system.packets.Packet;
+
+public abstract class OACPacket extends Packet {
+    @Getter
+    private final ProtocolVersion.ProtocolType packetType;
+    @Getter
+    private final ProtocolBridge protocolBridge;
+
+    public OACPacket(int id, ProtocolVersion.ProtocolType packetType, ProtocolBridge protocolBridge) {
+        super(id);
+        this.packetType = packetType;
+        this.protocolBridge = protocolBridge;
+    }
+}

src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/DomainPacket.java

@@ -0,0 +1,42 @@
+package github.openautonomousconnection.protocol.packets.v1_0_0.classic;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.ProtocolVersion;
+import github.openautonomousconnection.protocol.classic.Classic_Domain;
+import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion;
+import github.openautonomousconnection.protocol.classic.Classic_RequestDomain;
+import github.openautonomousconnection.protocol.packets.OACPacket;
+import me.finn.unlegitlibrary.network.system.packets.Packet;
+import me.finn.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+// ProtocolVersion 1.0.0-CLASSIC is ProtocolSide Server only
+public class DomainPacket extends OACPacket {
+    private final Classic_RequestDomain requestDomain;
+    private final Classic_Domain domain;
+    private final int clientID;
+
+    public DomainPacket(ProtocolBridge protocolBridge, int toClient, Classic_RequestDomain requestDomain, Classic_Domain domain) {
+        super(2, ProtocolVersion.ProtocolType.CLASSIC, protocolBridge);
+        this.clientID = toClient;
+        this.requestDomain = requestDomain;
+        this.domain = domain;
+    }
+
+    @Override
+    public void write(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        objectOutputStream.writeInt(clientID);
+        objectOutputStream.writeObject(requestDomain);
+        objectOutputStream.writeObject(domain);
+
+        objectOutputStream.writeObject(Classic_ProtocolVersion.PV_1_0_0);
+    }
+
+    @Override
+    public void read(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+
+    }
+}

src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/MessagePacket.java

@@ -0,0 +1,42 @@
+package github.openautonomousconnection.protocol.packets.v1_0_0.classic;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.ProtocolVersion;
+import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion;
+import github.openautonomousconnection.protocol.packets.OACPacket;
+import github.openautonomousconnection.protocol.side.ProtocolClient;
+import me.finn.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+// ProtocolVersion 1.0.0-CLASSIC is ProtocolSide Server only
+public class MessagePacket extends OACPacket {
+    private final String message;
+    private Classic_ProtocolVersion protocolVersion;
+    private final int clientID;
+
+    public MessagePacket(String message, int toClient, ProtocolBridge protocolBridge) {
+        super(3, ProtocolVersion.ProtocolType.CLASSIC, protocolBridge);
+        this.message = message;
+        this.clientID = toClient;
+    }
+
+    @Override
+    public void write(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        objectOutputStream.writeInt(clientID);
+
+        objectOutputStream.writeUTF(message);
+        objectOutputStream.writeObject(Classic_ProtocolVersion.PV_1_0_0);
+    }
+
+    @Override
+    public void read(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        int clientID = objectInputStream.readInt();
+        String message = objectInputStream.readUTF();
+        protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject();
+
+        getProtocolBridge().getClassicHandler().handleMessage(getProtocolBridge().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID), message);
+    }
+}

src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/PingPacket.java

@@ -0,0 +1,4 @@
+package github.openautonomousconnection.protocol.packets.v1_0_0.classic;
+
+public class PingPacket {
+}

src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java

@@ -0,0 +1,4 @@
+package github.openautonomousconnection.protocol.side;
+
+public class ProtocolClient {
+}

src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java

@@ -0,0 +1,24 @@
+package github.openautonomousconnection.protocol.side;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.handle.ClassicHandler;
+import lombok.Getter;
+import me.finn.unlegitlibrary.network.system.server.NetworkServer;
+
+public abstract class ProtocolServer {
+    @Getter
+    private final ProtocolBridge protocolBridge;
+
+    @Getter
+    private NetworkServer networkServer;
+
+    public ProtocolServer(ProtocolBridge protocolBridge) {
+        this.protocolBridge = protocolBridge;
+
+        this.networkServer = new NetworkServer.ServerBuilder().
+                setEventManager(protocolBridge.getProtocolSettings().eventManager).
+                setPacketHandler(protocolBridge.getProtocolSettings().packetHandler).
+                setPort(protocolBridge.getProtocolSettings().port).
+                build();
+    }
+}