Null check instead of initilizing empty work

.gitea/workflows/build.yaml

@@ -0,0 +1,48 @@
+name: Build and publish mistserver
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    runs-on: alpine-linux
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: Restore Dependencies
+        run: dotnet restore ./MistoxServer
+
+      - name: Dotnet Publish
+        run: dotnet publish ./MistoxServer --configuration Release --output ./publish --no-restore
+
+      - name: Archive Production Artifacts
+        run: |
+          cd ./publish
+          zip -r ../mistserver-${{ github.ref_name }}.zip .
+          cd ..
+
+      # 2. Publish directly to Gitea Releases
+      - name: Create Gitea Release
+        uses: https://gitea.com/actions/release-action@main
+        with:
+          # Automatically uses the tag string pushed (e.g., v1.2.3)
+          name: "Release ${{ github.ref_name }}"
+          
+          # Change this text to your desired version description (Supports Markdown)
+          body: |
+            ## Mistserver Version ${{ github.ref_name }}
+            Automated deployment build compiled on Alpine Linux.
+            
+            ### Changelog
+            - Compiled via Gitea Actions
+            - Run ID: ${{ github.run_id }}
+          
+          # Target the zipped artifact we generated in step 1
+          files: |
+            mistserver-*.zip
+          
+          # Uses Gitea's automatically injected repository token for authorization
+          api_key: '${{ secrets.GITHUB_TOKEN }}'

