Figura Server side (or FSB)

build.gradle

@@ -8,7 +8,7 @@ architectury {
 	minecraft = rootProject.minecraft_version
 }
 
-subprojects {
+rootProject.mod_projects.split(",").each { project(":$it") {
 	apply plugin: "dev.architectury.loom"
 	apply plugin: "io.github.juuxel.loom-vineflower"
 
@@ -39,7 +39,7 @@ subprojects {
 		modCompileOnly "maven.modrinth:immediatelyfast:$immediately_fast"
 		modCompileOnly "maven.modrinth:iris:$iris"
 	}
-}
+}}
 
 allprojects {
 	apply plugin: "java"

gradle.properties

@@ -7,6 +7,7 @@ java_version = 17
 minecraft_version = 1.20.1
 mappings = 1
 enabled_platforms = fabric,forge
+mod_projects = common,common:mojmap,fabric,forge
 
 # Mod Properties
 mod_version = 0.1.4

server-common/build.gradle

@@ -0,0 +1,7 @@
+repositories {
+
+}
+
+dependencies {
+    implementation 'com.google.code.gson:gson:2.11.0'
+}

server-common/src/main/java/org/figuramc/figura/server/DeferredPacketsQueue.java

@@ -0,0 +1,40 @@
+package org.figuramc.figura.server;
+
+import org.figuramc.figura.server.events.Events;
+import org.figuramc.figura.server.events.packets.DeferredPacketErrorEvent;
+import org.figuramc.figura.server.packets.Packet;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+public class DeferredPacketsQueue {
+    private final FiguraServer parent;
+    private final HashMap<UUID, LinkedList<CompletableFuture<Packet>>> queues = new HashMap<>();
+
+    public DeferredPacketsQueue(FiguraServer parent) {
+        this.parent = parent;
+    }
+
+    public void sendPacket(UUID receiver, CompletableFuture<Packet> futurePacket) {
+        queues.computeIfAbsent(receiver, u -> new LinkedList<>()).add(futurePacket);
+    }
+
+    void tick() {
+
+    }
+
+    private boolean completedAndSent(UUID receiver, CompletableFuture<Packet> packet) {
+        if (packet.isDone()) {
+            try {
+                Packet p = packet.join();
+                parent.sendPacket(receiver, p);
+            } catch (Exception e) {
+                Events.call(new DeferredPacketErrorEvent(e));
+            }
+            return true;
+        }
+        return false;
+    }
+}

server-common/src/main/java/org/figuramc/figura/server/FiguraServer.java

@@ -0,0 +1,110 @@
+package org.figuramc.figura.server;
+
+import org.figuramc.figura.server.avatars.FiguraServerAvatarManager;
+import org.figuramc.figura.server.events.Events;
+import org.figuramc.figura.server.events.HandshakeEvent;
+import org.figuramc.figura.server.events.packets.OutcomingPacketEvent;
+import org.figuramc.figura.server.packets.Packet;
+import org.figuramc.figura.server.packets.handlers.c2s.C2SPacketHandler;
+import org.figuramc.figura.server.packets.s2c.S2CBackendHandshakePacket;
+import org.figuramc.figura.server.utils.Identifier;
+import org.figuramc.figura.server.utils.Utils;
+
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+public abstract class FiguraServer {
+    private static FiguraServer INSTANCE;
+    private final FiguraUserManager userManager = new FiguraUserManager(this);
+    private final FiguraServerAvatarManager avatarManager = new FiguraServerAvatarManager(this);
+    private FiguraServerConfig config;
+    private final DeferredPacketsQueue deferredPacketsQueue = new DeferredPacketsQueue(this);
+    protected FiguraServer() {
+        if (INSTANCE != null) throw new IllegalStateException("Can't create more than one instance of FiguraServer");
+        INSTANCE = this;
+    }
+
+    public static FiguraServer getInstance() {
+        return INSTANCE;
+    }
+
+    public abstract Path getFiguraFolder();
+
+    public abstract void registerHandler(Identifier packetId, C2SPacketHandler<?> handler);
+    public abstract void unregisterHandler(Identifier packetId);
+
+    public Path getUsersFolder() {
+        return getFiguraFolder().resolve("users");
+    }
+
+    public Path getAvatarsFolder() {
+        return getFiguraFolder().resolve("avatars");
+    }
+
+    public Path getAvatar(byte[] hash) {
+        return getAvatarsFolder().resolve("%s.nbt".formatted(Utils.hexFromBytes(hash)));
+    }
+
+    public Path getAvatarMetadata(byte[] hash) {
+        return getAvatarsFolder().resolve("%s.mtd".formatted(Utils.hexFromBytes(hash)));
+    }
+
+    public Path getUserdataFile(UUID user) {
+        return getUsersFolder().resolve("%s.pl".formatted(Utils.uuidToHex(user)));
+    }
+
+    public final void init() {
+
+    }
+
+    public final void close() {
+        INSTANCE = null;
+    }
+
+    protected final void tick() {
+        deferredPacketsQueue.tick();
+        avatarManager.tick();
+    }
+
+    public final void sendHandshake(UUID receiver) {
+        var event = Events.call(new HandshakeEvent(receiver));
+        if (!event.isCancelled()) {
+            userManager.expect(receiver);
+            sendPacket(receiver, new S2CBackendHandshakePacket(
+                    config.pings(),
+                    config.pingsRateLimit(),
+                    config.pingsSizeLimit(),
+                    config.avatars(),
+                    config.avatarSizeLimit(),
+                    config.avatarsCountLimit()
+            ));
+        }
+    }
+
+    public FiguraServerConfig config() {
+        return config;
+    }
+
+    public FiguraUserManager userManager() {
+        return userManager;
+    }
+
+    public final void sendPacket(UUID receiver, Packet packet) {
+        OutcomingPacketEvent event = new OutcomingPacketEvent(receiver, packet);
+        Events.call(event);
+        if (!event.isCancelled()) {
+            sendPacketInternal(receiver, packet);
+        }
+    }
+
+    public final void sendDeferredPacket(UUID receiver, CompletableFuture<Packet> packet) {
+        deferredPacketsQueue.sendPacket(receiver, packet);
+    }
+
+    protected abstract void sendPacketInternal(UUID receiver, Packet packet);
+
+    public FiguraServerAvatarManager avatarManager() {
+        return avatarManager;
+    }
+}

server-common/src/main/java/org/figuramc/figura/server/FiguraServerConfig.java

@@ -0,0 +1,47 @@
+package org.figuramc.figura.server;
+
+public final class FiguraServerConfig {
+    private boolean pings = true;
+    private boolean avatars = true;
+
+    private int pingsRateLimit = 20;
+    private int pingsSizeLimit = 10240;
+
+    private int avatarSizeLimit = 102400;
+    private int avatarsCountLimit = 1;
+
+    private int garbageCollectionTicks = 1200;
+    private int maxOutcomingChunkSize = 50000;
+
+    public boolean pings() {
+        return pings;
+    }
+
+    public boolean avatars() {
+        return avatars;
+    }
+
+    public int pingsRateLimit() {
+        return pingsRateLimit;
+    }
+
+    public int pingsSizeLimit() {
+        return pingsSizeLimit;
+    }
+
+    public int avatarSizeLimit() {
+        return avatarSizeLimit;
+    }
+
+    public int avatarsCountLimit() {
+        return avatarsCountLimit;
+    }
+
+    public int garbageCollectionTicks() {
+        return garbageCollectionTicks;
+    }
+
+    public int s2cChunkSize() {
+        return maxOutcomingChunkSize;
+    }
+}