diff --git a/LICENCE b/LICENCE
new file mode 100644
index 0000000..325c6ad
--- /dev/null
+++ b/LICENCE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Albin Corén
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/MLAPI/Class1.cs b/MLAPI/Class1.cs
deleted file mode 100644
index a484755..0000000
--- a/MLAPI/Class1.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MLAPI
-{
- public class Class1
- {
- }
-}
diff --git a/MLAPI/MLAPI.csproj b/MLAPI/MLAPI.csproj
index b9a427a..0e4499c 100644
--- a/MLAPI/MLAPI.csproj
+++ b/MLAPI/MLAPI.csproj
@@ -1,22 +1,23 @@
-
+
Debug
AnyCPU
- ee431720-a9ed-43dc-9e74-10b693816d38
+ {EE431720-A9ED-43DC-9E74-10B693816D38}
Library
Properties
MLAPI
MLAPI
- v4.6.1
+ v3.5
512
+
true
full
false
- bin\Debug\
+ ..\..\..\..\Documents\MLAPI\Assets\
DEBUG;TRACE
prompt
4
@@ -30,24 +31,25 @@
4
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+ ..\..\..\..\..\..\Program Files\Unity\Editor\Data\Managed\UnityEngine.dll
+
-
+
+
+
+
+
-
+
\ No newline at end of file
diff --git a/MLAPI/NetworkedBehaviour.cs b/MLAPI/NetworkedBehaviour.cs
new file mode 100644
index 0000000..9afa3f3
--- /dev/null
+++ b/MLAPI/NetworkedBehaviour.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace MLAPI
+{
+ public abstract class NetworkedBehaviour : MonoBehaviour
+ {
+ protected bool isLocalPlayer;
+ protected bool isServer = NetworkingManager.singleton.isServer;
+
+ //Change data type
+ private Dictionary registeredMessageHandlers = new Dictionary();
+
+ public int RegisterMessageHandler(string name, Action 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 pair in registeredMessageHandlers)
+ {
+ DeregisterMessageHandler(pair.Key, pair.Value);
+ }
+ }
+ }
+}
diff --git a/MLAPI/NetworkedClient.cs b/MLAPI/NetworkedClient.cs
new file mode 100644
index 0000000..900604c
--- /dev/null
+++ b/MLAPI/NetworkedClient.cs
@@ -0,0 +1,7 @@
+namespace MLAPI
+{
+ public class NetworkedClient
+ {
+ public int ClientId;
+ }
+}
diff --git a/MLAPI/NetworkedObject.cs b/MLAPI/NetworkedObject.cs
new file mode 100644
index 0000000..3ea6d1e
--- /dev/null
+++ b/MLAPI/NetworkedObject.cs
@@ -0,0 +1,11 @@
+using UnityEngine;
+
+namespace MLAPI
+{
+ //TODO
+ //Will be used for objects which will be spawned automatically across clients
+ public class NetworkedObject : MonoBehaviour
+ {
+
+ }
+}
diff --git a/MLAPI/NetworkingConfiguration.cs b/MLAPI/NetworkingConfiguration.cs
new file mode 100644
index 0000000..02da1f5
--- /dev/null
+++ b/MLAPI/NetworkingConfiguration.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Networking;
+
+namespace MLAPI
+{
+ public class NetworkingConfiguration
+ {
+ public ushort ProtocolVersion = 0;
+ public Dictionary Channels = new Dictionary();
+ public List MessageTypes = new List();
+ public int MessageBufferSize = 65536;
+ public int MaxMessagesPerFrame = 150;
+ public int MaxConnections = 100;
+ public int Port = 7777;
+ public int ClientConnectionBufferTimeout = 10;
+ public bool ConnectionApproval = false;
+ public Action> ConnectionApprovalCallback;
+ public byte[] ConnectionData;
+ }
+}
diff --git a/MLAPI/NetworkingManager.cs b/MLAPI/NetworkingManager.cs
new file mode 100644
index 0000000..0af3fa3
--- /dev/null
+++ b/MLAPI/NetworkingManager.cs
@@ -0,0 +1,320 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace MLAPI
+{
+ public class NetworkingManager : MonoBehaviour
+ {
+ public static NetworkingManager singleton;
+ //Client only, what my connectionId is on the server
+ public int MyClientId;
+ //Server only
+ private Dictionary connectedClients;
+ private HashSet pendingClients;
+ internal bool isServer;
+ private bool isListening;
+ private byte[] messageBuffer;
+ private Dictionary channels;
+ private Dictionary messageTypes;
+ private Dictionary>> messageCallbacks;
+ private Dictionary messageHandlerCounter;
+ private Dictionary> releasedMessageHandlerCounters;
+
+ public NetworkingConfiguration NetworkConfig;
+
+ internal int AddIncomingMessageHandler(string name, Action action)
+ {
+ if(messageTypes.ContainsKey(name))
+ {
+ if(messageCallbacks.ContainsKey(messageTypes[name]))
+ {
+ int handlerId = 0;
+ if (messageHandlerCounter.ContainsKey(messageTypes[name]))
+ {
+ if (!releasedMessageHandlerCounters.ContainsKey(messageTypes[name]))
+ releasedMessageHandlerCounters.Add(messageTypes[name], new Stack());
+
+ if(releasedMessageHandlerCounters[messageTypes[name]].Count == 0)
+ {
+ handlerId = messageHandlerCounter[messageTypes[name]];
+ messageHandlerCounter[messageTypes[name]]++;
+ }
+ else
+ {
+ handlerId = releasedMessageHandlerCounters[messageTypes[name]].Pop();
+ }
+ }
+ else
+ {
+ messageHandlerCounter.Add(messageTypes[name], handlerId + 1);
+ }
+ messageCallbacks[messageTypes[name]].Add(handlerId, action);
+ return handlerId;
+ }
+ else
+ {
+ messageCallbacks.Add(messageTypes[name], new Dictionary>());
+ messageHandlerCounter.Add(messageTypes[name], 1);
+ messageCallbacks[messageTypes[name]].Add(0, action);
+ return 0;
+ }
+ }
+ else
+ {
+ Debug.LogWarning("MLAPI: The message type " + name + " has not been registered. Please define it in the netConfig");
+ return -1;
+ }
+ }
+
+ internal void RemoveIncomingMessageHandler(string name, int counter)
+ {
+ if (counter == -1)
+ return;
+
+ if (messageTypes.ContainsKey(name) && messageCallbacks.ContainsKey(messageTypes[name]) && messageCallbacks[messageTypes[name]].ContainsKey(counter))
+ {
+ messageCallbacks[messageTypes[name]].Remove(counter);
+ releasedMessageHandlerCounters[messageTypes[name]].Push(counter);
+ }
+ }
+
+ private ConnectionConfig Init(NetworkingConfiguration netConfig)
+ {
+ NetworkConfig = netConfig;
+
+ pendingClients = new HashSet();
+ connectedClients = new Dictionary();
+ messageBuffer = new byte[NetworkConfig.MessageBufferSize];
+ channels = new Dictionary();
+ messageTypes = new Dictionary();
+ messageCallbacks = new Dictionary>>();
+ messageHandlerCounter = new Dictionary();
+ releasedMessageHandlerCounters = new Dictionary>();
+
+ if (NetworkConfig.ConnectionApproval)
+ {
+ if(NetworkConfig.ConnectionApprovalCallback == null)
+ {
+ Debug.LogWarning("MLAPI: No ConnectionAproval callback defined. Connection aproval will timeout");
+ }
+ }
+
+ NetworkTransport.Init();
+ ConnectionConfig cConfig = new ConnectionConfig();
+
+ //MLAPI channels and messageTypes
+ NetworkConfig.Channels.Add("MLAPI_RELIABLE_FRAGMENTED", QosType.ReliableFragmented);
+ messageTypes.Add("CONNECTION_REQUEST", 0);
+
+
+ foreach (KeyValuePair pair in NetworkConfig.Channels)
+ {
+ channels.Add(pair.Key, cConfig.AddChannel(pair.Value));
+ }
+ //0-32 are reserved for MLAPI messages
+ for (ushort i = 32; i < NetworkConfig.MessageTypes.Count; i++)
+ {
+ messageTypes.Add(NetworkConfig.MessageTypes[i], i);
+ }
+ return cConfig;
+ }
+
+
+ public void StartServer(NetworkingConfiguration netConfig)
+ {
+ ConnectionConfig cConfig = Init(netConfig);
+ HostTopology hostTopology = new HostTopology(cConfig, NetworkConfig.MaxConnections);
+ NetworkTransport.AddHost(hostTopology, NetworkConfig.Port);
+ isServer = true;
+ isListening = true;
+ }
+
+ private void OnEnable()
+ {
+ if (singleton != null)
+ {
+ Debug.LogWarning("MLAPI: Multiple NetworkingManagers");
+ return;
+ }
+ singleton = this;
+ }
+
+ private void OnDisable()
+ {
+ singleton = null;
+ }
+
+ //Receive stuff
+ int hostId;
+ int connectionId;
+ int channelId;
+ int receivedSize;
+ byte error;
+ private void Update()
+ {
+ if(isListening)
+ {
+ NetworkEventType eventType;
+ int messagesProcessed = 0;
+ do
+ {
+ messagesProcessed++;
+ eventType = NetworkTransport.Receive(out hostId, out connectionId, out channelId, messageBuffer, NetworkConfig.MessageBufferSize, out receivedSize, out error);
+ NetworkError networkError = (NetworkError)error;
+ if (networkError != NetworkError.Ok)
+ {
+ Debug.LogWarning("MLAPI: NetworkTransport receive error: " + networkError.ToString());
+ return;
+ }
+ switch (eventType)
+ {
+ case NetworkEventType.ConnectEvent:
+ if(isServer)
+ {
+ if (NetworkConfig.ConnectionApproval)
+ {
+ pendingClients.Add(connectionId);
+ StartCoroutine(ApprovalTimeout(connectionId));
+ }
+ else
+ {
+ //Connect
+ HandleApproval(connectionId, false);
+ }
+ }
+ else
+ {
+ if (NetworkConfig.ConnectionApproval)
+ Send(connectionId, "CONNECTION_REQUEST", "MLAPI_RELIABLE_FRAGMENTED", NetworkConfig.ConnectionData);
+ }
+ break;
+ case NetworkEventType.DataEvent:
+ HandleIncomingData(connectionId, ref messageBuffer);
+ break;
+ }
+ } while (eventType != NetworkEventType.Nothing &&
+ (messagesProcessed < NetworkConfig.MaxMessagesPerFrame || NetworkConfig.MaxMessagesPerFrame < 0));
+
+ }
+ }
+
+ IEnumerator ApprovalTimeout(int connectionId)
+ {
+ float timeStarted = Time.time;
+ //We yield every frame incase a pending client disconnects and someone else gets its connection id
+ while (Time.time - timeStarted < NetworkConfig.ClientConnectionBufferTimeout && pendingClients.Contains(connectionId))
+ {
+ yield return null;
+ }
+ if(pendingClients.Contains(connectionId))
+ {
+ //Timeout
+ DisconnectClient(connectionId);
+ }
+ else
+ {
+ //If the key nolonger exist in pending and not in connected, they disconnected
+ if(!connectedClients.ContainsKey(connectionId))
+ {
+ pendingClients.Remove(connectionId);
+ }
+ }
+ }
+
+ private void HandleIncomingData(int connectonId, ref byte[] data)
+ {
+ using(MemoryStream stream = new MemoryStream(data))
+ {
+ BinaryReader reader = new BinaryReader(stream);
+ ushort protocolVersion = reader.ReadUInt16();
+ ushort messageType = reader.ReadUInt16();
+ if(messageType >= 32)
+ {
+ //Custom message
+ if(protocolVersion != NetworkConfig.ProtocolVersion)
+ {
+ Debug.LogWarning("MLAPI: Protocol version not matching");
+ DisconnectClient(connectionId);
+ }
+ }
+ else
+ {
+ //MLAPI message
+ switch(messageType)
+ {
+ case 0: //Client to server > sends connection buffer
+ byte[] connectionBuffer = reader.ReadBytes(int.MaxValue);
+ NetworkConfig.ConnectionApprovalCallback(connectionBuffer, connectionId, HandleApproval);
+ break;
+ case 1: //Server gives client it's connectionId
+ break;
+ case 2: //Server informs client of spawned objects
+ break;
+ case 3: //Server informs client of spawned players
+ break;
+ }
+ }
+ }
+ }
+
+ protected void Send(int connectionId, string messageType, string channelName, byte[] data)
+ {
+ using (MemoryStream stream = new MemoryStream())
+ {
+ BinaryWriter writer = new BinaryWriter(stream);
+ writer.Write(NetworkConfig.ProtocolVersion);
+ writer.Write(messageTypes[messageType]);
+ writer.Write(data);
+ NetworkTransport.Send(hostId, connectionId, channels[channelName], data, data.Length, out error);
+ }
+ }
+
+ protected void Send(int[] connectonIds, string messageType, string channelName, byte[] data)
+ {
+ for (int i = 0; i < connectonIds.Length; i++)
+ {
+ Send(connectonIds[i], messageType, channelName, data);
+ }
+ }
+
+ protected void Send(List connectonIds, string messageType, string channelName, byte[] data)
+ {
+ for (int i = 0; i < connectonIds.Count; i++)
+ {
+ Send(connectonIds[i], messageType, channelName, data);
+ }
+ }
+
+ protected void DisconnectClient(int connectionId)
+ {
+ if (pendingClients.Contains(connectionId))
+ pendingClients.Remove(connectionId);
+ if (connectedClients.ContainsKey(connectionId))
+ connectedClients.Remove(connectionId);
+ NetworkTransport.Disconnect(hostId, connectionId, out error);
+
+ }
+
+ private void HandleApproval(int connectionId, bool approved)
+ {
+ if(approved)
+ {
+ NetworkedClient client = new NetworkedClient()
+ {
+ ClientId = connectionId
+ };
+ connectedClients.Add(connectionId, client);
+ }
+ else
+ {
+ if (pendingClients.Contains(connectionId))
+ pendingClients.Remove(connectionId);
+ NetworkTransport.Disconnect(hostId, connectionId, out error);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d21dd1c
--- /dev/null
+++ b/README.md
@@ -0,0 +1,23 @@
+# MLAPI
+MLAPI (Mid level API) is a framework that hopefully simplifies building networked games in Unity. It is built on the LLAPI and is similar to the HLAPI in many ways. It does not however integrate into the compiler and it's ment to offer much greater flexibility than the HLAPI while keeping some of it's simplicity.
+
+The project is WIP.
+It's licenced under the MIT licence :D
+
+## Features that are planned / done are:
+* Object and player spawning (working on atm)
+* Connection approval (done)
+* Message names (done)
+* Replace the integer QOS with names. When you setup the networking you specify names that are assosiated with a channel. This makes it easier to manager. You can thus specify that a message should be sent on the "damage" channel which handles all damage related logic and is running on the AllCostDeliery channel. (done)
+* ProtcolVersion to allow making different versions not talk to each other. (done)
+* NetworkedBehaviours does not have to be on the root, it's simply just a class that implements the send methods etc. You could switch all your MonoBehaviours to NetworkedBehaviours
+* Multiple messages processed every frame with the ability to specify a maximum to prevent freezes in the normal game logic (done)
+* Built in lag compensation (going to be worked on when all base functionality is there)
+* Area of intrest (not working on ATM but it's on the TODO)
+That's all I can think of right now. But there is more to come, especially if people show intrest in the project.
+
+
+
+## Indepth
+The project shares many similarities with the HLAPI. But here are the major differences:
+* The command / rpc system is replaced with a messaging system. You simply call the Send method in the NetworkedBehaviour and specify a name (string), all scripts that are listening to that message name will recieve an update.