Try gitea release

.gitea/workflows/build.yaml

@@ -0,0 +1,51 @@
+name: Build and publish mistserver
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    runs-on: alpine-linux
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: Setup .NET SDK
+        run: apk add dotnet10-sdk
+
+      - 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/MistServer.csproj

@@ -19,7 +19,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\MistoxServer\MistServerModule.csproj" />
+    <ProjectReference Include="..\MistoxServer\MistServer.csproj" />
   </ItemGroup>
 
 </Project>

MistoxServer/Client/MistoxClient.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Net;
 using System.Net.Sockets;
+using System.Numerics;
+using System.Threading;
 using System.Threading.Tasks;
 using Mistox.ResevedPackets;
 
@@ -13,15 +16,21 @@ namespace Mistox.Client {
         public string UserName { get; private set; } = "";                          // My UserName
         public bool Alive { get; set; } = true;                                     // Is the server running
         public bool isAuthenticated { get; private set; } = false;                  // Is the server authenticated
-        public ConcurrentDictionary<IPEndPoint, mUDPClient> clientConnections { get; private set; }      // UserName, Connection
+        public ConcurrentDictionary<IPEndPoint, mUDPClient> clientConnections { get; private set; } = new();    // UserName, Connection
+        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 UdpClient ClientSocket { get; private set; }                         // Global UDP Sender
         public UDPReceiver UdpReceiver { get; private set; }                        // Global UDP Receiver
+
         private readonly string ConnectionKey = "";                                 // Server Connection Key
-    
+        private readonly int Port = 0;                                              // The port of the connected socket
+        private readonly int HeartbeatInterval = 5000;                              // How often should we heartbeat
+
         public MistoxClient(string userName, string connectionKey, IPEndPoint Server) {
             // Create and listen on UDP
+            Port = Server.Port;
             ClientSocket = new UdpClient( Server.Port );
             UdpReceiver = new UDPReceiver( this );
             UserName = userName;
@@ -33,15 +42,79 @@ namespace Mistox.Client {
                 ServerConnection = new mTCPClient( this, Server );
                 Console.WriteLine( "Connected to the server sucessfully" );
                 Alive = true;
-            } catch( Exception e ) {
+            } catch ( Exception e ) {
                 Console.WriteLine( "An error has occured with the connection to the server. Error { " );
                 Console.WriteLine( e.ToString() );
                 Console.WriteLine( "}" );
                 Alive = false;
             }
+
+            // Start the heartbeat
+            _ = RunAsync(Heartbeat);
         }
 
-        public async Task TryAuth() {
+        async Task RunAsync(Func<Task> work) {
+            try{
+                await work();
+            } catch (Exception ex) {
+                Console.WriteLine($"Error during background packet processing: {ex.Message}");
+            }
+        }
+
+/////////////////////////////
+// Heartbeat
+/////////////////////////////
+
+        async Task Heartbeat() {
+            while (Alive) {
+                await SendServer(new HeartbeatPacket {
+                    Position = Position
+                });
+                Thread.Sleep(HeartbeatInterval);
+            }
+        }
+
+        void HeartbeatReceived(HeartbeatPacket packet) {
+            // Build a HashSet of server IP addresses for O(1) removal checks
+            var activeIps = new HashSet<IPAddress>(packet.ServerList.Count);
+            for (int i = 0; i < packet.ServerList.Count; i++) {
+                activeIps.Add(packet.ServerList[i].IpAddress);
+            }
+
+            // Add users that joined
+            foreach (UserTableObject cur in packet.ServerList) {
+                IPEndPoint remoteHost = new IPEndPoint(cur.IpAddress, Port);
+                if (!clientConnections.ContainsKey(remoteHost)) {
+                    mUDPClient newConnection = new mUDPClient(this, remoteHost);
+                    clientConnections[remoteHost] = newConnection;
+                }
+            }
+
+            // Remove users that left
+            foreach (IPEndPoint key in clientConnections.Keys) {
+                if (!activeIps.Contains(key.Address)) {
+                    clientConnections.TryRemove(key, out _);
+                }
+            }
+            
+            // Update distance status
+            float maxDistanceSq = MaxNetworkRenderDistance * MaxNetworkRenderDistance;
+            foreach (mUDPClient cur in clientConnections.Values) {
+                float dx = Position.X - cur.Position.X;
+                float dy = Position.Y - cur.Position.Y;
+                float dz = Position.Z - cur.Position.Z;
+                
+                // Fixed bug (dz * dz instead of dz + dz) & avoided Sqrt
+                float distanceSq = (dx * dx) + (dy * dy) + (dz * dz);
+                cur.WithinRange = distanceSq < maxDistanceSq;
+            }
+        }
+
+/////////////////////////////
+// Auth
+/////////////////////////////
+
+        async Task TryAuth() {
             Console.WriteLine("Attempting to authenticate against the server...");
             await ServerConnection.Send(new UserAuthPacket {
                 UserName = UserName,
@@ -49,71 +122,18 @@ namespace Mistox.Client {
             });
         }
 
-        public async Task CheckAuthStatus(UserAuthPacket packet) {
+        async Task CheckAuthStatus(UserAuthPacket packet) {
             if (packet.AuthSuccessful == 1) {
                 isAuthenticated = true;
             }
             ServerName = packet.ServerName;
         }
 
-/////////////////////////////
-// Receive Methods
-/////////////////////////////
-
-        public void UserConnected(UserConnectedPacket packet) {
-            IPEndPoint remoteUser = new IPEndPoint(packet.ClientIPAddress, packet.ClientPort);
-            mUDPClient user = new mUDPClient(this, remoteUser) {
-                UserName = packet.UserName
-            };
-            clientConnections[remoteUser] = user;
-            InvokeOnUserConnected(user);
-        }
-
-        public void UserDisconnected(UserDisconnectedPacket packet) {
-            mUDPClient client = null;
-            foreach(mUDPClient cur in clientConnections.Values) {
-                if (cur.UserName.ToLower() == packet.UserName.ToLower()) {
-                    client = cur;
-                    break;
-                }
-            }
-            if (client != null) {
-                InvokeOnUserDisconnected( client );
-                client.Alive = false;
-                client.Dispose();
-                clientConnections[client._remoteHost] = null;
-            }
-        }
-
 /////////////////////////////
 // Events
 /////////////////////////////
 
-        public event Action<dynamic> onDataReceived;
-        public void InvokeOnReceived(dynamic DataPacket, mUDPClient remote = null){
-            switch (DataPacket as object)  {
-                case UserConnectedPacket packet:
-                    UserConnected(packet); 
-                    break;
-                case UserDisconnectedPacket packet:
-                    UserDisconnected(packet); 
-                    break;
-                case UserAuthPacket packet:
-                    Task.Run(async () => {
-                        try {
-                            await CheckAuthStatus(packet);
-                        } catch {}
-                    });
-                    break;
-                case null:
-                    Console.WriteLine("Received a null packet.");
-                    break;
-                default:
-                    onDataReceived?.Invoke(DataPacket);
-                    break;
-            }
-        }
-
+        // When (self) connects to the server
         public event Action onServerConnected;
         public void InvokeOnServerConnected(){
             Alive = true;
@@ -125,26 +145,67 @@ namespace Mistox.Client {
             onServerConnected?.Invoke();
         }
 
+        // When any user connects to the server (self) hasn't seen yet
+        public event Action<string> onUserJoined;
+        public void InvokeOnUserJoined(string UserName){
+            onUserJoined?.Invoke(UserName);
+        }
+
+        // When user is within range of (self) and network rendering starts
         public event Action<mUDPClient> onUserConnected;
         public void InvokeOnUserConnected(mUDPClient ConnectedUser){
             onUserConnected?.Invoke(ConnectedUser);
         }
 
+        // When generic data is received
+        public event Action<dynamic> onDataReceived;
+        public void InvokeOnReceived(dynamic DataPacket, mUDPClient remote = null){
+            switch (DataPacket as object)  {
+                case HeartbeatPacket packet:
+                    HeartbeatReceived(packet); 
+                    break;
+                case UserAuthPacket packet:
+                    _ = RunAsync(async () => {
+                        await CheckAuthStatus(packet);
+                    });
+                    break;
+                case null:
+                    Console.WriteLine("Received a null packet.");
+                    break;
+                default:
+                    onDataReceived?.Invoke(DataPacket);
+                    break;
+            }
+        }
+
+        // When user is no longer in range of (self) and network rendering stops
         public event Action<mUDPClient> onUserDisconnected;
         public void InvokeOnUserDisconnected(mUDPClient DisconnectedUser){
             onUserDisconnected?.Invoke(DisconnectedUser);
         }
 
+        // When any user disconnects from the server that isn't (self)
+        public event Action<string> onUserLeft;
+        public void InvokeOnUserLeft(string UserName){
+            onUserLeft?.Invoke(UserName);
+        }
+
+        // When (self) disconnects to the server
         public event Action onServerDisconnected;
         public void InvokeOnServerDisconnected(){
             Alive = false;
             onServerDisconnected?.Invoke();
         }
 
+/////////////////////////////
+// Send Methods
+/////////////////////////////
 
-        public async Task SendAllClients<Packet>(Packet data) {
+        public async Task SendAllClientsInRange<Packet>(Packet data) {
             foreach( mUDPClient cur in clientConnections.Values ){
-                await cur.Send( data );
+                if (cur.WithinRange) {
+                    await cur.Send( data );
+                }
             }
         }
 

MistoxServer/Client/UDPClient.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Net;
+using System.Numerics;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -7,9 +8,10 @@ namespace Mistox.Client {
     public class mUDPClient : IDisposable {
 
         public string UserName { get; set; } = "";                          // The remote players UserName
-        public bool Alive { get; set; } = true;                             // Is the connection alive
-        public IPEndPoint _remoteHost { get; set; }                         // The remote IP Address
+        public bool WithinRange { get; set; } = true;                       // Is the user close enough?
+        public Vector3 Position { get; set; } = new Vector3(0, 0, 0);       // The remote location of the player
 
+        private IPEndPoint _remoteHost { get; set; }                        // The remote IP Address
         private readonly SemaphoreSlim _sendLock = new SemaphoreSlim(1, 1);
         private readonly MistoxClient _parent;
 

MistoxServer/Server/MistoxServer.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Net;
 using System.Threading.Tasks;
 using Mistox.ResevedPackets;
@@ -8,25 +9,49 @@ namespace Mistox.Server {
 
     public class MistoxServer {
 
-        // Class Definitions
+        public string ServerName { get; private set; } = "";                            // The name of the server
+        public int MaxClients { get; set; } = 10;                                       // The max players per server
+        public float ConnectionRange { get; set; } = 40;                                // InGame distance for valid conections
+        public string ConnectionKey { get; set; } = "";                                 // The connection key for the server
+        public int ConnectionTimeoutSeconds { get; set; } = 10;                         // If no reply in time kill the connection
+        public bool Alive { get; set; } = true;                                         // Is the server running
+        public ConcurrentDictionary<string, ServerConnection> Connections = new();      // All the active connections. key is username
 
-        public string ServerName { get; private set; } = "";                    // The name of the server
-        public int MaxClients { get; set; } = 10;                               // The max players per server
-        public float ConnectionRange { get; set; } = 40;                        // InGame distance for valid conections
-        public string ConnectionKey { get; set; } = "";                         // The connection key for the server
-        public int ConnectionTimeoutSeconds { get; set; } = 10;                 // If no reply in time kill the connection
-        public bool Alive { get; set; } = true;                                 // Is the server running
-        public ConcurrentDictionary<string, ServerConnection> Connections;      // All the active connections. key is username
-
-        private readonly ServerListener Listener;                               // The Connection Listener singleton
+        private readonly ServerListener Listener;                                       // The Connection Listener singleton
 
         public MistoxServer(IPEndPoint ListenerAddress, string serverName) {
-            Connections = new ConcurrentDictionary<string, ServerConnection>();
             ServerName = serverName;
             Listener = new ServerListener(ListenerAddress, this);
             Console.WriteLine( "The Server is initilized and waiting for clients to connect at port : " + ListenerAddress.Port );
         }
 
+        async Task RunAsync(Func<Task> work) {
+            try{
+                await work();
+            } catch (Exception ex) {
+                Console.WriteLine($"Error during background packet processing: {ex.Message}");
+            }
+        }
+
+/////////////////////////////
+// Heartbeat
+/////////////////////////////
+
+        async Task BuildServerList(ServerConnection user, HeartbeatPacket packet) {
+            packet.ServerList = new List<UserTableObject>();
+            foreach( ServerConnection cur in Connections.Values) {
+                packet.ServerList.Add( new UserTableObject() {
+                    UserName = cur.UserName,
+                    Position = cur.Position,
+                    IpAddress = cur.getRemote()
+                } );
+            }
+            await user.Send( packet );
+        }
+
+/////////////////////////////
+// Auth
+/////////////////////////////
 
         async Task ProcessAuthRequest(ServerConnection user, UserAuthPacket packet) {
             packet.ServerName = ServerName;
@@ -36,30 +61,36 @@ namespace Mistox.Server {
                 user.UserName = packet.UserName;
                 Connections[packet.UserName] = user;
                 user.IsAuthenticated = true;
+                InvokeUserConnected(user);
             } else {
                 packet.AuthSuccessful = -1;
             }
-            await SendClient(packet.UserName, packet);
+            await user.Send(packet);
         }
 
-// Functions
+/////////////////////////////
+// Events
+/////////////////////////////
 
         public event Action<ServerConnection> onUserConnected;
         public void InvokeUserConnected( ServerConnection user ){
+            Connections[user.UserName] = user;
             onUserConnected?.Invoke( user );
         }
 
-        public event Action<ServerConnection, dynamic> onDataReceived;
+        public event Action<ServerConnection, object> onDataReceived;
         public void InvokeDataReceived( ServerConnection user, dynamic data ){
-            switch (data as object)  {
-                case UserAuthPacket packet:
-                    if (!user.IsAuthenticated) {
-                        Task.Run(async () => {
-                            try {
-                                await ProcessAuthRequest(user, packet); 
-                            } catch {}
-                        });
-                    }
+            switch (data)  {
+                case UserAuthPacket packet when !user.IsAuthenticated:
+                    _ = RunAsync(async () => {
+                        await ProcessAuthRequest(user, packet); 
+                    });
+                    break;
+                case HeartbeatPacket packet when user.IsAuthenticated:
+                    user.Position = packet.Position;
+                    _ = RunAsync(async () => {
+                        await BuildServerList(user, packet);
+                    });
                     break;
                 case null:
                     Console.WriteLine("Received a null packet.");
@@ -72,9 +103,14 @@ namespace Mistox.Server {
 
         public event Action<ServerConnection> onUserDisconnected;
         public void InvokeUserDisconnected( ServerConnection user ){
+            Connections.Remove(user.UserName, out _);
             onUserDisconnected?.Invoke( user );
         }
 
+/////////////////////////////
+// Send Methods
+/////////////////////////////
+
         public async Task SendAllClients<Packet>(Packet data) {
             foreach( ServerConnection cur in Connections.Values ) {
                 await cur.Send(data);

MistoxServer/Server/ServerConnection.cs

@@ -10,7 +10,7 @@ namespace Mistox.Server {
         
         public string UserName { get; set; } = "";                          // The Players UserName
         public bool IsAuthenticated { get; set; } = false;                  // Has the player authenticated
-        public Vector3 Position { get; set; }                               // The ingame position of the player
+        public Vector3 Position { get; set; } = new Vector3(0, 0, 0);       // The ingame position of the player
         public bool Connected { get; set; } = true;                         // Is the connection valid
         
         private readonly MistoxServer _parent;
@@ -26,7 +26,6 @@ namespace Mistox.Server {
             _client.NoDelay = true;
             _client.ReceiveTimeout = _parent.ConnectionTimeoutSeconds * 1000;
 
-            _parent.InvokeUserConnected( this );
             // Start the receive thread
             Task.Run(ReceiveThread);
         }
@@ -82,18 +81,18 @@ namespace Mistox.Server {
             }
         }
 
+        public IPAddress getRemote() {
+            return _remoteAddress.Address;
+        }
+
         public void Dispose() {
-            if (!Connected) return;
-            
             Connected = false;
             _cts.Cancel();
             _client.Close();
             _sendLock.Dispose();
             _cts.Dispose();
 
-            _parent.Connections.TryRemove(UserName, out _);
             _parent.InvokeUserDisconnected(this);
-            _parent.Alive = false;
             // Remove this item from the Dictionary on the Server for garbage collection
         }
     }

MistoxServer/Server/ServerListener.cs

@@ -28,6 +28,7 @@ namespace Mistox.Server {
                 TcpClient client = await _Listener.AcceptTcpClientAsync();
 
                 if (_parent.Connections.Count + 1 > _parent.MaxClients) {
+                    //client.Client.SendAsync(); // Send the client a packet saying the servername and reject reason 'server full'
                     continue;
                 }
 

MistoxServer/mPacket/ResevedPackets.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Net;
 using System.Numerics;
 using Mistox.Attributes;
@@ -30,20 +31,18 @@ namespace Mistox.ResevedPackets {
         public byte[] InnerPayload { get; set; }
     }
 
-    // Not implemented
-    // Packet sent to all clients when a users TCP stream connects to the server
-    [mPacket]
-    public class UserConnectedPacket {
+    public class UserTableObject {
         public string UserName { get; set; }
-        public IPAddress ClientIPAddress { get; set; }
+        public IPAddress IpAddress { get; set; }
+        public Vector3 Position { get; set; }
     }
 
     // Not implemented
     // Packet sent to all clients when a global position update occurrs
     [mPacket]
-    public class UserPositionUpdatePacket {
-        public string UserName { get; set; }
+    public class HeartbeatPacket {
         public Vector3 Position { get; set; }
+        public List<UserTableObject> ServerList { get; set; }
     }
 
     // Not implimented

Todo.txt

@@ -1,46 +1,21 @@
 The server receive thread needs to push the user it was received from up the chain
 
-1. Allow the server to setup a server name                                                  Done
-2. Allow the client to setup a user name                                                    Done
-3. When a user connects add them to the Connections dictionary with a GUID.                 Done
-3. Have the client send the server a welcome packet                                         Done
-4. Have the server use the welcome packet to fillout the user information on the server     Done
-5. Respond to the client from the server with a server list of UDPEndpoints
-6. Instead of looping through a list of avalible users have a local user dictionary that can be used to lookup clients IPEndPoints
+1. Allow the server to setup a server name                                                              Done
+2. Allow the client to setup a user name                                                                Done
+3. When a user connects add them to the Connections dictionary with a GUID.                             Done
+4. Have the client send the server a welcome packet                                                     Done
+5. Have the server use the welcome packet to fillout the user information on the server                 Done
+6. Send the server the heartbeat location update every 5 seconds                                        Done
+7. Respond to the client with a server list of UDPEndpoints and heartbeat locations                     Done
+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
+
+
+Set the network bubble distance [ render distance ] on the server and pass to the clients
+Send a packet back to the client for if the lobby is full, notify them of why the connection failed
 
 Test that the datapacket is formatted correctly. The packet size might be off from the actual packet size
 
-Have each client update the ingame location to the server every 5 seconds [ Heartbeat ]
-For each user in the server calculate which other players are close enough for a connection
-So the server needs to hold a table of what clients a client is already connected to
-if a new player is now close enough update the client and the servers client table with that information
-have the clients udp together
-if a player goes out of the range update the clients that they no longer need the connection
-drop the player from the table and notify the end user they can close the connection
-
-When user a joins a server
-    The IP gets added to the servers master list
-    The user needs to authenticate for username
-
-when the server connection closes
-    Notify all clients to drop the connections
-    Remove the user from the server table
-
-Use the Server TCP connection to notify all clients when a user disconnects
-
-Only send updates across the network. Dont send same state events
-Need to setup a network buffer for Tagged Objects. ID
-
-
-Connection Flow:
-    1. Connection to server is made                                                                         working
-        Server object is created                                                                            working
-        ServerConnection gets added to the Connections table                                                working
-            Server fires user connected event                                                               working
-
-    2. User sends an Auth Packet to server                                                                  working
-        Server responds with Auth sucess or fail and marks the users auth status in the server table.       needs work
-        After sucessfull auth share the users IPEndPoint with close connections                             not started
-
-    3. If the TCP connection closes                                                                         not started
+    1. If the TCP connection closes                                                                         not started
         Disconnect the user and tell all clients that the user is gone                                      not started