feat: Added exceptions to the public API

Author: TwoTenPvP

MLAPI/Data/Exceptions/NotServerException.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace MLAPI.Exceptions
+{
+    /// <summary>
+    /// Exception thrown when the operation can only be done on the server
+    /// </summary>
+    public class NotServerException : Exception
+    {
+        /// <summary>
+        /// Constructs a ObjectNotSpawnedException
+        /// </summary>
+        public NotServerException()
+        {
+            
+        }
+
+        /// <summary>
+        /// Constructs a NotServerException with a message
+        /// </summary>
+        /// <param name="message">The exception message</param>
+        public NotServerException(string message) : base(message)
+        {
+            
+        }
+
+        /// <summary>
+        /// Constructs a NotServerException with a message and a inner exception
+        /// </summary>
+        /// <param name="message">The exception message</param>
+        /// <param name="inner">The inner exception</param>
+        public NotServerException(string message, Exception inner) : base(message, inner)
+        {
+            
+        }
+    }
+}

MLAPI/Data/Exceptions/SpawnStateException.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace MLAPI.Exceptions
+{
+    /// <summary>
+    /// Exception thrown when an object is not yet spawned
+    /// </summary>
+    public class SpawnStateException : Exception
+    {
+        /// <summary>
+        /// Constructs a SpawnStateException
+        /// </summary>
+        public SpawnStateException()
+        {
+            
+        }
+
+        /// <summary>
+        /// Constructs a SpawnStateException with a message
+        /// </summary>
+        /// <param name="message">The exception message</param>
+        public SpawnStateException(string message) : base(message)
+        {
+            
+        }
+
+        /// <summary>
+        /// Constructs a SpawnStateException with a message and a inner exception
+        /// </summary>
+        /// <param name="message">The exception message</param>
+        /// <param name="inner">The inner exception</param>
+        public SpawnStateException(string message, Exception inner) : base(message, inner)
+        {
+            
+        }
+    }
+}

MLAPI/MonoBehaviours/Core/NetworkedObject.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using MLAPI.Components;
 using MLAPI.Data;
+using MLAPI.Exceptions;
 using MLAPI.Internal;
 using MLAPI.Logging;
 using MLAPI.Serialization;
@@ -157,6 +158,11 @@ internal set
         /// <returns>Observers enumerator</returns>
         public HashSet<ulong>.Enumerator GetObservers()
         {
+            if (!IsSpawned)
+            {
+                throw new SpawnStateException("Object is not spawned");
+            }
+            
             return observers.GetEnumerator();
         }
 
@@ -167,6 +173,11 @@ public HashSet<ulong>.Enumerator GetObservers()
         /// <returns>True if the client knows about the object</returns>
         public bool IsNetworkVisibleTo(ulong clientId)
         {
+            if (!IsSpawned)
+            {
+                throw new SpawnStateException("Object is not spawned");
+            }
+            
             return observers.Contains(clientId);
         }
 
@@ -177,10 +188,14 @@ public bool IsNetworkVisibleTo(ulong clientId)
         /// <param name="payload">An optional payload to send as part of the spawn</param>
         public void NetworkShow(ulong clientId, Stream payload = null)
         {
+            if (!IsSpawned)
+            {
+                throw new SpawnStateException("Object is not spawned");
+            }
+            
             if (!NetworkingManager.Singleton.IsServer)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Error) LogHelper.LogError("Can only call NetworkShow on the server");
-                return;
+                throw new NotServerException("Only server can change visibility");
             }
 
             if (!observers.Contains(clientId))
@@ -198,10 +213,14 @@ public void NetworkShow(ulong clientId, Stream payload = null)
         /// <param name="clientId">The client to hide the object for</param>
         public void NetworkHide(ulong clientId)
         {
+            if (!IsSpawned)
+            {
+                throw new SpawnStateException("Object is not spawned");
+            }
+            
             if (!NetworkingManager.Singleton.IsServer)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Error) LogHelper.LogError("Can only call NetworkHide on the server");
-                return;
+                throw new NotServerException("Only server can change visibility");
             }
 
             if (observers.Contains(clientId) && clientId != NetworkingManager.Singleton.ServerClientId)
@@ -252,7 +271,7 @@ public void Spawn(Stream spawnPayload = null, bool destroyWithScene = false)
         /// Unspawns this GameObject and destroys it for other clients. This should be used if the object should be kept on the server
         /// </summary>
         public void UnSpawn()