CLI/ClientExample.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Threading.Tasks;
+using Mistox;
+using Mistox.Client;
+
+class clientExample {
+
+    public MistoxClient? clientObject;
+
+    void onServerConnected() {
+        Console.WriteLine("Connected to server sucessfully");
+    }
+    
+    void onClientConnected(mUDPClient user) {
+        Console.WriteLine("User connected to server with username: " + user.UserName);
+    }
+
+    void onClientJoined(mUDPClient user) {
+        Console.WriteLine("User is now in range of you and UDP connections started with user : " + user.UserName);
+    }
+
+    void onReceive(mUDPClient? user, dynamic data) {
+        switch (data){
+            case MessagePacket packet: 
+                if (user == null) {
+                    Console.WriteLine($"MSG From [Serverx]: {packet.Data}");
+                } else {
+                    Console.WriteLine($"MSG From [{user.UserName}]: {packet.Data}");
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    void onClientLeft(mUDPClient user) {
+        Console.WriteLine("User is no longer in range of you and UDP connections ended with user : " + user.UserName);
+    }
+
+    void onClientDisconnected(mUDPClient user) {
+        Console.WriteLine("User disconnected from server with username: " + user.UserName);
+    }
+
+    void onServerDisconnected() {
+        Console.WriteLine("Disconnected from server");
+    }
+
+    public async Task StartClient(string userName, string host, int port, string password) {
+        clientObject = GameServer.newClient(userName, host, port, password);
+        if (clientObject == null) return;
+        clientObject.onServerConnected += onServerConnected;
+        clientObject.onUserConnected += onClientConnected;
+        clientObject.onUserJoined += onClientJoined;
+        clientObject.onDataReceived += onReceive;
+        clientObject.onUserLeft += onClientLeft;
+        clientObject.onUserDisconnected += onClientDisconnected;
+        clientObject.onServerDisconnected += onServerDisconnected;
+    }
+
+}

CLI/Help/Documentation.txt

@@ -1,15 +0,0 @@
-The servers default port is 25566
-
-
-TCPServer.cs
-	Void		TCPServer()						Initilizes the server object on the default game port of 25566
-	Void		SendAll(string Data)			Send data to all the clients
-	Event		onReceived						Fires when data is received from a client
-
-TCPClient.cs
-	Void		TCPClient(String ServerIP)		Initilizes the client object
-	Void		Send(String Data)				Sends data to the server
-	Event		onReceived						Fires when data is received from the server
-
-UDPClient.cs
-	

CLI/MistServer.csproj

@@ -9,6 +9,7 @@
     <Company>Mistox.net</Company>
     <Product>Mistox Game Server</Product>
     <Description>Game Server for Mistox Games and partners</Description>
+    <Nullable>enable</Nullable>
     <SignAssembly>false</SignAssembly>
   </PropertyGroup>
 

CLI/Program.cs

@@ -1,85 +1,48 @@
 using System;
 using System.Threading.Tasks;
-using MistoxServer;
 
 namespace MistoxHolePunch {
+
+    enum Mode {
+        Server,
+        Client
+    }
+
     class Program {
 
-        static IMistoxServer serverObj;
+        static serverExample? server;
-        static bool running = true;
+        static clientExample? client;
+        static Mode mode;
 
-        void onConnected( object sender, EventArgs e ) {
+        async Task StartServer(string name, int port) {
-            // sender and e are always null
+            server = new serverExample();
-            // put connected functions in here
+            await server.StartServer(name, port);
-        }
+            // On a game this sleep loop isnt needed
-
+            if (server.serverObject == null) return;
-        void slowReceive( object obj, EventArgs e ) {
+            while (server.serverObject.Alive) {
-            if ( serverObj is ServerInterface ) {
+                // becuase this is a console app if we dont keep the main thread alive the app will close
-                // If ServerMode is passive obj is byte[] and Send takes in byte[]
+                await Task.Delay(5000);
-                // If Servermode is Athoritiative obj is the Class type sent and Send takes in any Class type except generic object
-
-                // Check to make sure data is correct before relaying
-                // Also perform server specific checks in here
-                // IE player didnt teleport or is shooting from 20 feet from his body
-                serverObj.Send( obj, SendType.SlowUpdate );
-            }
-            Console.Write( "Received TCP : " );
-            Console.WriteLine( obj );
-        }
-
-        void fastReceive( object obj, EventArgs e ) {
-            if( serverObj is ServerInterface ) {
-                // If ServerMode is passive obj is byte[] and Send takes in byte[]
-                // If Servermode is Athoritiative obj is the Class type sent and Send takes in any Class type except generic object
-
-                // Check to make sure data is correct before relaying
-                // Also perform server specific checks in here
-                // IE player didnt teleport or is shooting from 20 feet from his body
-                serverObj.Send( obj, SendType.FastUpdate );
-            }
-            Console.Write( "Received UDP : " );
-            Console.WriteLine( obj );
-        }
-
-        void onDisconnected( object sender, EventArgs e ) {
-            // sender and e are always null
-            // put disconnected functions in here
-        }
-
-        static string host = "example.com";
-        static int port = 7300;
-        static ServerMode mode = ServerMode.Passive;
-
-        async Task RunServer() {
-            serverObj = mServer.newServer( Convert.ToInt32( port ), mode );
-            serverObj.onConnected += onConnected;
-            serverObj.onSlowReceive += slowReceive;
-            serverObj.onFastReceive += fastReceive;
-            serverObj.onDisconnected += onDisconnected;
-            while ( running ) {
-                // Stop this thread for 1 second so the CPU isnt 100%
-                // All the real work is on different threads
-                // While loop needs to exist so our main thread doesnt close
-                await Task.Delay( 1000 ); 
             }
         }
 
-        async Task RunClient() {
+        async Task StartClient(string username, string host, int port, string password) {
-            serverObj = mServer.newClient( host, Convert.ToInt32( port ) );
+            client = new clientExample();
-            serverObj.onConnected += onConnected;
+            await client.StartClient(username, host, port, password);
-            serverObj.onSlowReceive += slowReceive;
+            // On a game this sleep loop isnt needed
-            serverObj.onFastReceive += fastReceive;
+            if (client.clientObject == null) return;
-            serverObj.onDisconnected += onDisconnected;
+            while (client.clientObject.Alive) {
-            while( running ) {
+                // becuase this is a console app if we dont keep the main thread alive the app will close
-                // Stop this thread for 1 second so the CPU isnt 100%
+                await Task.Delay(5000);
-                // All the real work is on different threads
-                // While loop needs to exist so our main thread doesnt close
-                await Task.Delay( 1000 );
             }
         }
 
-        static async Task Main(string[] args) {
+        async Task Main(string[] args) {
-            string Task = args.Length > 0 ? args[0].ToLower() : null;
+            string Job = args.Length > 0 ? args[0].ToLower() : "";
+
+            string host = "";
+            string name = "";
+            string pass = "";
+            int port = 0;
 
             for( int i = 0; i < args.Length; i++ ) {
                 string cur = args[i].ToLower();
@@ -87,25 +50,21 @@ namespace MistoxHolePunch {
                     host = args [i + 1];
                 } else if( cur == "/p" || cur == "-p" ) {
                     port = Convert.ToInt32( args [i + 1] );
-                } else if( cur == "/a" || cur == "-a" ) {
+                } else if( cur == "/n" || cur == "-n" ) {
-                    mode = ServerMode.Authoritative;
+                    name = args [i + 1];
+                } else if( cur == "/u" || cur == "-u" ) {
+                    pass = args [i + 1];
                 }
             }
 
-            if (Task == "/?" || Task == "--help") {
+            if (Job == "/?" || Job == "--help") {
                 Console.WriteLine(HelpDocumentation.HelpText);
-            } else if (Task == "/s" || Task == "-s") {
+            } else if (Job == "/s" || Job == "-s") {
-                Program prog = new Program();
+                await StartServer(name, port);
-                await prog.RunServer();
+            } else if (Job == "/c" || Job == "-c") {
-            } else if (Task == "/c" || Task == "-c") {
+                await StartClient(name, host, port, pass);
-                Program prog = new Program();
-                await prog.RunClient();
             } else {
-                host = "example.com";
+                await StartServer("example.com", 4500);
-                port = 1500;
-                Program prog = new Program();
-                //prog.RunClient();
-                await prog.RunServer();
             }
         }
 

CLI/ServerExample.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Threading.Tasks;
+using Mistox;
+using Mistox.Server;
+
+class serverExample {
+
+    public MistoxServer? serverObject;
+    
+    void onClientConnected(ServerConnection user) {
+        Console.WriteLine("User connected with username: " + user.UserName);
+    }
+
+    void onReceive(ServerConnection user, dynamic data) {
+        switch (data){
+            case MessagePacket packet when user.IsAuthenticated: 
+                Console.WriteLine($"MSG From [{user.UserName}]: {packet.Data}");
+                break;
+            default:
+                break;
+        }
+    }
+
+    void onClientDisconnected(ServerConnection user) {
+        Console.WriteLine("User disconnected with username: " + user.UserName);
+    }
+
+    public async Task StartServer(string serverName, int port) {
+        serverObject = GameServer.newServer(serverName, port);
+        serverObject.onUserConnected += onClientConnected;
+        serverObject.onDataReceived += onReceive;
+        serverObject.onUserDisconnected += onClientDisconnected;
+    }
+
+}

CLI/packetList.cs

@@ -0,0 +1,6 @@
+using Mistox.Attributes;
+
+[mPacket]
+class MessagePacket {
+    public string Data { get; set; } = "";
+}

MistoxServer/Client/MistoxClient.cs

@@ -20,7 +20,7 @@ namespace Mistox.Client {
         public Vector3 Position { get; set; } = new Vector3(0, 0, 0);               // My world position
         public float MaxNetworkRenderDistance { get; private set; } = 0;            // The distance for connections
 
-        public mTCPClient ServerConnection {get; private set; }                     // Global TCP Server Connection
+        public mTCPClient? ServerConnection {get; private set; }                     // Global TCP Server Connection
         public UdpClient ClientSocket { get; private set; }                         // Global UDP Sender
         public UDPReceiver UdpReceiver { get; private set; }                        // Global UDP Receiver
 
@@ -87,13 +87,17 @@ namespace Mistox.Client {
                 if (!clientConnections.ContainsKey(remoteHost)) {
                     mUDPClient newConnection = new mUDPClient(this, remoteHost);
                     clientConnections[remoteHost] = newConnection;
+                    InvokeOnUserJoined(newConnection);
                 }
             }
 
             // Remove users that left
             foreach (IPEndPoint key in clientConnections.Keys) {
                 if (!activeIps.Contains(key.Address)) {
-                    clientConnections.TryRemove(key, out _);
+                    mUDPClient? user;
+                    clientConnections.TryRemove(key, out user);
+                    if (user == null) return;
+                    InvokeOnUserLeft(user);
                 }
             }
             
@@ -116,6 +120,7 @@ namespace Mistox.Client {
 
         async Task TryAuth() {
             Console.WriteLine("Attempting to authenticate against the server...");
+            if (ServerConnection == null) return;
             await ServerConnection.Send(new UserAuthPacket {
                 UserName = UserName,
                 ConnectionKey = ConnectionKey
@@ -134,7 +139,7 @@ namespace Mistox.Client {
 /////////////////////////////
 
         // When (self) connects to the server
-        public event Action onServerConnected;
+        public event Action? onServerConnected;
         public void InvokeOnServerConnected(){
             Alive = true;
             Task.Run(async () => {
@@ -146,20 +151,20 @@ namespace Mistox.Client {
         }
 
         // When any user connects to the server (self) hasn't seen yet
-        public event Action<string> onUserJoined;
+        public event Action<mUDPClient>? onUserJoined;
-        public void InvokeOnUserJoined(string UserName){
+        public void InvokeOnUserJoined(mUDPClient User){
-            onUserJoined?.Invoke(UserName);
+            onUserJoined?.Invoke(User);
         }
 
         // When user is within range of (self) and network rendering starts
-        public event Action<mUDPClient> onUserConnected;
+        public event Action<mUDPClient>? onUserConnected;
-        public void InvokeOnUserConnected(mUDPClient ConnectedUser){
+        public void InvokeOnUserConnected(mUDPClient User){
-            onUserConnected?.Invoke(ConnectedUser);
+            onUserConnected?.Invoke(User);
         }
 
         // When generic data is received
-        public event Action<dynamic> onDataReceived;
+        public event Action<mUDPClient?, dynamic>? onDataReceived;
-        public void InvokeOnReceived(dynamic DataPacket, mUDPClient remote = null){
+        public void InvokeOnReceived(dynamic DataPacket, mUDPClient? remote = null){
             switch (DataPacket as object)  {
                 case HeartbeatPacket packet:
                     HeartbeatReceived(packet); 
@@ -173,25 +178,25 @@ namespace Mistox.Client {
                     Console.WriteLine("Received a null packet.");
                     break;
                 default:
-                    onDataReceived?.Invoke(DataPacket);
+                    onDataReceived?.Invoke(remote, DataPacket);
                     break;
             }
         }
 
         // When user is no longer in range of (self) and network rendering stops
-        public event Action<mUDPClient> onUserDisconnected;
+        public event Action<mUDPClient>? onUserDisconnected;
-        public void InvokeOnUserDisconnected(mUDPClient DisconnectedUser){
+        public void InvokeOnUserDisconnected(mUDPClient User){
-            onUserDisconnected?.Invoke(DisconnectedUser);
+            onUserDisconnected?.Invoke(User);
         }
 
         // When any user disconnects from the server that isn't (self)
-        public event Action<string> onUserLeft;
+        public event Action<mUDPClient>? onUserLeft;
-        public void InvokeOnUserLeft(string UserName){
+        public void InvokeOnUserLeft(mUDPClient User){
-            onUserLeft?.Invoke(UserName);
+            onUserLeft?.Invoke(User);
         }
 
         // When (self) disconnects to the server
-        public event Action onServerDisconnected;
+        public event Action? onServerDisconnected;
         public void InvokeOnServerDisconnected(){
             Alive = false;
             onServerDisconnected?.Invoke();
@@ -219,6 +224,7 @@ namespace Mistox.Client {
         }
 
         public async Task SendServer<Packet>(Packet data) {
+            if (ServerConnection == null) return;
             await ServerConnection.Send( data );
         }
     }

MistoxServer/Client/TCPClient.cs

@@ -48,10 +48,11 @@ namespace Mistox.Client {
                         await ns.ReadExactlyAsync(payloadBuffer, 0, Header.DataLength);
 
                         // Create the dataobject
-                        dynamic dataobject = DataPacket.Deserialize( Header, payloadBuffer.AsMemory(DataPacket.HeaderLength, Header.DataLength) );
+                        object? dataobject = DataPacket.Deserialize( Header, payloadBuffer.AsMemory(DataPacket.HeaderLength, Header.DataLength) );
-
+                        if (dataobject != null) {
-                        // Return the object
+                            // Return the object
-                        _parent.InvokeOnReceived(dataobject);
+                            _parent.InvokeOnReceived(dataobject);   
+                        }
 
                     }
                 } catch (Exception e) {

MistoxServer/Client/UDPReceiver.cs

@@ -21,9 +21,9 @@ namespace Mistox.Client {
                     UdpReceiveResult udpPacket = await _parent.ClientSocket.ReceiveAsync();
 
                     // Try find the user
-                    mUDPClient client = null;
+                    mUDPClient? client = null;
-                    bool clientExists = _parent.clientConnections.TryGetValue(udpPacket.RemoteEndPoint, out client);
+                    _parent.clientConnections.TryGetValue(udpPacket.RemoteEndPoint, out client);
-                    if (clientExists) {
+                    if (client != null) {
                         
                         // Create the data readers
                         ReadOnlyMemory<byte> dataMemory = udpPacket.Buffer.AsMemory();
@@ -39,10 +39,12 @@ namespace Mistox.Client {
                         ReadOnlyMemory<byte> data = dataMemory.Slice(DataPacket.HeaderLength, Header.DataLength);
 
                         // Extract the object
-                        dynamic buildObj = DataPacket.Deserialize( Header, data );
+                        object? buildObj = DataPacket.Deserialize( Header, data );
+                        if (buildObj != null) {
 
-                        // Return the object
+                            // Return the object
-                        _parent.InvokeOnReceived( buildObj, client );
+                            _parent.InvokeOnReceived( buildObj, client );
+                        }
 
                     }
                 } catch( Exception e ) {

MistoxServer/GameServer.cs

@@ -19,7 +19,7 @@ namespace Mistox {
             return new MistoxServer(listenerAddress, serverName);
         }
 
-        public static MistoxClient newClient( string UserName, string ServerIPOrHostName, int Port, string ConnectionKey = "" ) {
+        public static MistoxClient? newClient( string UserName, string ServerIPOrHostName, int Port, string ConnectionKey = "" ) {
             
             // Build the network packet list
             NetworkPacketDictionary.BuildNetworkPacketList();

MistoxServer/MistServer.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>

MistoxServer/Server/MistoxServer.cs

@@ -72,15 +72,15 @@ namespace Mistox.Server {
 // Events
 /////////////////////////////
 
-        public event Action<ServerConnection> onUserConnected;
+        public event Action<ServerConnection>? onUserConnected;
         public void InvokeUserConnected( ServerConnection user ){
             Connections[user.UserName] = user;
             onUserConnected?.Invoke( user );
         }
 
-        public event Action<ServerConnection, object> onDataReceived;
+        public event Action<ServerConnection, object>? onDataReceived;
         public void InvokeDataReceived( ServerConnection user, dynamic data ){
-            switch (data)  {
+            switch (data) {
                 case UserAuthPacket packet when !user.IsAuthenticated:
                     _ = RunAsync(async () => {
                         await ProcessAuthRequest(user, packet); 
@@ -101,7 +101,7 @@ namespace Mistox.Server {
             }
         }
 
-        public event Action<ServerConnection> onUserDisconnected;
+        public event Action<ServerConnection>? onUserDisconnected;
         public void InvokeUserDisconnected( ServerConnection user ){
             Connections.Remove(user.UserName, out _);
             onUserDisconnected?.Invoke( user );

MistoxServer/Server/ServerConnection.cs

@@ -55,10 +55,11 @@ namespace Mistox.Server {
                         await ns.ReadExactlyAsync(payloadBuffer, 0, Header.DataLength, _cts.Token);
 
                         // Create the dataobject
-                        dynamic dataobject = DataPacket.Deserialize( Header, payloadBuffer.AsMemory(DataPacket.HeaderLength) );
+                        object? dataobject = DataPacket.Deserialize( Header, payloadBuffer.AsMemory(DataPacket.HeaderLength) );
-
+                        if (dataobject != null) {
-                        // Return the object
+                            // Return the object
-                        _parent.InvokeDataReceived(this, dataobject);
+                            _parent.InvokeDataReceived(this, dataobject);
+                        }
 
                     }
                 } catch (Exception e) {

MistoxServer/Server/ServerListener.cs

@@ -32,14 +32,15 @@ namespace Mistox.Server {
                     continue;
                 }
 
-                IPEndPoint remote = client.Client.RemoteEndPoint as IPEndPoint;
+                IPEndPoint? remote = client.Client.RemoteEndPoint as IPEndPoint;
+                if (remote != null) {
+                    string connectionID = Guid.NewGuid().ToString();
+                    _parent.Connections[connectionID] = new ServerConnection( client, _parent, remote) {
+                        UserName = connectionID
+                    };
 
-                string connectionID = Guid.NewGuid().ToString();
+                    Console.WriteLine( "New User Connected" );
-                _parent.Connections[connectionID] = new ServerConnection( client, _parent, remote) {
+                }
-                    UserName = connectionID
-                };
-
-                Console.WriteLine( "New User Connected" );
             }
             Dispose();
         }

MistoxServer/mPacket/DataPacket.cs

@@ -46,10 +46,10 @@ namespace Mistox {
             return writer.WrittenSpan.ToArray();
         }
 
-        public static object Deserialize( DataPacketHeader Header, ReadOnlyMemory<byte> Data ) {
+        public static object? Deserialize( DataPacketHeader Header, ReadOnlyMemory<byte> Data ) {
             
             // Get the type from the tag
-            if (!NetworkPacketDictionary.PacketLookupTable.TryGetValue(Header.Type, out Type resolvedType)) {
+            if (!NetworkPacketDictionary.PacketLookupTable.TryGetValue(Header.Type, out Type? resolvedType)) {
                 throw new Exception($"Unknown packet type ID: {Header.Type}");
             }
 

MistoxServer/mPacket/NetworkPacketDictionary.cs

@@ -27,7 +27,7 @@ namespace Mistox.Attributes {
             foreach (Assembly assembly in assemblies) {
                 Type[] allClasses = assembly.GetTypes();
                 foreach( Type cur in allClasses) {
-                    mPacket attribute = cur.GetCustomAttribute<mPacket>(false);
+                    mPacket? attribute = cur.GetCustomAttribute<mPacket>(false);
                     if (attribute != null) {
 
                         // Generate a deterministic 16-bit ID based on the Type's FullName

MistoxServer/mPacket/ResevedPackets.cs

@@ -25,31 +25,31 @@ namespace Mistox.ResevedPackets {
 
         // Tag to make sure the object on the other side is the same object i want to update here
         // Need to map these Object ID's to a dictionary to make sure I only send network updates when there is a change
-        public ushort ObjectId { get; set; }
+        public ushort ObjectId { get; set; } = 0;
 
         // Packet payload data that im matching for in the dictionary
-        public byte[] InnerPayload { get; set; }
+        public byte[] InnerPayload { get; set; } = {};
     }
 
     public class UserTableObject {
-        public string UserName { get; set; }
+        public string UserName { get; set; } = string.Empty;
-        public IPAddress IpAddress { get; set; }
+        public IPAddress IpAddress { get; set; } = new([]);
-        public Vector3 Position { get; set; }
+        public Vector3 Position { get; set; } = new();
     }
 
     // Not implemented
     // Packet sent to all clients when a global position update occurrs
     [mPacket]
     public class HeartbeatPacket {
-        public Vector3 Position { get; set; }
+        public Vector3 Position { get; set; } = new();
-        public List<UserTableObject> ServerList { get; set; }
+        public List<UserTableObject> ServerList { get; set; } = new();
     }
 
     // Not implimented
     // Packet sent to all clients when a users TCP stream disconnects from the server
     [mPacket]
     public class UserDisconnectedPacket {
-        public string UserName { get; set; }
+        public string UserName { get; set; } = string.Empty;
     }
 
 }

Todo.txt

@@ -10,6 +10,7 @@ The server receive thread needs to push the user it was received from up the cha
 8. Each client can figure out what connections it needs to make or drop via the list                    Done
 10. When the TCP connection drops update the heartbeat list so all the clients remove the connection    Done
 11. Build a network cache table on the clients so obj's only send updates and not repeat packets
+12. User joined and left events are not implimented
 
 
 Set the network bubble distance [ render distance ] on the server and pass to the clients