Start implementing the Master Server.

src/Master/MasterServer.zig

@@ -0,0 +1,58 @@
+//! The Master Server keeps track of all Cluster Servers. It also allocates
+//! connecting users to Cluster Servers automatically, or allows the users
+//! to manually select one.
+
+const std = @import("std");
+const sustenet = @import("root").sustenet;
+const network = @import("network");
+const world = sustenet.world;
+
+const ArrayList = std.ArrayList;
+const AutoHashMap = std.AutoHashMap;
+const BaseServer = @import("root").sustenet.transport.BaseServer;
+
+const MasterServer = @This();
+
+/// A list of clients that have been registered as cluster clients.
+cluster_ids: ArrayList(i32),
+
+cluster_info: AutoHashMap(i32, world.ClusterInfo),
+
+super: BaseServer,
+
+pub fn new(allocator: std.mem.Allocator, max_connections: ?i32, port: ?u16) !MasterServer {
+    // RSAManager.loadPubKeys();
+    // AESManager.loadKeys();
+
+    var master_server = MasterServer{
+        .super = try BaseServer.new(
+            allocator,
+            BaseServer.ServerType.MasterServer,
+            max_connections orelse 0,
+            port orelse 6256,
+        ),
+
+        .cluster_ids = ArrayList(i32).init(allocator),
+        .cluster_info = AutoHashMap(i32, world.ClusterInfo).init(allocator),
+    };
+
+    MasterServer.initializeData(allocator);
+
+    try master_server.super.start(allocator);
+
+    return master_server;
+}
+
+fn initializeData(allocator: std.mem.Allocator) void {
+    if (BaseServer.packetHandlers == null) {
+        BaseServer.packetHandlers = AutoHashMap(i32, BaseServer.packetHandler).init(allocator);
+    }
+}
+
+//#region Memory Functions
+pub fn deinit(self: *MasterServer) void {
+    self.cluster_ids.deinit();
+    self.cluster_info.deinit();
+    self.super.deinit();
+}
+//#endregion

src/Master/master.zig

@@ -0,0 +1,7 @@
+//! Master namespace
+
+pub const MasterServer = @import("MasterServer.zig");
+
+test {
+    @import("std").testing.refAllDecls(@This());
+}

src/Transport/BaseServer.zig

@@ -14,7 +14,7 @@ const BaseServer = @This();
 pub const ServerType = enum { MasterServer, ClusterServer };
 
 pub const packetHandler = *const fn (from_client: i32, packet: i32) void;
-var packetHandlers: ?AutoHashMap(i32, packetHandler) = null;
+pub var packetHandlers: ?AutoHashMap(i32, packetHandler) = null;
 
 // UDP equivalent is in BaseClient.UdpHandler.socket
 // tcp_listener: i32, // Just set as i32 to shutup the compiler
@@ -32,7 +32,7 @@ released_ids: std.ArrayList(i32),
 // onReceived: BaseEvent(comptime []u8),
 
 pub fn new(allocator: std.mem.Allocator, server_type: ServerType, max_connections: i32, port: ?u16) !BaseServer {
-    var baseServer = BaseServer{
+    return BaseServer{
         .server_type = server_type,
         .server_type_name = serverTypeToString(server_type),
         .max_connections = max_connections,
@@ -41,14 +41,14 @@ pub fn new(allocator: std.mem.Allocator, server_type: ServerType, max_connection
         .clients = AutoHashMap(comptime i32, comptime BaseClient).init(allocator),
         .released_ids = std.ArrayList(comptime i32).init(allocator),
     };
-    baseServer.initializeData(allocator);
-
-    return baseServer;
 }
 
 //#region Connection Functions
 pub fn start(self: *BaseServer, allocator: std.mem.Allocator) !void {
     if (Constants.DEBUGGING) {
+
+        // TODO
+        // onConnection.Run += (id) => DebugServer(serverTypeName, $"Client#{id} has connected.");
         const header = try std.fmt.allocPrint(allocator, "Starting {s} on Port {d}", .{ self.server_type_name, self.port });
         defer allocator.free(header);
         Utilities.consoleHeader(header);
@@ -64,14 +64,6 @@ pub fn start(self: *BaseServer, allocator: std.mem.Allocator) !void {
 }
 //#endregion
 
-//#region Data Functions
-pub fn initializeData(_: *BaseServer, allocator: std.mem.Allocator) void {
-    if (BaseServer.packetHandlers == null) {
-        BaseServer.packetHandlers = AutoHashMap(i32, packetHandler).init(allocator);
-    }
-}
-//#endregion
-
 //#region Utillity Functions
 pub fn serverTypeToString(server_type: ServerType) []const u8 {
     switch (server_type) {
@@ -81,8 +73,12 @@ pub fn serverTypeToString(server_type: ServerType) []const u8 {
 }
 //#endregion
 
+//#region Data Functions
+
+//#endregion
+
 //#region Memory Functions
-pub fn deinit(self: *BaseServer, _: std.mem.Allocator) void {
+pub fn deinit(self: *BaseServer) void {
     // Free clients
     {
         var it = self.clients.iterator();
@@ -103,3 +99,7 @@ pub fn deinit(self: *BaseServer, _: std.mem.Allocator) void {
     }
 }
 //#endregion
+
+pub fn debugServer(serverTypeName: []const u8, msg: []const u8) void {
+    Utilities.printMsg("({s}) {s}", .{ serverTypeName, msg });
+}

src/main.zig

@@ -7,18 +7,17 @@ const eql = std.mem.eql;
 const print = std.debug.print;
 const ArrayList = std.ArrayList;
 const transport = sustenet.transport;
+const master = sustenet.master;
 const clients = sustenet.clients;
 
 const Constants = sustenet.utils.Constants;
 const BaseServer = transport.BaseServer;
 
-pub var client_list: std.ArrayList(clients.Client) = undefined;
-
 var is_running = false;
 
-// pub var clients: []Clients.Client;
-// pub var cluster: World = undefined;
-// pub var master = undefined;
+pub var client_list: std.ArrayList(clients.Client) = undefined;
+// pub var cluster_server: world.ClusterServer = undefined;
+pub var master_server: master.MasterServer = undefined;
 
 pub fn main() !void {
     // Get allocator
@@ -88,7 +87,10 @@ pub fn main() !void {
         } else if (eql(u8, arg, "cluster") or eql(u8, arg, "cs")) {
             return;
         } else if (eql(u8, arg, "master") or eql(u8, arg, "ms")) {
-            return;
+            // TODO Use config file
+
+            master_server = try master.MasterServer.new(allocator, 0, 4337);
+            defer master_server.deinit();
         } else {
             print("Add 'help' to this command to get a list of options.\n", .{});
             return;

src/sustenet.zig

@@ -1,9 +1,11 @@
 pub const clients = @import("Clients/clients.zig");
 pub const core = @import("Core/core.zig");
 pub const events = @import("Events/events.zig");
+pub const master = @import("Master/master.zig");
 pub const network = @import("Network/network.zig");
 pub const transport = @import("Transport/transport.zig");
 pub const utils = @import("Utils/utils.zig");
+pub const world = @import("World/world.zig");
 
 pub const zig_numerics = @import("deps/zig_numerics/zig_numerics.zig");