init commit over here

MistoxServer/Server/Connection.cs

@@ -0,0 +1,10 @@
+using System.Net;
+
+namespace MistoxServer.Server {
+
+    public class Connection {
+        public mTCPServer slowClient { get; set; }
+        public IPEndPoint fastClient { get; set; }
+    }
+
+}

MistoxServer/Server/ServerListener.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+// Client Connections
+
+namespace MistoxServer.Server {
+    public class mTCPListener : IDisposable {
+
+        public event EventHandler onConnected;
+        public event EventHandler onDisconnected;
+        public event EventHandler onReceive;
+
+        TcpListener Listener;
+        ServerMode ServerMode;
+        bool Alive;
+        int port;
+
+        public mTCPListener( int Port, ServerMode mode ) {
+            port = Port;
+            Alive = true;
+            ServerMode = mode;
+            Thread ConnectionThread = new Thread(async () => await ListenerThread() );
+            ConnectionThread.Start();
+        }
+
+        async Task ListenerThread() {
+            Listener = new TcpListener( IPAddress.Any, port );
+            Listener.Start();
+            while( Alive ) {
+                TcpClient client = await Listener.AcceptTcpClientAsync();
+
+                Connection user = new Connection(){
+                    slowClient = new mTCPServer(client, ServerMode),
+                    fastClient = new IPEndPoint( ((IPEndPoint)client.Client.RemoteEndPoint).Address, port )
+                };
+
+                Console.WriteLine( "New User Connected" );
+
+                onConnected?.Invoke( user, new EventArgs() );
+                user.slowClient.onDisconnected += onDisconnected;
+                user.slowClient.onReceived += onReceive;
+
+                Thread receiveThread = new Thread(async () => await user.slowClient.ReceiveThread(user) );
+                receiveThread.Start();
+            }
+        }
+
+        public void Dispose() {
+            Alive = false;
+            Listener.Stop();
+            Listener = null;
+        }
+    }
+
+}

MistoxServer/Server/TCPServer.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Net.Sockets;
+using System.Threading.Tasks;
+
+namespace MistoxServer.Server {
+    public class mTCPServer : IDisposable {
+        public TcpClient slowClient;
+        ServerMode Mode;
+
+        public event EventHandler onReceived;
+        public event EventHandler onDisconnected;
+
+        public mTCPServer( TcpClient client, ServerMode mode ) {
+            slowClient = client;
+            slowClient.Client.NoDelay = true;
+            Mode = mode;
+        }
+
+        bool Alive = true;
+        public async Task ReceiveThread( Connection Client ) {
+            bool connected = true;
+            while( Alive && connected ) {
+                try {
+                    byte[] StreamData = new byte[1024];
+                    int bytesRead = await slowClient.GetStream().ReadAsync(StreamData, 0, StreamData.Length);
+                    if( bytesRead > 0 ) {
+                        if ( Mode == ServerMode.Passive) {
+                            onReceived?.Invoke( StreamData.Sub( 0, bytesRead ), new EventArgs() );
+                        } else if ( Mode == ServerMode.Authoritative) {
+                            dynamic data = mSerialize.tReceive( StreamData.Sub( 0, bytesRead ) );
+                            if( data != null ) {
+                                onReceived?.Invoke( data, new EventArgs() );
+                            }
+                        }
+                    }
+                } catch( Exception ) {
+                    Console.WriteLine( "User disconnected" );
+                    connected = false;
+                    onDisconnected?.Invoke( Client, new EventArgs() );
+                }
+            }
+        }
+
+        public async Task Send<T>( T packet ) {
+            if( Mode == ServerMode.Authoritative ) {
+                byte[] byteData = mSerialize.PacketSerialize( packet );
+                await slowClient.GetStream().WriteAsync( byteData, 0, byteData.Length );
+            } else if( Mode == ServerMode.Passive ) {
+                byte[] byteData = packet as byte[];
+                await slowClient.GetStream().WriteAsync( byteData, 0, byteData.Length );
+            }
+        }
+
+        public void Dispose() {
+            Alive = false;
+        }
+    }
+}