Basic Networking done

Assets/Mirror/Runtime/Utils.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using UnityEngine;
+
+namespace Mirror
+{
+    // Handles network messages on client and server
+    public delegate void NetworkMessageDelegate(NetworkConnection conn, NetworkReader reader, int channelId);
+
+    // Handles requests to spawn objects on the client
+    public delegate GameObject SpawnDelegate(Vector3 position, Guid assetId);
+
+    public delegate GameObject SpawnHandlerDelegate(SpawnMessage msg);
+
+    // Handles requests to unspawn objects on the client
+    public delegate void UnSpawnDelegate(GameObject spawned);
+
+    // invoke type for Cmd/Rpc
+    public enum MirrorInvokeType
+    {
+        Command,
+        ClientRpc
+    }
+
+    // Deprecated 2021-03-15
+    [Obsolete("Version has never been used, neither by UNET nor by Mirror.")]
+    public enum Version
+    {
+        Current = 1
+    }
+
+    // channels are const ints instead of an enum so people can add their own
+    // channels (can't extend an enum otherwise).
+    //
+    // note that Mirror is slowly moving towards quake style networking which
+    // will only require reliable for handshake, and unreliable for the rest.
+    // so eventually we can change this to an Enum and transports shouldn't
+    // add custom channels anymore.
+    public static class Channels
+    {
+        public const int Reliable = 0;      // ordered
+        public const int Unreliable = 1;    // unordered
+
+        // Deprecated 2021-03-15
+        [Obsolete("Use Channels.Reliable instead")]
+        public const int DefaultReliable = Reliable;
+
+        // Deprecated 2021-03-15
+        [Obsolete("Use Channels.Unreliable instead")]
+        public const int DefaultUnreliable = Unreliable;
+    }
+
+    // -- helpers for float conversion without allocations --
+    [StructLayout(LayoutKind.Explicit)]
+    internal struct UIntFloat
+    {
+        [FieldOffset(0)]
+        public float floatValue;
+
+        [FieldOffset(0)]
+        public uint intValue;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    internal struct UIntDouble
+    {
+        [FieldOffset(0)]
+        public double doubleValue;
+
+        [FieldOffset(0)]
+        public ulong longValue;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    internal struct UIntDecimal
+    {
+        [FieldOffset(0)]
+        public ulong longValue1;
+
+        [FieldOffset(8)]
+        public ulong longValue2;
+
+        [FieldOffset(0)]
+        public decimal decimalValue;
+    }
+
+    public static class Utils
+    {
+        public static uint GetTrueRandomUInt()
+        {
+            // use Crypto RNG to avoid having time based duplicates
+            using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
+            {
+                byte[] bytes = new byte[4];
+                rng.GetBytes(bytes);
+                return BitConverter.ToUInt32(bytes, 0);
+            }
+        }
+
+        public static bool IsPrefab(GameObject obj)
+        {
+#if UNITY_EDITOR
+            return UnityEditor.PrefabUtility.IsPartOfPrefabAsset(obj);
+#else
+            return false;
+#endif
+        }
+
+        public static bool IsSceneObjectWithPrefabParent(GameObject gameObject, out GameObject prefab)
+        {
+            prefab = null;
+
+#if UNITY_EDITOR
+            if (!UnityEditor.PrefabUtility.IsPartOfPrefabInstance(gameObject))
+            {
+                return false;
+            }
+            prefab = UnityEditor.PrefabUtility.GetCorrespondingObjectFromSource(gameObject);
+#endif
+
+            if (prefab == null)
+            {
+                Debug.LogError("Failed to find prefab parent for scene object [name:" + gameObject.name + "]");
+                return false;
+            }
+            return true;
+        }
+
+        // is a 2D point in screen? (from ummorpg)
+        // (if width = 1024, then indices from 0..1023 are valid (=1024 indices)
+        public static bool IsPointInScreen(Vector2 point) =>
+            0 <= point.x && point.x < Screen.width &&
+            0 <= point.y && point.y < Screen.height;
+    }
+}