GabrielTofvesson/MLAPI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First commit with basic functionality, licence and readme

Browse Source
This commit is contained in:
Albin Corén 2018-01-05 14:19:26 +01:00
parent 776ba9dc0a
commit c102935df1
9 changed files with 460 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
LICENCE Normal file
View File

@ -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.

12
MLAPI/Class1.cs
View File

@ -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
{
}
}

42
MLAPI/MLAPI.csproj
View File

@ -1,22 +1,23 @@
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>ee431720-a9ed-43dc-9e74-10b693816d38</ProjectGuid>
<ProjectGuid>{EE431720-A9ED-43DC-9E74-10B693816D38}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>MLAPI</RootNamespace>
<AssemblyName>MLAPI</AssemblyName>
<TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<OutputPath>..\..\..\..\Documents\MLAPI\Assets\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
@ -30,24 +31,25 @@
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System"/>
<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="System" />
<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="Class1.cs" />
<Compile Include="NetworkedBehaviour.cs" />
<Compile Include="NetworkedClient.cs" />
<Compile Include="NetworkedObject.cs" />
<Compile Include="NetworkingConfiguration.cs" />
<Compile Include="NetworkingManager.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>
</Project>

35
MLAPI/NetworkedBehaviour.cs Normal file
View File

@ -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<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);
}
}
}
}

7
MLAPI/NetworkedClient.cs Normal file
View File

@ -0,0 +1,7 @@
namespace MLAPI
{
public class NetworkedClient
{
public int ClientId;
}
}

11
MLAPI/NetworkedObject.cs Normal file
View File

@ -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
{
}
}

21
MLAPI/NetworkingConfiguration.cs Normal file
View File

@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
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 int ClientConnectionBufferTimeout = 10;
public bool ConnectionApproval = false;
public Action<byte[], int, Action<int, bool>> ConnectionApprovalCallback;
public byte[] ConnectionData;
}
}

320
MLAPI/NetworkingManager.cs Normal file
View File

@ -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<int, NetworkedClient> connectedClients;
private HashSet<int> pendingClients;
internal bool isServer;
private bool isListening;
private byte[] messageBuffer;
private Dictionary<string, int> channels;
private Dictionary<string, ushort> messageTypes;
private Dictionary<ushort, Dictionary<int, Action<int, byte[]>>> messageCallbacks;
private Dictionary<ushort, int> messageHandlerCounter;
private Dictionary<ushort, Stack<int>> releasedMessageHandlerCounters;
public NetworkingConfiguration NetworkConfig;
internal int AddIncomingMessageHandler(string name, Action<int, byte[]> 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<int>());
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<int, Action<int, byte[]>>());
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<int>();
connectedClients = new Dictionary<int, NetworkedClient>();
messageBuffer = new byte[NetworkConfig.MessageBufferSize];
channels = new Dictionary<string, int>();
messageTypes = new Dictionary<string, ushort>();
messageCallbacks = new Dictionary<ushort, Dictionary<int, Action<int, byte[]>>>();
messageHandlerCounter = new Dictionary<ushort, int>();
releasedMessageHandlerCounters = new Dictionary<ushort, Stack<int>>();
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<string, QosType> 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<int> 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);
}
}
}
}

23
README.md Normal file
View File

@ -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.