Add proxy and mcloader modules, start working on abstractions

plugin/build.gradle

@@ -20,7 +20,6 @@ allprojects {
         maven { url = "https://repo.papermc.io/repository/maven-public/" }
         maven { url = "https://hub.spigotmc.org/nexus/content/groups/public/" }
         maven { url = "https://oss.sonatype.org/content/groups/public/" }
-        maven { url = "https://papermc.io/repo/repository/maven-public/" }
         maven { url = "https://s01.oss.sonatype.org/content/repositories/snapshots/" }
     }
 }
@@ -37,12 +36,16 @@ configurations {
 
 dependencies{
     modules project(':toolkit')
-    modules project(':core')
+    modules project(':common')
+
+    modules project(':proxy')
+    modules project(':mcloader')
+
     modules project(':paper')
     modules project(':velocity')
 }
 
-def projects = [":toolkit", ":core", ":paper", ":velocity"]
+def projects = [":toolkit", ":common", ":proxy", ":mcloader", ":paper", ":velocity"]
 jar {
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
     dependsOn(projects.collect {it + ":shadowJar"} )

plugin/core/src/main/java/group/aelysium/rustyconnector/core/common/events/EventManager.java → plugin/common/src/main/java/group/aelysium/rustyconnector/core/common/events/EventManager.java

@@ -1,19 +1,16 @@
 package group.aelysium.rustyconnector.core.common.events;
 
-import group.aelysium.rustyconnector.toolkit.core.absolute_redundancy.Particle;
 import group.aelysium.rustyconnector.toolkit.core.events.Event;
+import group.aelysium.rustyconnector.toolkit.core.events.IEventManager;
 import group.aelysium.rustyconnector.toolkit.core.events.Listener;
-import group.aelysium.rustyconnector.toolkit.velocity.events.mc_loader.RegisterEvent;
-import group.aelysium.rustyconnector.toolkit.velocity.events.mc_loader.UnregisterEvent;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.Map;
 import java.util.Vector;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ForkJoinPool;
 
-public class EventManager extends group.aelysium.rustyconnector.toolkit.core.events.EventManager {
+public class EventManager implements IEventManager {
 
     // A map of event types to their listeners
     private final Map<Class<? extends Event>, Vector<Listener<Event>>> listeners = new ConcurrentHashMap<>();
@@ -22,7 +19,7 @@ public class EventManager extends group.aelysium.rustyconnector.toolkit.core.eve
     private final ExecutorService executor = ForkJoinPool.commonPool();
 
     // Constructor
-    protected EventManager() {}
+    public EventManager() {}
 
     // Register a listener for a given event type
     public void on(Class<? extends Event> event, Listener<?> listener) {
@@ -54,21 +51,4 @@ public void close() throws Exception {
         this.listeners.clear();
         this.executor.shutdown();
     }
-
-    public static class Tinder extends Particle.Tinder<EventManager> {
-        protected final Map<Class<? extends Event>, Listener<? extends Event>> listeners;
-
-        public Tinder(Map<Class<? extends Event>, Listener<? extends Event>> listeners) {
-            this.listeners = listeners;
-        }
-
-        @Override
-        public @NotNull EventManager ignite() throws Exception {
-            EventManager eventManager = new EventManager();
-
-            listeners.forEach(eventManager::on);
-
-            return eventManager;
-        }
-    }
 }

plugin/gradle.properties

@@ -9,8 +9,8 @@ config_version               = 7
 magic_link_protocol_version  = 3
 
 # Paper
-paper_version                = 1.20.1-R0.1-SNAPSHOT
-folia_version                = 1.20.1-R0.1-SNAPSHOT
+paper_version                = 1.20.6-R0.1-SNAPSHOT
+folia_version                = 1.20.6-R0.1-SNAPSHOT
 
 # Fabric - https://fabricmc.net/develop/
 minecraft_version            = 1.20.2

plugin/mcloader/build.gradle

@@ -0,0 +1,19 @@
+compileJava {
+    options.encoding = "UTF-8"
+}
+
+dependencies {
+    shadow project(configuration: 'shadow', path: ':common')
+}
+
+// If ever strange behaviour check the docs for reference: https://imperceptiblethoughts.com/shadow/
+shadowJar {
+    archiveBaseName.set('mcloader')
+    archiveClassifier.set('')
+    archiveVersion.set('')
+
+    mergeServiceFiles()
+    minimize()
+}
+
+jar.finalizedBy('shadowJar')

plugin/mcloader/src/main/java/group/aelysium/Main.java

@@ -0,0 +1,7 @@
+package group.aelysium;
+
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello world!");
+    }
+}

plugin/paper/build.gradle

@@ -6,7 +6,7 @@ compileJava {
 
 dependencies {
     // Dev only
-    shadow project(path: ':core', configuration: 'shadow')
+    shadow project(configuration: 'shadow', path: ':mcloader')
     compileOnly "io.papermc.paper:paper-api:${project.paper_version}"
     shadow "dev.folia:folia-api:${project.folia_version}"
     implementation "cloud.commandframework:cloud-paper:${project.cloud_paperfabric_version}"

plugin/proxy/build.gradle

@@ -0,0 +1,19 @@
+compileJava {
+    options.encoding = "UTF-8"
+}
+
+dependencies {
+    shadow project(configuration: 'shadow', path: ':common')
+}
+
+// If ever strange behaviour check the docs for reference: https://imperceptiblethoughts.com/shadow/
+shadowJar {
+    archiveBaseName.set('proxy')
+    archiveClassifier.set('')
+    archiveVersion.set('')
+
+    mergeServiceFiles()
+    minimize()
+}
+
+jar.finalizedBy('shadowJar')

plugin/proxy/src/main/java/group/aelysium/Main.java

@@ -0,0 +1,7 @@
+package group.aelysium;
+
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello world!");
+    }
+}

plugin/proxy/src/main/java/group/aelysium/OnPlayerChangeServer.java

@@ -0,0 +1,74 @@
+package group.aelysium;
+
+import com.velocitypowered.api.event.EventTask;
+import com.velocitypowered.api.event.PostOrder;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.player.ServerPreConnectEvent;
+import com.velocitypowered.api.proxy.server.RegisteredServer;
+import group.aelysium.rustyconnector.core.proxy.family.mcloader.MCLoader;
+import group.aelysium.rustyconnector.plugin.velocity.event_handlers.EventDispatch;
+import group.aelysium.rustyconnector.plugin.velocity.lib.players.Player;
+import group.aelysium.rustyconnector.toolkit.velocity.events.player.*;
+
+import java.util.UUID;
+
+public class OnPlayerChangeServer {
+    /**
+     * Also runs when a player first joins the proxy
+     */
+    @Subscribe(order = PostOrder.FIRST)
+    public EventTask onPlayerChangeServer(ServerPreConnectEvent event) {
+            return EventTask.async(() -> {
+                Player player = new Player(event.getPlayer());
+
+                try {
+                    RegisteredServer newRawServer = event.getOriginalServer();
+                    RegisteredServer oldRawServer = event.getPreviousServer();
+
+                    MCLoader newServer = new MCLoader.Reference(UUID.fromString(newRawServer.getServerInfo().getName())).get();
+
+                    if (oldRawServer == null) { // Player just connected to proxy. This isn't a server switch.
+                        proxyJoin(newServer, player);
+                        return;
+                    }
+                    MCLoader oldServer = new MCLoader.Reference(UUID.fromString(oldRawServer.getServerInfo().getName())).get();
+
+                    serverSwitch(oldServer, newServer, player);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            });
+    }
+
+    /**
+     * Fires when a player first joins the proxy.
+     */
+    protected void proxyJoin(MCLoader newServer, Player player) {
+        EventDispatch.UnSafe.fireAndForget(new FamilyPostJoinEvent(newServer.family(), newServer, player));
+        EventDispatch.UnSafe.fireAndForget(new NetworkJoinEvent(newServer.family(), newServer, player));
+    }
+
+    /**
+     * Fires when the player is switching from one server on the proxy to another server on the proxy.
+     * Regardless of the families that poses those servers.
+     */
+    protected void serverSwitch(MCLoader oldServer, MCLoader newServer, Player player) {
+        boolean isTheSameFamily = newServer.family().equals(oldServer.family());
+
+        if(!isTheSameFamily) familySwitch(oldServer, newServer, player);
+
+        EventDispatch.UnSafe.fireAndForget(new FamilyInternalSwitchEvent(newServer.family(), oldServer, newServer, player));
+        EventDispatch.UnSafe.fireAndForget(new MCLoaderLeaveEvent(oldServer, player, false));
+        EventDispatch.UnSafe.fireAndForget(new MCLoaderJoinEvent(newServer, player));
+        EventDispatch.UnSafe.fireAndForget(new MCLoaderSwitchEvent(oldServer, newServer, player));
+    }
+
+    /**
+     * Fires if the player is switching from one family to another family.
+     */
+    protected void familySwitch(MCLoader oldServer, MCLoader newServer, Player player) {
+        EventDispatch.UnSafe.fireAndForget(new FamilySwitchEvent(oldServer.family(), newServer.family(), oldServer, newServer, player));
+        EventDispatch.UnSafe.fireAndForget(new FamilyLeaveEvent(oldServer.family(), oldServer, player, false));
+        EventDispatch.UnSafe.fireAndForget(new FamilyPostJoinEvent(newServer.family(), newServer, player));
+    }
+}

plugin/proxy/src/main/java/group/aelysium/OnPlayerChooseInitialServer.java

@@ -0,0 +1,136 @@
+package group.aelysium;
+
+import com.velocitypowered.api.event.EventTask;
+import com.velocitypowered.api.event.PostOrder;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.player.PlayerChooseInitialServerEvent;
+import group.aelysium.rustyconnector.core.common.exception.NoOutputException;
+import group.aelysium.rustyconnector.plugin.velocity.central.Tinder;
+import group.aelysium.rustyconnector.plugin.velocity.event_handlers.EventDispatch;
+import group.aelysium.rustyconnector.plugin.velocity.lib.dynamic_teleport.injectors.InjectorService;
+import group.aelysium.rustyconnector.plugin.velocity.lib.friends.FriendsService;
+import group.aelysium.rustyconnector.plugin.velocity.lib.lang.ProxyLang;
+import group.aelysium.rustyconnector.plugin.velocity.lib.players.Player;
+import group.aelysium.rustyconnector.toolkit.core.logger.PluginLogger;
+import group.aelysium.rustyconnector.toolkit.velocity.events.player.FamilyPostJoinEvent;
+import group.aelysium.rustyconnector.toolkit.velocity.family.Family;
+import group.aelysium.rustyconnector.toolkit.velocity.family.scalar_family.IRootFamily;
+import group.aelysium.rustyconnector.toolkit.velocity.family.whitelist.IWhitelist;
+import group.aelysium.rustyconnector.toolkit.velocity.friends.IFriendRequest;
+import group.aelysium.rustyconnector.toolkit.velocity.player.IPlayer;
+import group.aelysium.rustyconnector.toolkit.velocity.server.IMCLoader;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+public class OnPlayerChooseInitialServer {
+    /**
+     * Runs when a player first joins the proxy
+     */
+    @Subscribe(order = PostOrder.LAST)
+    public EventTask onPlayerChooseInitialServer(PlayerChooseInitialServerEvent event) {
+        return EventTask.async(() -> {
+            Tinder api = Tinder.get();
+            PluginLogger logger = api.logger();
+            Player player = new Player(event.getPlayer());
+            com.velocitypowered.api.proxy.Player eventPlayer = event.getPlayer();
+
+            // Check for network whitelist
+            try {
+                IWhitelist whitelist = api.services().whitelist().proxyWhitelist();
+                if (whitelist == null) throw new NoOutputException();
+                if (!whitelist.validate(player)) {
+                    logger.log("Player isn't whitelisted on the proxy whitelist! Kicking...");
+                    player.disconnect(Component.text(whitelist.message()));
+                    return;
+                }
+            } catch (Exception ignore) {}
+
+            connect(event, player);
+
+            // Store the player once they join the network
+            // If they've joined recently, this will resolve pretty quickly.
+            try {
+                player.store();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+            // Check for active friend requests
+            try {
+                FriendsService friendsService = api.services().friends().orElseThrow();
+                List<IFriendRequest> requests = friendsService.findRequestsToTarget(player);
+
+                if(requests.size() == 0) throw new NoOutputException();
+
+                eventPlayer.sendMessage(ProxyLang.FRIENDS_JOIN_MESSAGE.build(requests));
+            } catch (Exception ignore) {}
+
+            // Check for online friends
+            try {
+                FriendsService friendsService = api.services().friends().orElseThrow();
+                List<IPlayer> friends = friendsService.friendStorage().get(player).orElseThrow();
+
+                if(friends.size() == 0) throw new NoOutputException();
+
+                List<com.velocitypowered.api.proxy.Player> onlineFriends = new ArrayList<>();
+                friends.forEach(friend -> {
+                    try {
+                        com.velocitypowered.api.proxy.Player onlineFriend = friend.resolve().orElseThrow();
+
+                        if (onlineFriend.isActive()) onlineFriends.add(onlineFriend);
+                    } catch (Exception ignore) {}
+                });
+
+                if(friends.size() == 0 || onlineFriends.size() == 0) {
+                    eventPlayer.sendMessage(ProxyLang.NO_ONLINE_FRIENDS);
+                    throw new NoOutputException();
+                }
+
+                eventPlayer.sendMessage(ProxyLang.ONLINE_FRIENDS);
+                final Component[] friendsList = {Component.text("", NamedTextColor.WHITE)};
+                onlineFriends.forEach(friend -> friendsList[0] = friendsList[0].append(Component.text(friend.getUsername())));
+                eventPlayer.sendMessage(Component.join(JoinConfiguration.commas(true), friendsList));
+
+                onlineFriends.forEach(friend -> friend.sendMessage(ProxyLang.FRIEND_JOIN.build(player)));
+            } catch (Exception ignore) {}
+        });
+    }
+
+    private static void connect(PlayerChooseInitialServerEvent event, IPlayer player) {
+        Tinder api = Tinder.get();
+        try {
+            // Handle family injectors if they exist
+            try {
+                InjectorService injectors = api.services().dynamicTeleport().orElseThrow().services().injector().orElseThrow();
+
+                Family family = api.services().family().rootFamily();
+                if(family == null) throw new RuntimeException("Unable to fetch a server to connect to.");
+
+                String host = event.getPlayer().getVirtualHost().map(InetSocketAddress::getHostString).orElse("").toLowerCase(Locale.ROOT);
+
+                family = injectors.familyOf(host).orElseThrow();
+                IMCLoader server = family.smartFetch().orElseThrow();
+
+                EventDispatch.UnSafe.fireAndForget(new FamilyPostJoinEvent(family, server, player));
+                event.setInitialServer(server.registeredServer());
+                return;
+            } catch (Exception ignore) {}
+
+            IRootFamily family = api.services().family().rootFamily();
+            IMCLoader server = family.smartFetch().orElseThrow();
+
+            EventDispatch.UnSafe.fireAndForget(new FamilyPostJoinEvent(family, server, player));
+            event.setInitialServer(server.registeredServer());
+        } catch (NoOutputException ignore) {
+        } catch (Exception e) {
+            player.sendMessage(Component.text("We were unable to connect you!"));
+            e.printStackTrace();
+        }
+    }
+}