Added more core features & object / player spawning

Author: TwoTenPvP

MLAPI/Data/NetworkedClient.cs

@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace MLAPI
+{
+    public class NetworkedClient
+    {
+        public int ClientId;
+        public GameObject PlayerObject;
+    }
+}

MLAPI/Data/NetworkingConfiguration.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security.Cryptography;
+using UnityEngine.Networking;
+
+namespace MLAPI
+{
+    public class NetworkingConfiguration
+    {
+        public ushort ProtocolVersion = 0;
+        public Dictionary<string, QosType> Channels = new Dictionary<string, QosType>();
+        public List<string> MessageTypes = new List<string>();
+        public int MessageBufferSize = 65536;
+        public int MaxMessagesPerFrame = 150;
+        public int MaxConnections = 100;
+        public int Port = 7777;
+        public string Address;
+        public int ClientConnectionBufferTimeout = 10;
+        public bool ConnectionApproval = false;
+        public Action<byte[], int, Action<int, bool>> ConnectionApprovalCallback;
+        public byte[] ConnectionData;
+        public bool HandleObjectSpawning = true;
+        //TODO
+        public bool CompressMessages = false;
+        //Should only be used for dedicated servers and will require the servers RSA keypair being hard coded into clients in order to exchange a AES key
+        //TODO
+        public bool EncryptMessages = false;
+
+
+        //Cached config hash
+        private byte[] ConfigHash = null;
+        public byte[] GetConfig(bool cache = true)
+        {
+            if (ConfigHash != null && cache)
+                return ConfigHash;
+
+            using(MemoryStream writeStream = new MemoryStream())
+            {
+                using(BinaryWriter writer = new BinaryWriter(writeStream))
+                {
+                    writer.Write(ProtocolVersion);
+                    foreach (KeyValuePair<string, QosType> pair in Channels)
+                    {
+                        writer.Write(pair.Key);
+                        writer.Write((int)pair.Value);
+                    }
+                    for (int i = 0; i < MessageTypes.Count; i++)
+                    {
+                        writer.Write(MessageTypes[i]);
+                    }
+                    writer.Write(HandleObjectSpawning);
+                    writer.Write(CompressMessages);
+                    writer.Write(EncryptMessages);
+                }
+                using(SHA256Managed sha256 = new SHA256Managed())
+                {
+                    //Returns a 256 bit / 32 byte long checksum of the config
+                    if (cache)
+                    {
+                        ConfigHash = sha256.ComputeHash(writeStream);
+                        return ConfigHash;
+                    }
+                    return sha256.ComputeHash(writeStream);
+                }
+            }
+        }
+
+        public bool CompareConfig(byte[] hash)
+        {
+            return hash == GetConfig();
+        }
+    }
+}

MLAPI/MLAPI.csproj

@@ -35,20 +35,18 @@
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
-    <Reference Include="System.Net.Http" />
     <Reference Include="System.Xml" />
     <Reference Include="UnityEngine">
       <HintPath>..\..\..\..\..\..\Program Files\Unity\Editor\Data\Managed\UnityEngine.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="NetworkedBehaviour.cs" />
-    <Compile Include="NetworkedClient.cs" />
-    <Compile Include="NetworkedObject.cs" />
-    <Compile Include="NetworkingConfiguration.cs" />
-    <Compile Include="NetworkingManager.cs" />
+    <Compile Include="MonoBehaviours\Core\NetworkedBehaviour.cs" />
+    <Compile Include="Data\NetworkedClient.cs" />
+    <Compile Include="MonoBehaviours\Core\NetworkedObject.cs" />
+    <Compile Include="Data\NetworkingConfiguration.cs" />
+    <Compile Include="MonoBehaviours\Core\NetworkingManager.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+
+namespace MLAPI
+{
+    public abstract class NetworkedBehaviour : MonoBehaviour
+    {
+        protected bool isLocalPlayer
+        {
+            get
+            {
+                return networkedObject.isLocalPlayer;
+            }
+        }
+        protected bool isServer = NetworkingManager.singleton.isServer;
+        protected NetworkedObject networkedObject
+        {
+            get
+            {
+                if(_networkedObject == null)
+                {
+                    _networkedObject = GetComponentInParent<NetworkedObject>();
+                }
+                return _networkedObject;
+            }
+        }
+        private NetworkedObject _networkedObject = null;
+        protected uint netId
+        {
+            get
+            {
+                return networkedObject.NetworkId;
+            }
+        }
+
+        //Change data type
+        private Dictionary<string, int> registeredMessageHandlers = new Dictionary<string, int>();
+
+        public int RegisterMessageHandler(string name, Action<int, byte[]> action)
+        {
+            int counter = NetworkingManager.singleton.AddIncomingMessageHandler(name, action);
+            registeredMessageHandlers.Add(name, counter);
+            return counter;
+        }
+
+        public void DeregisterMessageHandler(string name, int counter)
+        {
+            NetworkingManager.singleton.RemoveIncomingMessageHandler(name, counter);
+        }
+
+        private void OnDestroy()
+        {
+            foreach (KeyValuePair<string, int> pair in registeredMessageHandlers)
+            {
+                DeregisterMessageHandler(pair.Key, pair.Value);
+            }
+        }
+
+        public void Send(int connectionId, string messageType, string channelName, byte[] data)
+        {
+            Send(connectionId, messageType, channelName, data);
+        }
+
+        public void Send(int[] connectonIds, string messageType, string channelName, byte[] data)
+        {
+            for (int i = 0; i < connectonIds.Length; i++)
+            {
+                Send(connectonIds[i], messageType, channelName, data);
+            }
+        }
+
+        public void Send(List<int> connectonIds, string messageType, string channelName, byte[] data)
+        {
+            for (int i = 0; i < connectonIds.Count; i++)
+            {
+                Send(connectonIds[i], messageType, channelName, data);
+            }
+        }
+    }
+}

MLAPI/MonoBehaviours/Core/NetworkedObject.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+namespace MLAPI
+{
+    //TODO
+    //Will be used for objects which will be spawned automatically across clients
+    public class NetworkedObject : MonoBehaviour
+    {
+        public uint NetworkId;
+        public int OwnerClientId = -1;
+        public int SpawnablePrefabId;
+        internal bool IsPlayerObject = false;
+        public bool isLocalPlayer
+        {
+            get
+            {
+                return OwnerClientId == NetworkingManager.singleton.MyClientId;
+            }
+        }
+
+        private void OnDestroy()
+        {
+            NetworkingManager.OnDestroyObject(NetworkId);
+        }
+    }
+}