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

Added XML documentation to public methods

Browse Source
This commit is contained in:
Albin Corén 2018-03-31 09:07:42 +02:00
parent d53179832d
commit 7b42bbfd3a
13 changed files with 439 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
MLAPI/Attributes/SyncedVar.cs
View File

@ -2,9 +2,15 @@
namespace MLAPI.Attributes
{
/// <summary>
/// The attribute to use for variables that should be automatically. replicated from Server to Client.
/// </summary>
[AttributeUsage(AttributeTargets.Field)]
public class SyncedVar : Attribute
{
/// <summary>
/// The method name to invoke when the SyncVar get's updated.
/// </summary>
public string hook;
public SyncedVar()

16
MLAPI/Data/ClientIdKey.cs
View File

@ -1,10 +1,24 @@
namespace MLAPI.Data
{
struct ClientIdKey
/// <summary>
/// A struct representing a client. Contains a hostId and a connectionId.
/// </summary>
internal struct ClientIdKey
{
/// <summary>
/// The NetworkTransport hostId
/// </summary>
internal readonly int hostId;
/// <summary>
/// The NetworkTransport connectionId
/// </summary>
internal readonly int connectionId;
/// <summary>
/// Creates a new ClientIdKey
/// </summary>
/// <param name="hostId">The NetworkTransport hostId</param>
/// <param name="connectionId">The NetworkTransport connectionId</param>
internal ClientIdKey (int hostId, int connectionId)
{
this.hostId = hostId;

3
MLAPI/Data/FieldType.cs
View File

@ -1,5 +1,8 @@
namespace MLAPI.Data
{
/// <summary>
/// The datatype used to classify SyncedVars
/// </summary>
internal enum FieldType
{
Bool,

15
MLAPI/Data/NetworkedClient.cs
View File

@ -3,11 +3,26 @@ using UnityEngine;
namespace MLAPI
{
/// <summary>
/// A NetworkedClient
/// </summary>
public class NetworkedClient
{
/// <summary>
/// The Id of the NetworkedClient
/// </summary>
public int ClientId;
/// <summary>
/// The PlayerObject of the Client
/// </summary>
public GameObject PlayerObject;
/// <summary>
/// The NetworkedObject's owned by this Client
/// </summary>
public List<NetworkedObject> OwnedObjects = new List<NetworkedObject>();
/// <summary>
/// The encryption key used for this client
/// </summary>
public byte[] AesKey;
}
}

94
MLAPI/Data/NetworkingConfiguration.cs
View File

@ -8,38 +8,123 @@ namespace MLAPI
{
public class NetworkingConfiguration
{
/// <summary>
/// The protocol version. Different versions doesn't talk to each other.
/// </summary>
public ushort ProtocolVersion = 0;
/// <summary>
/// Channels used by the NetworkedTransport
/// </summary>
public SortedDictionary<string, QosType> Channels = new SortedDictionary<string, QosType>();
/// <summary>
/// Registered MessageTypes
/// </summary>
public List<string> MessageTypes = new List<string>();
/// <summary>
/// List of MessageTypes that can be passed through by Server. MessageTypes in this list should thus not be trusted to as great of an extent as normal messages.
/// </summary>
public List<string> PassthroughMessageTypes = new List<string>();
/// <summary>
/// Internal collection of Passthrough MessageTypes
/// </summary>
internal HashSet<ushort> RegisteredPassthroughMessageTypes = new HashSet<ushort>();
/// <summary>
/// Set of channels that will have all message contents encrypted when used
/// </summary>
public HashSet<int> EncryptedChannels = new HashSet<int>();
/// <summary>
/// A list of SceneNames that can be used during networked games.
/// </summary>
public List<string> RegisteredScenes = new List<string>();
/// <summary>
/// The size of the receive message buffer. This is the max message size.
/// </summary>
public int MessageBufferSize = 65535;
/// <summary>
/// Amount of times per second the receive queue is emptied and all messages inside are processed.
/// </summary>
public int ReceiveTickrate = 64;
/// <summary>
/// The max amount of messages to process per ReceiveTickrate. This is to prevent flooding.
/// </summary>
public int MaxReceiveEventsPerTickRate = 500;
/// <summary>
/// The amount of times per second every pending message will be sent away.
/// </summary>
public int SendTickrate = 64;
/// <summary>
/// The amount of times per second internal frame events will occur, examples include SyncedVar send checking.
/// </summary>
public int EventTickrate = 64;
/// <summary>
/// The max amount of Clients that can connect.
/// </summary>
public int MaxConnections = 100;
/// <summary>
/// The port for the NetworkTransport to use
/// </summary>
public int Port = 7777;
/// <summary>
/// The address to connect to
/// </summary>
public string Address = "127.0.0.1";
/// <summary>
/// The amount of seconds to wait for handshake to complete before timing out a client
/// </summary>
public int ClientConnectionBufferTimeout = 10;
/// <summary>
/// Wheter or not to use connection approval
/// </summary>
public bool ConnectionApproval = false;
/// <summary>
/// The callback to invoke when a connection has to be decided if it should get approved
/// </summary>
public Action<byte[], int, Action<int, bool>> ConnectionApprovalCallback = null;
/// <summary>
/// The data to send during connection which can be used to decide on if a client should get accepted
/// </summary>
public byte[] ConnectionData = new byte[0];
/// <summary>
/// The amount of seconds to keep a lag compensation position history
/// </summary>
public float SecondsHistory = 5;
/// <summary>
/// Wheter or not to make the library handle object spawning
/// </summary>
public bool HandleObjectSpawning = true;
/// <summary>
/// Wheter or not to enable encryption
/// </summary>
public bool EnableEncryption = true;
/// <summary>
/// Wheter or not to enable signed diffie hellman key exchange.
/// </summary>
public bool SignKeyExchange = true;
/// <summary>
/// Private RSA XML key to use for signing key exchange
/// </summary>
public string RSAPrivateKey = "<RSAKeyValue><Modulus>vBEvOQki/EftWOgwh4G8/nFRvcDJLylc8P7Dhz5m/hpkkNtAMzizNKYUrGbs7sYWlEuMYBOWrzkIDGOMoOsYc9uCi+8EcmNoHDlIhK5yNfZUexYBF551VbvZ625LSBR7kmBxkyo4IPuA09fYCHeUFm3prt4h6aTD0Hjc7ZsJHUU=</Modulus><Exponent>EQ==</Exponent><P>ydgcrq5qLJOdDQibD3m9+o3/dkKoFeCC110dnMgdpEteCruyBdL0zjGKKvjjgy3XTSSp43EN591NiXaBp0JtDw==</P><Q>7obHrUnUCsSHUsIJ7+JOrupcGrQ0XaYcQ+Uwb2v7d2YUzwZ46U4gI9snfD2J0tc3DGEh3v3G0Q8q7bxEe3H4aw==</Q><DP>L34k3c6vkgSdbHp+1nb/hj+HZx6+I0PijQbZyolwYuSOmR0a1DGjA1bzVWe9D86NAxevgM9OkOjG8yrxVIgZqQ==</DP><DQ>OB+2gyBuIKa2bdNNodrlVlVC2RtXnZB/HwjAGjeGdnJfP8VJoE6eJo3rLEq3BG7fxq1xYaUfuLhGVg4uOyngGQ==</DQ><InverseQ>o97PimYu58qH5eFmySRCIsyhBr/tK2GM17Zd9QQPJZRSorrhIJn1m6gwQ/G5aJLIM/3Yl04CoyqmQGsPXMzW2w==</InverseQ><D>CxAR1i22w4vCquB7U0Pd8Nl9R2Wxez6rHTwpnoszPB+rkAzlqKj7e5FMgpykhoQfciKPyWqQZKkAeTMIRbN56JinvpAt5POId/28HDd5xjGymHE81k3RzoHqzQXFIOF1TSYKUWzjPPF/TU4nn7auD4i6lOODATsMqtLr5DRBN/0=</D></RSAKeyValue>"; //CHANGE THESE FOR PRODUCTION!
/// <summary>
/// Public RSA XML key to use for signing key exchange
/// </summary>
public string RSAPublicKey = "<RSAKeyValue><Modulus>vBEvOQki/EftWOgwh4G8/nFRvcDJLylc8P7Dhz5m/hpkkNtAMzizNKYUrGbs7sYWlEuMYBOWrzkIDGOMoOsYc9uCi+8EcmNoHDlIhK5yNfZUexYBF551VbvZ625LSBR7kmBxkyo4IPuA09fYCHeUFm3prt4h6aTD0Hjc7ZsJHUU=</Modulus><Exponent>EQ==</Exponent></RSAKeyValue>"; //CHANGE THESE FOR PRODUCTION!
/// <summary>
/// Wheter or not to allow any type of passthrough messages
/// </summary>
public bool AllowPassthroughMessages = true;
/// <summary>
/// Wheter or not to enable scene switching
/// </summary>
public bool EnableSceneSwitching = false;
//Cached config hash
private byte[] ConfigHash = null;
/// <summary>
/// Gets a SHA256 hash of parts of the NetworkingConfiguration instance
/// </summary>
/// <param name="cache"></param>
/// <returns></returns>
public byte[] GetConfig(bool cache = true)
{
if (ConfigHash != null && cache)
@ -92,6 +177,11 @@ namespace MLAPI
}
}
/// <summary>
/// Compares a SHA256 hash with the current NetworkingConfiguration instances hash
/// </summary>
/// <param name="hash"></param>
/// <returns></returns>
public bool CompareConfig(byte[] hash)
{
byte[] localConfigHash = GetConfig();

123
MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs
View File

@ -12,7 +12,13 @@ namespace MLAPI
{
public abstract class NetworkedBehaviour : MonoBehaviour
{
/// <summary>
/// The minimum delay in seconds between SyncedVar sends
/// </summary>
public float SyncVarSyncDelay = 0.1f;
/// <summary>
/// Gets if the object is the the personal clients player object
/// </summary>
public bool isLocalPlayer
{
get
@ -20,6 +26,9 @@ namespace MLAPI
return networkedObject.isLocalPlayer;
}
}
/// <summary>
/// Gets if the object is owned by the local player
/// </summary>
public bool isOwner
{
get
@ -27,6 +36,9 @@ namespace MLAPI
return networkedObject.isOwner;
}
}
/// <summary>
/// Gets if we are executing as server
/// </summary>
protected bool isServer
{
get
@ -34,6 +46,9 @@ namespace MLAPI
return NetworkingManager.singleton.isServer;
}
}
/// <summary>
/// Gets if we are executing as client
/// </summary>
protected bool isClient
{
get
@ -41,6 +56,9 @@ namespace MLAPI
return NetworkingManager.singleton.isClient;
}
}
/// <summary>
/// Gets if we are executing as Host, I.E Server and Client
/// </summary>
protected bool isHost
{
get
@ -48,6 +66,9 @@ namespace MLAPI
return NetworkingManager.singleton.isHost;
}
}
/// <summary>
/// The NetworkedObject that owns this NetworkedBehaviour instance
/// </summary>
public NetworkedObject networkedObject
{
get
@ -60,6 +81,9 @@ namespace MLAPI
}
}
private NetworkedObject _networkedObject = null;
/// <summary>
/// The NetworkId of the NetworkedObject that owns the NetworkedBehaviour instance
/// </summary>
public uint networkId
{
get
@ -67,7 +91,9 @@ namespace MLAPI
return networkedObject.NetworkId;
}
}
/// <summary>
/// The clientId that owns the NetworkedObject
/// </summary>
public int ownerClientId
{
get
@ -617,6 +643,12 @@ namespace MLAPI
#endregion
#region SEND METHODS
/// <summary>
/// Sends a buffer to the server from client
/// </summary>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToServer(string messageType, string channelName, byte[] data)
{
if(MessageManager.messageTypes[messageType] < 32)
@ -632,6 +664,12 @@ namespace MLAPI
NetworkingManager.singleton.Send(NetworkingManager.singleton.serverClientId, messageType, channelName, data);
}
/// <summary>
/// Sends a buffer to the server from client. Only handlers on this NetworkedBehaviour will get invoked
/// </summary>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToServerTarget(string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -647,6 +685,12 @@ namespace MLAPI
NetworkingManager.singleton.Send(NetworkingManager.singleton.serverClientId, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
}
/// <summary>
/// Sends a buffer to the server from client
/// </summary>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToLocalClient(string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -662,6 +706,12 @@ namespace MLAPI
NetworkingManager.singleton.Send(ownerClientId, messageType, channelName, data);
}
/// <summary>
/// Sends a buffer to the client that owns this object from the server. Only handlers on this NetworkedBehaviour will get invoked
/// </summary>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToLocalClientTarget(string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -677,6 +727,12 @@ namespace MLAPI
NetworkingManager.singleton.Send(ownerClientId, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
}
/// <summary>
/// Sends a buffer to all clients except to the owner object from the server
/// </summary>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToNonLocalClients(string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -692,6 +748,12 @@ namespace MLAPI
NetworkingManager.singleton.Send(messageType, channelName, data, ownerClientId);
}
/// <summary>
/// Sends a buffer to all clients except to the owner object from the server. Only handlers on this NetworkedBehaviour will get invoked
/// </summary>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToNonLocalClientsTarget(string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -707,6 +769,13 @@ namespace MLAPI
NetworkingManager.singleton.Send(messageType, channelName, data, ownerClientId, networkId, networkedObject.GetOrderIndex(this));
}
/// <summary>
/// Sends a buffer to a client with a given clientId from Server
/// </summary>
/// <param name="clientId">The clientId to send the message to</param>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToClient(int clientId, string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -722,6 +791,13 @@ namespace MLAPI
NetworkingManager.singleton.Send(clientId, messageType, channelName, data);
}
/// <summary>
/// Sends a buffer to a client with a given clientId from Server. Only handlers on this NetworkedBehaviour gets invoked
/// </summary>
/// <param name="clientId">The clientId to send the message to</param>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToClientTarget(int clientId, string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -737,6 +813,13 @@ namespace MLAPI
NetworkingManager.singleton.Send(clientId, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
}
/// <summary>
/// Sends a buffer to multiple clients from the server
/// </summary>
/// <param name="clientIds">The clientId's to send to</param>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToClients(int[] clientIds, string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -752,6 +835,13 @@ namespace MLAPI
NetworkingManager.singleton.Send(clientIds, messageType, channelName, data);
}
/// <summary>
/// Sends a buffer to multiple clients from the server. Only handlers on this NetworkedBehaviour gets invoked
/// </summary>
/// <param name="clientIds">The clientId's to send to</param>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToClientsTarget(int[] clientIds, string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -767,6 +857,13 @@ namespace MLAPI
NetworkingManager.singleton.Send(clientIds, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
}
/// <summary>
/// Sends a buffer to multiple clients from the server
/// </summary>
/// <param name="clientIds">The clientId's to send to</param>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToClients(List<int> clientIds, string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -782,6 +879,13 @@ namespace MLAPI
NetworkingManager.singleton.Send(clientIds, messageType, channelName, data);
}
/// <summary>
/// Sends a buffer to multiple clients from the server. Only handlers on this NetworkedBehaviour gets invoked
/// </summary>
/// <param name="clientIds">The clientId's to send to</param>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToClientsTarget(List<int> clientIds, string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -797,6 +901,12 @@ namespace MLAPI
NetworkingManager.singleton.Send(clientIds, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
}
/// <summary>
/// Sends a buffer to all clients from the server
/// </summary>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToClients(string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -812,6 +922,12 @@ namespace MLAPI
NetworkingManager.singleton.Send(messageType, channelName, data);
}
/// <summary>
/// Sends a buffer to all clients from the server. Only handlers on this NetworkedBehaviour will get invoked
/// </summary>
/// <param name="messageType">User defined messageType</param>
/// <param name="channelName">User defined channelName</param>
/// <param name="data">The binary data to send</param>
protected void SendToClientsTarget(string messageType, string channelName, byte[] data)
{
if (MessageManager.messageTypes[messageType] < 32)
@ -828,6 +944,11 @@ namespace MLAPI
}
#endregion
/// <summary>
/// Gets the local instance of a object with a given NetworkId
/// </summary>
/// <param name="networkId"></param>
/// <returns></returns>
protected NetworkedObject GetNetworkedObject(uint networkId)
{
return SpawnManager.spawnedObjects[networkId];

45
MLAPI/MonoBehaviours/Core/NetworkedObject.cs
View File

@ -8,19 +8,43 @@ namespace MLAPI
[AddComponentMenu("MLAPI/NetworkedObject", -99)]
public class NetworkedObject : MonoBehaviour
{
/// <summary>
/// The unique ID of this object that is synced across the network
/// </summary>
[HideInInspector]
public uint NetworkId;
/// <summary>
/// The clientId of the owner of this NetworkedObject
/// </summary>
[HideInInspector]
public int OwnerClientId = -2;
/// <summary>
/// The index of the prefab used to spawn this in the spawnablePrefabs list
/// </summary>
[HideInInspector]
public int SpawnablePrefabIndex;
/// <summary>
/// Gets if this object is a player object
/// </summary>
[HideInInspector]
public bool isPlayerObject = false;
/// <summary>
/// Gets or sets if this object should be replicated across the network
/// </summary>
public bool ServerOnly = false;
/// <summary>
/// Gets if this object is part of a pool
/// </summary>
[HideInInspector]
public bool isPooledObject = false;
/// <summary>
/// Gets the poolId this object is part of
/// </summary>
[HideInInspector]
public ushort PoolId;
/// <summary>
/// Gets if the object is the the personal clients player object
/// </summary>
public bool isLocalPlayer
{
get
@ -28,7 +52,9 @@ namespace MLAPI
return isPlayerObject && (OwnerClientId == NetworkingManager.singleton.MyClientId || (OwnerClientId == -1 && NetworkingManager.singleton.isHost));
}
}
/// <summary>
/// Gets if the object is owned by the local player
/// </summary>
public bool isOwner
{
get
@ -44,21 +70,32 @@ namespace MLAPI
internal bool isSpawned = false;
/// <summary>
/// Spawns this GameObject across the network. Can only be called from the Server
/// </summary>
public void Spawn()
{
SpawnManager.OnSpawnObject(this);
}
/// <summary>
/// Spawns an object across the network with a given owner. Can only be called from server
/// </summary>
/// <param name="clientId">The clientId to own the object</param>
public void SpawnWithOwnership(int clientId)
{
SpawnManager.OnSpawnObject(this, clientId);
}
/// <summary>
/// Removes all ownership of an object from any client. Can only be called from server
/// </summary>
public void RemoveOwnership()
{
SpawnManager.RemoveOwnership(NetworkId);
}
/// <summary>
/// Changes the owner of the object. Can only be called from server
/// </summary>
/// <param name="newOwnerClientId">The new owner clientId</param>
public void ChangeOwnership(int newOwnerClientId)
{
SpawnManager.ChangeOwnership(NetworkId, newOwnerClientId);

65
MLAPI/MonoBehaviours/Core/NetworkingManager.cs
View File

@ -14,16 +14,39 @@ namespace MLAPI
[AddComponentMenu("MLAPI/NetworkingManager", -100)]
public class NetworkingManager : MonoBehaviour
{
/// <summary>
/// A syncronized time, represents the time in seconds since the server application started. Is replicated across all clients
/// </summary>
public static float NetworkTime;
/// <summary>
/// Gets or sets if the NetworkingManager should be marked as DontDestroyOnLoad
/// </summary>
public bool DontDestroy = true;
/// <summary>
/// Gets or sets if the application should be set to run in background
/// </summary>
public bool RunInBackground = true;
/// <summary>
/// A list of spawnable prefabs
/// </summary>
public List<GameObject> SpawnablePrefabs;
/// <summary>
/// The default prefab to give to players
/// </summary>
public GameObject DefaultPlayerPrefab;
/// <summary>
/// The singleton instance of the NetworkingManager
/// </summary>
public static NetworkingManager singleton;
//Client only, what my connectionId is on the server
/// <summary>
/// The clientId the server calls the local client by, only valid for clients
/// </summary>
[HideInInspector]
public int MyClientId;
internal Dictionary<int, NetworkedClient> connectedClients;
/// <summary>
/// Gets a dictionary of connected clients
/// </summary>
public Dictionary<int, NetworkedClient> ConnectedClients
{
get
@ -34,6 +57,9 @@ namespace MLAPI
internal HashSet<int> pendingClients;
internal bool isServer;
internal bool isClient;
/// <summary>
/// Gets if we are running as host
/// </summary>
public bool isHost
{
get
@ -44,12 +70,26 @@ namespace MLAPI
private bool isListening;
private byte[] messageBuffer;
internal int serverClientId;
/// <summary>
/// Gets if we are connected as a client
/// </summary>
[HideInInspector]
public bool IsClientConnected;
/// <summary>
/// The callback to invoke once a client connects
/// </summary>
public Action<int> OnClientConnectedCallback = null;
/// <summary>
/// The callback to invoke when a client disconnects
/// </summary>
public Action<int> OnClientDisconnectCallback = null;
/// <summary>
/// The callback to invoke once the server is ready
/// </summary>
public Action OnServerStarted = null;
/// <summary>
/// The current NetworkingConfiguration
/// </summary>
public NetworkingConfiguration NetworkConfig;
private EllipticDiffieHellman clientDiffieHellman;
@ -199,6 +239,10 @@ namespace MLAPI
return cConfig;
}
/// <summary>
/// Starts a server with a given NetworkingConfiguration
/// </summary>
/// <param name="netConfig">The NetworkingConfiguration to use</param>
public void StartServer(NetworkingConfiguration netConfig)
{
ConnectionConfig cConfig = Init(netConfig);
@ -219,6 +263,10 @@ namespace MLAPI
OnServerStarted.Invoke();
}
/// <summary>
/// Starts a client with a given NetworkingConfiguration
/// </summary>
/// <param name="netConfig">The NetworkingConfiguration to use</param>
public void StartClient(NetworkingConfiguration netConfig)
{
ConnectionConfig cConfig = Init(netConfig);
@ -231,6 +279,9 @@ namespace MLAPI
serverClientId = NetworkTransport.Connect(hostId, NetworkConfig.Address, NetworkConfig.Port, 0, out error);
}
/// <summary>
/// Stops the running server
/// </summary>
public void StopServer()
{
HashSet<int> sentIds = new HashSet<int>();
@ -254,18 +305,28 @@ namespace MLAPI
Shutdown();
}
/// <summary>
/// Stops the running host
/// </summary>
public void StopHost()
{
StopServer();
//We don't stop client since we dont actually have a transport connection to our own host. We just handle host messages directly in the MLAPI
}
/// <summary>
/// Stops the running client
/// </summary>
public void StopClient()
{
NetworkTransport.Disconnect(hostId, serverClientId, out error);
Shutdown();
}
/// <summary>
/// Starts a Host with a given NetworkingConfiguration
/// </summary>
/// <param name="netConfig">The NetworkingConfiguration to use</param>
public void StartHost(NetworkingConfiguration netConfig)
{
ConnectionConfig cConfig = Init(netConfig);

12
MLAPI/NetworkingManagerComponents/CryptographyHelper.cs
View File

@ -6,6 +6,12 @@ namespace MLAPI.NetworkingManagerComponents
{
public static class CryptographyHelper
{
/// <summary>
/// Decrypts a message with AES with a given key and a salt that is encoded as the first 16 bytes of the buffer
/// </summary>
/// <param name="encryptedBuffer">The buffer with the salt</param>
/// <param name="key">The key to use</param>
/// <returns>The decrypted byte array</returns>
public static byte[] Decrypt(byte[] encryptedBuffer, byte[] key)
{
byte[] iv = new byte[16];
@ -26,6 +32,12 @@ namespace MLAPI.NetworkingManagerComponents
}
}
/// <summary>
/// Encrypts a message with AES with a given key and a random salt that gets encoded as the first 16 bytes of the encrypted buffer
/// </summary>
/// <param name="clearBuffer">The buffer to be encrypted</param>
/// <param name="key">The key to use</param>
/// <returns>The encrypted byte array with encoded salt</returns>
public static byte[] Encrypt(byte[] clearBuffer, byte[] key)
{
using (MemoryStream stream = new MemoryStream())

10
MLAPI/NetworkingManagerComponents/LagCompensationManager.cs
View File

@ -10,6 +10,11 @@ namespace MLAPI.NetworkingManagerComponents
{
public static List<TrackedObject> SimulationObjects = new List<TrackedObject>();
/// <summary>
/// Turns time back a given amount of seconds, invokes an action and turns it back
/// </summary>
/// <param name="secondsAgo">The amount of seconds</param>
/// <param name="action">The action to invoke when time is turned back</param>
public static void Simulate(float secondsAgo, Action action)
{
if(!NetworkingManager.singleton.isServer)
@ -31,6 +36,11 @@ namespace MLAPI.NetworkingManagerComponents
}
private static byte error = 0;
/// <summary>
/// Turns time back a given amount of seconds, invokes an action and turns it back. The time is based on the estimated RTT of a clientId
/// </summary>
/// <param name="clientId">The clientId's RTT to use</param>
/// <param name="action">The action to invoke when time is turned back</param>
public static void Simulate(int clientId, Action action)
{
if (!NetworkingManager.singleton.isServer)

36
MLAPI/NetworkingManagerComponents/MessageChunker.cs
View File

@ -5,6 +5,12 @@ namespace MLAPI.NetworkingManagerComponents
{
public static class MessageChunker
{
/// <summary>
/// Chunks a large byte array to smaller chunks
/// </summary>
/// <param name="message">The large byte array</param>
/// <param name="chunkSize">The amount of bytes of non header data to use for each chunk</param>
/// <returns>List of chunks</returns>
public static List<byte[]> GetChunkedMessage(ref byte[] message, int chunkSize)
{
List<byte[]> chunks = new List<byte[]>((int)Math.Ceiling((double)message.Length / chunkSize));
@ -36,6 +42,12 @@ namespace MLAPI.NetworkingManagerComponents
return chunks;
}
/// <summary>
/// Checks if a list of chunks has missing parts
/// </summary>
/// <param name="chunks">The list of chunks</param>
/// <param name="expectedChunksCount">The expected amount of chunks</param>
/// <returns>If list of chunks has missing parts</returns>
public static bool HasMissingParts(ref List<byte[]> chunks, uint expectedChunksCount)
{
if (chunks.Count < expectedChunksCount)
@ -54,6 +66,11 @@ namespace MLAPI.NetworkingManagerComponents
return chunks.Count - duplicateCount != expectedChunksCount;
}
/// <summary>
/// Checks if a list of chunks is in correct order
/// </summary>
/// <param name="chunks">The list of chunks</param>
/// <returns>If all chunks are in order</returns>
public static bool IsOrdered(ref List<byte[]> chunks)
{
uint lastChunkIndex = 0;
@ -69,6 +86,12 @@ namespace MLAPI.NetworkingManagerComponents
return true;
}
/// <summary>
/// Checks if a list of chunks have any duplicates inside of it
/// </summary>
/// <param name="chunks">The list of chunks</param>
/// <param name="expectedChunksCount">The expected amount of chunks</param>
/// <returns>If a list of chunks has duplicate chunks in it</returns>
public static bool HasDuplicates(ref List<byte[]> chunks, uint expectedChunksCount)
{
if (chunks.Count > expectedChunksCount)
@ -86,7 +109,12 @@ namespace MLAPI.NetworkingManagerComponents
return false;
}
/// <summary>
/// Converts a list of chunks back into the original buffer, this requires the list to be in correct order and properly verified
/// </summary>
/// <param name="chunks">The list of chunks</param>
/// <param name="chunkSize">The size of each chunk. Optional</param>
/// <returns></returns>
public static byte[] GetMessageOrdered(ref List<byte[]> chunks, int chunkSize = -1)
{
if (chunks.Count == 0)
@ -107,6 +135,12 @@ namespace MLAPI.NetworkingManagerComponents
return message;
}
/// <summary>
/// Converts a list of chunks back into the original buffer, this does not require the list to be in correct order and properly verified
/// </summary>
/// <param name="chunks">The list of chunks</param>
/// <param name="chunkSize">The size of each chunk. Optional</param>
/// <returns></returns>
public static byte[] GetMessageUnordered(ref List<byte[]> chunks, int chunkSize = -1)
{
if (chunks.Count == 0)

22
MLAPI/NetworkingManagerComponents/NetworkPoolManager.cs
View File

@ -11,7 +11,12 @@ namespace MLAPI.NetworkingManagerComponents
private static ushort PoolIndex = 0;
internal static Dictionary<string, ushort> PoolNamesToIndexes;
//Server only
/// <summary>
/// Creates a networked object pool. Can only be called from the server
/// </summary>
/// <param name="poolName">Name of the pool</param>
/// <param name="spawnablePrefabIndex">The index of the prefab to use in the spawnablePrefabs array</param>
/// <param name="size">The amount of objects in the pool</param>
public static void CreatePool(string poolName, int spawnablePrefabIndex, uint size = 16)
{
if(!NetworkingManager.singleton.isServer)
@ -24,6 +29,10 @@ namespace MLAPI.NetworkingManagerComponents
PoolIndex++;
}
/// <summary>
/// This destroys an object pool and all of it's objects. Can only be called from the server
/// </summary>
/// <param name="poolName">The name of the pool</param>
public static void DestroyPool(string poolName)
{
if (!NetworkingManager.singleton.isServer)
@ -38,6 +47,13 @@ namespace MLAPI.NetworkingManagerComponents
Pools.Remove(PoolNamesToIndexes[poolName]);
}
/// <summary>
/// Spawns a object from the pool at a given position and rotation. Can only be called from server.
/// </summary>
/// <param name="poolName">The name of the pool</param>
/// <param name="position">The position to spawn the object at</param>
/// <param name="rotation">The rotation to spawn the object at</param>
/// <returns></returns>
public static GameObject SpawnPoolObject(string poolName, Vector3 position, Quaternion rotation)
{
if (!NetworkingManager.singleton.isServer)
@ -63,6 +79,10 @@ namespace MLAPI.NetworkingManagerComponents
return go;
}
/// <summary>
/// Destroys a NetworkedObject if it's part of a pool. Use this instead of the MonoBehaviour Destroy method. Can only be called from Server.
/// </summary>
/// <param name="netObject">The NetworkedObject instance to destroy</param>
public static void DestroyPoolObject(NetworkedObject netObject)
{
if (!NetworkingManager.singleton.isServer)

4
MLAPI/NetworkingManagerComponents/NetworkSceneManager.cs
View File

@ -26,6 +26,10 @@ namespace MLAPI.NetworkingManagerComponents
CurrentSceneIndex = sceneNameToIndex[SceneManager.GetActiveScene().name];
}
/// <summary>
/// Switches to a scene with a given name. Can only be called from Server
/// </summary>
/// <param name="sceneName">The name of the scene to switch to</param>
public static void SwitchScene(string sceneName)
{
if(!NetworkingManager.singleton.NetworkConfig.EnableSceneSwitching)