-        {
+        {            
             SpawnManager.UnSpawnObject(this);
         }
 
@@ -305,15 +324,15 @@ public void SpawnAsPlayerObject(ulong clientId, Stream spawnPayload = null, bool
         /// </summary>
         public void RemoveOwnership()
         {
-            SpawnManager.RemoveOwnership(NetworkId);
+            SpawnManager.RemoveOwnership(this);
         }
         /// <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(ulong newOwnerClientId)
         {
-            SpawnManager.ChangeOwnership(NetworkId, newOwnerClientId);
+            SpawnManager.ChangeOwnership(this, newOwnerClientId);
         }
 
         internal void InvokeBehaviourOnLostOwnership()

MLAPI/NetworkingManagerComponents/Core/LagCompensationManager.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using MLAPI.Exceptions;
 using MLAPI.Logging;
 
 namespace MLAPI.Components
@@ -21,11 +22,11 @@ public static class LagCompensationManager
         /// <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)
+            if (!NetworkingManager.Singleton.IsServer)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Lag compensation simulations are only to be ran on the server");
-                return;
+                throw new NotServerException("Only the server can perform lag compensation");
             }
+            
             for (int i = 0; i < simulationObjects.Count; i++)
             {
                 simulationObjects[i].ReverseTransform(secondsAgo);
@@ -48,9 +49,9 @@ public static void Simulate(ulong clientId, Action action)
         {
             if (!NetworkingManager.Singleton.IsServer)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Lag compensation simulations are only to be ran on the server");
-                return;
+                throw new NotServerException("Only the server can perform lag compensation");
             }
+            
             float millisecondsDelay = NetworkingManager.Singleton.NetworkConfig.NetworkTransport.GetCurrentRtt(clientId) / 2f;
             Simulate(millisecondsDelay * 1000f, action);
         }

MLAPI/NetworkingManagerComponents/Core/NetworkSceneManager.cs

@@ -2,6 +2,7 @@
 using System;
 using System.IO;
 using MLAPI.Data;
+using MLAPI.Exceptions;
 using MLAPI.Internal;
 using MLAPI.Logging;
 using MLAPI.Serialization;
@@ -53,7 +54,11 @@ internal static void SetCurrentSceneIndex()
         /// <param name="sceneName">The name of the scene to switch to</param>
         public static SceneSwitchProgress SwitchScene(string sceneName)
         {
-            if (isSwitching)
+            if (!NetworkingManager.Singleton.IsServer)
+            {
+                throw new NotServerException("Only server can start a scene switch");
+            }
+            else if (isSwitching)
             {
                 if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Scene switch already in progress");
                 return null;

MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs

@@ -1,14 +1,12 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
-using JetBrains.Annotations;
-using MLAPI.Configuration;
 using MLAPI.Data;
+using MLAPI.Exceptions;
 using MLAPI.Internal;
 using MLAPI.Logging;
-using MLAPI.NetworkedVar;
 using MLAPI.Serialization;
 using UnityEngine;
-using UnityEngine.SceneManagement;
 
 namespace MLAPI.Components
 {
@@ -165,55 +163,64 @@ public static NetworkedObject GetPlayerObject(ulong clientId)
             return NetworkingManager.Singleton.ConnectedClients[clientId].PlayerObject;
         }
 
-        internal static void RemoveOwnership(ulong networkId)
+        internal static void RemoveOwnership(NetworkedObject netObject)
         {
             if (!NetworkingManager.Singleton.IsServer)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("You can only remove ownership from Server");
-                return;
+                throw new NotServerException("Only the server can change ownership");
+            }
+
+            if (!netObject.IsSpawned)
+            {
+                throw new SpawnStateException("Object is not spawned");
             }
 
-            NetworkedObject netObject = SpawnManager.SpawnedObjects[networkId];
             for (int i = NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.Count - 1; i > -1; i--)
             {
-                if (NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects[i].NetworkId == networkId)
+                if (NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects[i] == netObject)
                     NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.RemoveAt(i);
             }
+            
 			netObject._ownerClientId = null;
 
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                 {
-                    writer.WriteUInt64Packed(networkId);
+                    writer.WriteUInt64Packed(netObject.NetworkId);
                     writer.WriteUInt64Packed(netObject.OwnerClientId);
 
                     InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, netObject);
                 }
             }
         }
 
-        internal static void ChangeOwnership(ulong networkId, ulong clientId)
+        internal static void ChangeOwnership(NetworkedObject netObject, ulong clientId)
         {
             if (!NetworkingManager.Singleton.IsServer)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("You can only change ownership from Server");
-                return;
+                throw new NotServerException("Only the server can change ownership");
             }
-            NetworkedObject netObject = SpawnManager.SpawnedObjects[networkId];
+
+            if (!netObject.IsSpawned)
+            {
+                throw new SpawnStateException("Object is not spawned");
+            }
+            
             for (int i = NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.Count - 1; i > -1; i--)
             {
-                if (NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects[i].NetworkId == networkId)
+                if (NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects[i] == netObject)
                     NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.RemoveAt(i);
             }
+            
             NetworkingManager.Singleton.ConnectedClients[clientId].OwnedObjects.Add(netObject);
             netObject.OwnerClientId = clientId;
 
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                 {
-                    writer.WriteUInt64Packed(networkId);
+                    writer.WriteUInt64Packed(netObject.NetworkId);
                     writer.WriteUInt64Packed(clientId);
 
                     InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, netObject);
@@ -259,14 +266,12 @@ internal static void SpawnNetworkedObjectLocally(NetworkedObject netObject, ulon
         {
             if (netObject == null)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Error) LogHelper.LogError("Cannot spawn null object");
-                return;
+                throw new ArgumentNullException(nameof(netObject), "Cannot spawn null object");
             }
 
             if (netObject.IsSpawned)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Error) LogHelper.LogError("Cannot spawn already spawned object");
-                return;
+                throw new SpawnStateException("Object is already spawned");
             }
 
 
@@ -393,13 +398,12 @@ internal static void UnSpawnObject(NetworkedObject netObject)
         {
             if (!netObject.IsSpawned)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Cannot unspawn objects that are not spawned");
-                return;
+                throw new SpawnStateException("Object is not spawned");
             }
-            else if (!NetworkingManager.Singleton.IsServer)
+            
+            if (!NetworkingManager.Singleton.IsServer)
             {
-                if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Only server can unspawn objects");
-                return;
+                throw new NotServerException("Only server unspawn objects");
             }
 
             OnDestroyObject(netObject.NetworkId, false);