Initial commit to the repository.

.gitattributes

@@ -0,0 +1,53 @@
+# 3D models
+*.3dm filter=lfs diff=lfs merge=lfs -text
+*.3ds filter=lfs diff=lfs merge=lfs -text
+*.blend filter=lfs diff=lfs merge=lfs -text
+*.c4d filter=lfs diff=lfs merge=lfs -text
+*.collada filter=lfs diff=lfs merge=lfs -text
+*.dae filter=lfs diff=lfs merge=lfs -text
+*.dxf filter=lfs diff=lfs merge=lfs -text
+*.fbx filter=lfs diff=lfs merge=lfs -text
+*.jas filter=lfs diff=lfs merge=lfs -text
+*.lws filter=lfs diff=lfs merge=lfs -text
+*.lxo filter=lfs diff=lfs merge=lfs -text
+*.ma filter=lfs diff=lfs merge=lfs -text
+*.max filter=lfs diff=lfs merge=lfs -text
+*.mb filter=lfs diff=lfs merge=lfs -text
+*.obj filter=lfs diff=lfs merge=lfs -text
+*.ply filter=lfs diff=lfs merge=lfs -text
+*.skp filter=lfs diff=lfs merge=lfs -text
+*.stl filter=lfs diff=lfs merge=lfs -text
+*.ztl filter=lfs diff=lfs merge=lfs -text
+# Audio
+*.aif filter=lfs diff=lfs merge=lfs -text
+*.aiff filter=lfs diff=lfs merge=lfs -text
+*.it filter=lfs diff=lfs merge=lfs -text
+*.mod filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.s3m filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.xm filter=lfs diff=lfs merge=lfs -text
+# Fonts
+*.otf filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
+# Images
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.exr filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.hdr filter=lfs diff=lfs merge=lfs -text
+*.iff filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.pict filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.psd filter=lfs diff=lfs merge=lfs -text
+*.tga filter=lfs diff=lfs merge=lfs -text
+*.tif filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Collapse Unity-generated files on GitHub
+*.asset linguist-generated
+*.mat linguist-generated
+*.meta linguist-generated
+*.prefab linguist-generated
+*.unity linguist-generated

.gitignore

@@ -0,0 +1,72 @@
+# This .gitignore file should be placed at the root of your Unity project directory
+#
+# Get latest from https://github.com/github/gitignore/blob/main/Unity.gitignore
+#
+/[Ll]ibrary/
+/[Tt]emp/
+/[Oo]bj/
+/[Bb]uild/
+/[Bb]uilds/
+/[Ll]ogs/
+/[Uu]ser[Ss]ettings/
+
+# MemoryCaptures can get excessive in size.
+# They also could contain extremely sensitive data
+/[Mm]emoryCaptures/
+
+# Recordings can get excessive in size
+/[Rr]ecordings/
+
+# Uncomment this line if you wish to ignore the asset store tools plugin
+# /[Aa]ssets/AssetStoreTools*
+
+# Autogenerated Jetbrains Rider plugin
+/[Aa]ssets/Plugins/Editor/JetBrains*
+
+# Visual Studio cache directory
+.vs/
+
+# Gradle cache directory
+.gradle/
+
+# Autogenerated VS/MD/Consulo solution and project files
+ExportedObj/
+.consulo/
+*.csproj
+*.unityproj
+*.sln
+*.suo
+*.tmp
+*.user
+*.userprefs
+*.pidb
+*.booproj
+*.svd
+*.pdb
+*.mdb
+*.opendb
+*.VC.db
+
+# Unity3D generated meta files
+*.pidb.meta
+*.pdb.meta
+*.mdb.meta
+
+# Unity3D generated file on crash reports
+sysinfo.txt
+
+# Builds
+*.apk
+*.aab
+*.unitypackage
+*.app
+
+# Crashlytics generated file
+crashlytics-build.properties
+
+# Packed Addressables
+/[Aa]ssets/[Aa]ddressable[Aa]ssets[Dd]ata/*/*.bin*
+
+# Temporary auto-generated Android Assets
+/[Aa]ssets/[Ss]treamingAssets/aa.meta
+/[Aa]ssets/[Ss]treamingAssets/aa/*

.vscode/settings.json

@@ -0,0 +1,58 @@
+{
+  "files.exclude": {
+    "**/.DS_Store": true,
+    "**/.git": true,
+    "**/.gitignore": true,
+    "**/.gitmodules": true,
+    "**/*.booproj": true,
+    "**/*.pidb": true,
+    "**/*.suo": true,
+    "**/*.user": true,
+    "**/*.userprefs": true,
+    "**/*.unityproj": true,
+    "**/*.dll": true,
+    "**/*.exe": true,
+    "**/*.pdf": true,
+    "**/*.mid": true,
+    "**/*.midi": true,
+    "**/*.wav": true,
+    "**/*.gif": true,
+    "**/*.ico": true,
+    "**/*.jpg": true,
+    "**/*.jpeg": true,
+    "**/*.png": true,
+    "**/*.psd": true,
+    "**/*.tga": true,
+    "**/*.tif": true,
+    "**/*.tiff": true,
+    "**/*.3ds": true,
+    "**/*.3DS": true,
+    "**/*.fbx": true,
+    "**/*.FBX": true,
+    "**/*.lxo": true,
+    "**/*.LXO": true,
+    "**/*.ma": true,
+    "**/*.MA": true,
+    "**/*.obj": true,
+    "**/*.OBJ": true,
+    "**/*.asset": true,
+    "**/*.cubemap": true,
+    "**/*.flare": true,
+    "**/*.mat": true,
+    "**/*.meta": true,
+    "**/*.prefab": true,
+    "**/*.unity": true,
+    "build/": true,
+    "Build/": true,
+    "Library/": true,
+    "library/": true,
+    "obj/": true,
+    "Obj/": true,
+    "ProjectSettings/": true,
+    "temp/": true,
+    "Temp/": true,
+    "**/*.csproj": true
+  },
+  "git.ignoreLimitWarning": true,
+  "esbonio.sphinx.confDir": ""
+}

.vsconfig

@@ -0,0 +1,6 @@
+{
+  "version": "1.0",
+  "components": [ 
+    "Microsoft.VisualStudio.Workload.ManagedGame"
+  ]
+} 

Assets/Materials.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5b1424152fd9fc348b8e33878d6e6234
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Materials/Player.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Player
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.2783019, g: 1, b: 0.3892091, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/Materials/Player.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: be9e482d028e9234da250ae990729af7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5cf8eb36be0834b3da408c694a41cb88
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Authenticators.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1b2f9d254154cd942ba40b06b869b8f3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Authenticators/BasicAuthenticator.cs

@@ -0,0 +1,193 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror.Authenticators
+{
+    [AddComponentMenu("Network/ Authenticators/Basic Authenticator")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-authenticators/basic-authenticator")]
+    public class BasicAuthenticator : NetworkAuthenticator
+    {
+        [Header("Server Credentials")]
+        public string serverUsername;
+        public string serverPassword;
+
+        [Header("Client Credentials")]
+        public string username;
+        public string password;
+
+        readonly HashSet<NetworkConnection> connectionsPendingDisconnect = new HashSet<NetworkConnection>();
+
+        #region Messages
+
+        public struct AuthRequestMessage : NetworkMessage
+        {
+            // use whatever credentials make sense for your game
+            // for example, you might want to pass the accessToken if using oauth
+            public string authUsername;
+            public string authPassword;
+        }
+
+        public struct AuthResponseMessage : NetworkMessage
+        {
+            public byte code;
+            public string message;
+        }
+
+        #endregion
+
+        #region Server
+
+        /// <summary>
+        /// Called on server from StartServer to initialize the Authenticator
+        /// <para>Server message handlers should be registered in this method.</para>
+        /// </summary>
+        public override void OnStartServer()
+        {
+            // register a handler for the authentication request we expect from client
+            NetworkServer.RegisterHandler<AuthRequestMessage>(OnAuthRequestMessage, false);
+        }
+
+        /// <summary>
+        /// Called on server from StopServer to reset the Authenticator
+        /// <para>Server message handlers should be registered in this method.</para>
+        /// </summary>
+        public override void OnStopServer()
+        {
+            // unregister the handler for the authentication request
+            NetworkServer.UnregisterHandler<AuthRequestMessage>();
+        }
+
+        /// <summary>
+        /// Called on server from OnServerAuthenticateInternal when a client needs to authenticate
+        /// </summary>
+        /// <param name="conn">Connection to client.</param>
+        public override void OnServerAuthenticate(NetworkConnectionToClient conn)
+        {
+            // do nothing...wait for AuthRequestMessage from client
+        }
+
+        /// <summary>
+        /// Called on server when the client's AuthRequestMessage arrives
+        /// </summary>
+        /// <param name="conn">Connection to client.</param>
+        /// <param name="msg">The message payload</param>
+        public void OnAuthRequestMessage(NetworkConnectionToClient conn, AuthRequestMessage msg)
+        {
+            //Debug.Log($"Authentication Request: {msg.authUsername} {msg.authPassword}");
+
+            if (connectionsPendingDisconnect.Contains(conn)) return;
+
+            // check the credentials by calling your web server, database table, playfab api, or any method appropriate.
+            if (msg.authUsername == serverUsername && msg.authPassword == serverPassword)
+            {
+                // create and send msg to client so it knows to proceed
+                AuthResponseMessage authResponseMessage = new AuthResponseMessage
+                {
+                    code = 100,
+                    message = "Success"
+                };
+
+                conn.Send(authResponseMessage);
+
+                // Accept the successful authentication
+                ServerAccept(conn);
+            }
+            else
+            {
+                connectionsPendingDisconnect.Add(conn);
+
+                // create and send msg to client so it knows to disconnect
+                AuthResponseMessage authResponseMessage = new AuthResponseMessage
+                {
+                    code = 200,
+                    message = "Invalid Credentials"
+                };
+
+                conn.Send(authResponseMessage);
+
+                // must set NetworkConnection isAuthenticated = false
+                conn.isAuthenticated = false;
+
+                // disconnect the client after 1 second so that response message gets delivered
+                StartCoroutine(DelayedDisconnect(conn, 1f));
+            }
+        }
+
+        IEnumerator DelayedDisconnect(NetworkConnectionToClient conn, float waitTime)
+        {
+            yield return new WaitForSeconds(waitTime);
+
+            // Reject the unsuccessful authentication
+            ServerReject(conn);
+
+            yield return null;
+
+            // remove conn from pending connections
+            connectionsPendingDisconnect.Remove(conn);
+        }
+
+        #endregion
+
+        #region Client
+
+        /// <summary>
+        /// Called on client from StartClient to initialize the Authenticator
+        /// <para>Client message handlers should be registered in this method.</para>
+        /// </summary>
+        public override void OnStartClient()
+        {
+            // register a handler for the authentication response we expect from server
+            NetworkClient.RegisterHandler<AuthResponseMessage>(OnAuthResponseMessage, false);
+        }
+
+        /// <summary>
+        /// Called on client from StopClient to reset the Authenticator
+        /// <para>Client message handlers should be unregistered in this method.</para>
+        /// </summary>
+        public override void OnStopClient()
+        {
+            // unregister the handler for the authentication response
+            NetworkClient.UnregisterHandler<AuthResponseMessage>();
+        }
+
+        /// <summary>
+        /// Called on client from OnClientAuthenticateInternal when a client needs to authenticate
+        /// </summary>
+        public override void OnClientAuthenticate()
+        {
+            AuthRequestMessage authRequestMessage = new AuthRequestMessage
+            {
+                authUsername = username,
+                authPassword = password
+            };
+
+            NetworkClient.connection.Send(authRequestMessage);
+        }
+
+        /// <summary>
+        /// Called on client when the server's AuthResponseMessage arrives
+        /// </summary>
+        /// <param name="msg">The message payload</param>
+        public void OnAuthResponseMessage(AuthResponseMessage msg)
+        {
+            if (msg.code == 100)
+            {
+                //Debug.Log($"Authentication Response: {msg.message}");
+
+                // Authentication has been accepted
+                ClientAccept();
+            }
+            else
+            {
+                Debug.LogError($"Authentication Response: {msg.message}");
+
+                // Authentication has been rejected
+                ClientReject();
+            }
+        }
+
+        #endregion
+    }
+}

Assets/Mirror/Authenticators/BasicAuthenticator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 28496b776660156428f00cf78289c1ec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Authenticators/DeviceAuthenticator.cs

@@ -0,0 +1,129 @@
+using System;
+using UnityEngine;
+
+namespace Mirror.Authenticators
+{
+    /// <summary>
+    /// An authenicator that identifies the user by their device.
+    /// <para>A GUID is used as a fallback when the platform doesn't support SystemInfo.deviceUniqueIdentifier.</para>
+    /// <para>Note: deviceUniqueIdentifier can be spoofed, so security is not guaranteed.</para>
+    /// <para>See https://docs.unity3d.com/ScriptReference/SystemInfo-deviceUniqueIdentifier.html for details.</para>
+    /// </summary>
+    [AddComponentMenu("Network/ Authenticators/Device Authenticator")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-authenticators/device-authenticator")]
+    public class DeviceAuthenticator : NetworkAuthenticator
+    {
+        #region Messages
+
+        public struct AuthRequestMessage : NetworkMessage
+        {
+            public string clientDeviceID;
+        }
+
+        public struct AuthResponseMessage : NetworkMessage { }
+
+        #endregion
+
+        #region Server
+
+        /// <summary>
+        /// Called on server from StartServer to initialize the Authenticator
+        /// <para>Server message handlers should be registered in this method.</para>
+        /// </summary>
+        public override void OnStartServer()
+        {
+            // register a handler for the authentication request we expect from client
+            NetworkServer.RegisterHandler<AuthRequestMessage>(OnAuthRequestMessage, false);
+        }
+
+        /// <summary>
+        /// Called on server from StopServer to reset the Authenticator
+        /// <para>Server message handlers should be registered in this method.</para>
+        /// </summary>
+        public override void OnStopServer()
+        {
+            // unregister the handler for the authentication request
+            NetworkServer.UnregisterHandler<AuthRequestMessage>();
+        }
+
+        /// <summary>
+        /// Called on server from OnServerAuthenticateInternal when a client needs to authenticate
+        /// </summary>
+        /// <param name="conn">Connection to client.</param>
+        public override void OnServerAuthenticate(NetworkConnectionToClient conn)
+        {
+            // do nothing, wait for client to send his id
+        }
+
+        void OnAuthRequestMessage(NetworkConnectionToClient conn, AuthRequestMessage msg)
+        {
+            Debug.Log($"connection {conn.connectionId} authenticated with id {msg.clientDeviceID}");
+
+            // Store the device id for later reference, e.g. when spawning the player
+            conn.authenticationData = msg.clientDeviceID;
+
+            // Send a response to client telling it to proceed as authenticated
+            conn.Send(new AuthResponseMessage());
+
+            // Accept the successful authentication
+            ServerAccept(conn);
+        }
+
+        #endregion
+
+        #region Client
+
+        /// <summary>
+        /// Called on client from StartClient to initialize the Authenticator
+        /// <para>Client message handlers should be registered in this method.</para>
+        /// </summary>
+        public override void OnStartClient()
+        {
+            // register a handler for the authentication response we expect from server
+            NetworkClient.RegisterHandler<AuthResponseMessage>(OnAuthResponseMessage, false);
+        }
+
+        /// <summary>
+        /// Called on client from StopClient to reset the Authenticator
+        /// <para>Client message handlers should be unregistered in this method.</para>
+        /// </summary>
+        public override void OnStopClient()
+        {
+            // unregister the handler for the authentication response
+            NetworkClient.UnregisterHandler<AuthResponseMessage>();
+        }
+
+        /// <summary>
+        /// Called on client from OnClientAuthenticateInternal when a client needs to authenticate
+        /// </summary>
+        public override void OnClientAuthenticate()
+        {
+            string deviceUniqueIdentifier = SystemInfo.deviceUniqueIdentifier;
+
+            // Not all platforms support this, so we use a GUID instead
+            if (deviceUniqueIdentifier == SystemInfo.unsupportedIdentifier)
+            {
+                // Get the value from PlayerPrefs if it exists, new GUID if it doesn't
+                deviceUniqueIdentifier = PlayerPrefs.GetString("deviceUniqueIdentifier", Guid.NewGuid().ToString());
+
+                // Store the deviceUniqueIdentifier to PlayerPrefs (in case we just made a new GUID)
+                PlayerPrefs.SetString("deviceUniqueIdentifier", deviceUniqueIdentifier);
+            }
+
+            // send the deviceUniqueIdentifier to the server
+            NetworkClient.connection.Send(new AuthRequestMessage { clientDeviceID = deviceUniqueIdentifier } );
+        }
+
+        /// <summary>
+        /// Called on client when the server's AuthResponseMessage arrives
+        /// </summary>
+        /// <param name="msg">The message payload</param>
+        public void OnAuthResponseMessage(AuthResponseMessage msg)
+        {
+            Debug.Log("Authentication Success");
+            ClientAccept();
+        }
+
+        #endregion
+    }
+}

Assets/Mirror/Authenticators/DeviceAuthenticator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 60960a6ba81a842deb2fdcdc93788242
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Authenticators/Mirror.Authenticators.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "Mirror.Authenticators",
+    "references": [
+        "Mirror"
+    ],
+    "optionalUnityReferences": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": []
+}

Assets/Mirror/Authenticators/Mirror.Authenticators.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e720aa64e3f58fb4880566a322584340
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Authenticators/TimeoutAuthenticator.cs

@@ -0,0 +1,70 @@
+using System.Collections;
+using UnityEngine;
+
+namespace Mirror.Authenticators
+{
+    /// <summary>
+    /// An authenticator that disconnects connections if they don't
+    /// authenticate within a specified time limit.
+    /// </summary>
+    [AddComponentMenu("Network/ Authenticators/Timeout Authenticator")]
+    public class TimeoutAuthenticator : NetworkAuthenticator
+    {
+        public NetworkAuthenticator authenticator;
+
+        [Range(0, 600), Tooltip("Timeout to auto-disconnect in seconds. Set to 0 for no timeout.")]
+        public float timeout = 60;
+
+        public void Awake()
+        {
+            authenticator.OnServerAuthenticated.AddListener(connection => OnServerAuthenticated.Invoke(connection));
+            authenticator.OnClientAuthenticated.AddListener(OnClientAuthenticated.Invoke);
+        }
+
+        public override void OnStartServer()
+        {
+            authenticator.OnStartServer();
+        }
+
+        public override void OnStopServer()
+        {
+            authenticator.OnStopServer();
+        }
+
+        public override void OnStartClient()
+        {
+            authenticator.OnStartClient();
+        }
+
+        public override void OnStopClient()
+        {
+            authenticator.OnStopClient();
+        }
+
+        public override void OnServerAuthenticate(NetworkConnectionToClient conn)
+        {
+            authenticator.OnServerAuthenticate(conn);
+            if (timeout > 0)
+                StartCoroutine(BeginAuthentication(conn));
+        }
+
+        public override void OnClientAuthenticate()
+        {
+            authenticator.OnClientAuthenticate();
+            if (timeout > 0)
+                StartCoroutine(BeginAuthentication(NetworkClient.connection));
+        }
+
+        IEnumerator BeginAuthentication(NetworkConnection conn)
+        {
+            //Debug.Log($"Authentication countdown started {conn} {timeout}");
+            yield return new WaitForSecondsRealtime(timeout);
+
+            if (!conn.isAuthenticated)
+            {
+                Debug.LogError($"Authentication Timeout - Disconnecting {conn}");
+                conn.Disconnect();
+            }
+        }
+    }
+}

Assets/Mirror/Authenticators/TimeoutAuthenticator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 24d8269a07b8e4edfa374753a91c946e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/CompilerSymbols.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1f8b918bcd89f5c488b06f5574f34760
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/CompilerSymbols/Mirror.CompilerSymbols.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "Mirror.CompilerSymbols",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": []
+}

Assets/Mirror/CompilerSymbols/Mirror.CompilerSymbols.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 325984b52e4128546bc7558552f8b1d2
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/CompilerSymbols/PreprocessorDefine.cs

@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace Mirror
+{
+    static class PreprocessorDefine
+    {
+        /// <summary>
+        /// Add define symbols as soon as Unity gets done compiling.
+        /// </summary>
+        [InitializeOnLoadMethod]
+        public static void AddDefineSymbols()
+        {
+            string currentDefines = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
+            HashSet<string> defines = new HashSet<string>(currentDefines.Split(';'))
+            {
+                "MIRROR",
+                "MIRROR_17_0_OR_NEWER",
+                "MIRROR_18_0_OR_NEWER",
+                "MIRROR_24_0_OR_NEWER",
+                "MIRROR_26_0_OR_NEWER",
+                "MIRROR_27_0_OR_NEWER",
+                "MIRROR_28_0_OR_NEWER",
+                "MIRROR_29_0_OR_NEWER",
+                "MIRROR_30_0_OR_NEWER",
+                "MIRROR_30_5_2_OR_NEWER",
+                "MIRROR_32_1_2_OR_NEWER",
+                "MIRROR_32_1_4_OR_NEWER",
+                "MIRROR_35_0_OR_NEWER",
+                "MIRROR_35_1_OR_NEWER",
+                "MIRROR_37_0_OR_NEWER",
+                "MIRROR_38_0_OR_NEWER",
+                "MIRROR_39_0_OR_NEWER",
+                "MIRROR_40_0_OR_NEWER",
+                "MIRROR_41_0_OR_NEWER",
+                "MIRROR_42_0_OR_NEWER",
+                "MIRROR_43_0_OR_NEWER",
+                "MIRROR_44_0_OR_NEWER",
+                "MIRROR_46_0_OR_NEWER",
+                "MIRROR_47_0_OR_NEWER",
+                "MIRROR_53_0_OR_NEWER",
+                "MIRROR_55_0_OR_NEWER",
+                "MIRROR_57_0_OR_NEWER",
+                "MIRROR_58_0_OR_NEWER",
+                "MIRROR_65_0_OR_NEWER",
+                "MIRROR_66_0_OR_NEWER"
+            };
+
+            // only touch PlayerSettings if we actually modified it.
+            // otherwise it shows up as changed in git each time.
+            string newDefines = string.Join(";", defines);
+            if (newDefines != currentDefines)
+            {
+                PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, newDefines);
+            }
+        }
+    }
+}

Assets/Mirror/CompilerSymbols/PreprocessorDefine.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f1d66fe74ec6f42dd974cba37d25d453
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9bee879fbc8ef4b1a9a9f7088bfbf726
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/AssemblyInfo.cs

@@ -0,0 +1,12 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Mirror.Tests.Common")]
+[assembly: InternalsVisibleTo("Mirror.Tests")]
+// need to use Unity.*.CodeGen assembly name to import Unity.CompilationPipeline
+// for ILPostProcessor tests.
+[assembly: InternalsVisibleTo("Unity.Mirror.Tests.CodeGen")]
+[assembly: InternalsVisibleTo("Mirror.Tests.Generated")]
+[assembly: InternalsVisibleTo("Mirror.Tests.Runtime")]
+[assembly: InternalsVisibleTo("Mirror.Tests.Performance.Editor")]
+[assembly: InternalsVisibleTo("Mirror.Tests.Performance.Runtime")]
+[assembly: InternalsVisibleTo("Mirror.Editor")]

Assets/Mirror/Components/AssemblyInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a65b9283f7a724e70b8e17cb277f4c1e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Discovery.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b5dcf9618f5e14a4eb60bff5480284a6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Discovery/NetworkDiscovery.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Net;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace Mirror.Discovery
+{
+    [Serializable]
+    public class ServerFoundUnityEvent : UnityEvent<ServerResponse> {};
+
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/Network Discovery")]
+    public class NetworkDiscovery : NetworkDiscoveryBase<ServerRequest, ServerResponse>
+    {
+        #region Server
+
+        public long ServerId { get; private set; }
+
+        [Tooltip("Transport to be advertised during discovery")]
+        public Transport transport;
+
+        [Tooltip("Invoked when a server is found")]
+        public ServerFoundUnityEvent OnServerFound;
+
+        public override void Start()
+        {
+            ServerId = RandomLong();
+
+            // active transport gets initialized in awake
+            // so make sure we set it here in Start()  (after awakes)
+            // Or just let the user assign it in the inspector
+            if (transport == null)
+                transport = Transport.activeTransport;
+
+            base.Start();
+        }
+
+        /// <summary>
+        /// Process the request from a client
+        /// </summary>
+        /// <remarks>
+        /// Override if you wish to provide more information to the clients
+        /// such as the name of the host player
+        /// </remarks>
+        /// <param name="request">Request coming from client</param>
+        /// <param name="endpoint">Address of the client that sent the request</param>
+        /// <returns>The message to be sent back to the client or null</returns>
+        protected override ServerResponse ProcessRequest(ServerRequest request, IPEndPoint endpoint)
+        {
+            // In this case we don't do anything with the request
+            // but other discovery implementations might want to use the data
+            // in there,  This way the client can ask for
+            // specific game mode or something
+
+            try
+            {
+                // this is an example reply message,  return your own
+                // to include whatever is relevant for your game
+                return new ServerResponse
+                {
+                    serverId = ServerId,
+                    uri = transport.ServerUri()
+                };
+            }
+            catch (NotImplementedException)
+            {
+                Debug.LogError($"Transport {transport} does not support network discovery");
+                throw;
+            }
+        }
+
+        #endregion
+
+        #region Client
+
+        /// <summary>
+        /// Create a message that will be broadcasted on the network to discover servers
+        /// </summary>
+        /// <remarks>
+        /// Override if you wish to include additional data in the discovery message
+        /// such as desired game mode, language, difficulty, etc... </remarks>
+        /// <returns>An instance of ServerRequest with data to be broadcasted</returns>
+        protected override ServerRequest GetRequest() => new ServerRequest();
+
+        /// <summary>
+        /// Process the answer from a server
+        /// </summary>
+        /// <remarks>
+        /// A client receives a reply from a server, this method processes the
+        /// reply and raises an event
+        /// </remarks>
+        /// <param name="response">Response that came from the server</param>
+        /// <param name="endpoint">Address of the server that replied</param>
+        protected override void ProcessResponse(ServerResponse response, IPEndPoint endpoint)
+        {
+            // we received a message from the remote endpoint
+            response.EndPoint = endpoint;
+
+            // although we got a supposedly valid url, we may not be able to resolve
+            // the provided host
+            // However we know the real ip address of the server because we just
+            // received a packet from it,  so use that as host.
+            UriBuilder realUri = new UriBuilder(response.uri)
+            {
+                Host = response.EndPoint.Address.ToString()
+            };
+            response.uri = realUri.Uri;
+
+            OnServerFound.Invoke(response);
+        }
+
+        #endregion
+    }
+}

Assets/Mirror/Components/Discovery/NetworkDiscovery.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c761308e733c51245b2e8bb4201f46dc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Discovery/NetworkDiscoveryBase.cs

@@ -0,0 +1,433 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading.Tasks;
+using UnityEngine;
+
+// Based on https://github.com/EnlightenedOne/MirrorNetworkDiscovery
+// forked from https://github.com/in0finite/MirrorNetworkDiscovery
+// Both are MIT Licensed
+
+namespace Mirror.Discovery
+{
+    /// <summary>
+    /// Base implementation for Network Discovery.  Extend this component
+    /// to provide custom discovery with game specific data
+    /// <see cref="NetworkDiscovery">NetworkDiscovery</see> for a sample implementation
+    /// </summary>
+    [DisallowMultipleComponent]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-discovery")]
+    public abstract class NetworkDiscoveryBase<Request, Response> : MonoBehaviour
+        where Request : NetworkMessage
+        where Response : NetworkMessage
+    {
+        public static bool SupportedOnThisPlatform { get { return Application.platform != RuntimePlatform.WebGLPlayer; } }
+
+        // each game should have a random unique handshake,  this way you can tell if this is the same game or not
+        [HideInInspector]
+        public long secretHandshake;
+
+        [SerializeField]
+        [Tooltip("The UDP port the server will listen for multi-cast messages")]
+        protected int serverBroadcastListenPort = 47777;
+
+        [SerializeField]
+        [Tooltip("If true, broadcasts a discovery request every ActiveDiscoveryInterval seconds")]
+        public bool enableActiveDiscovery = true;
+
+        [SerializeField]
+        [Tooltip("Time in seconds between multi-cast messages")]
+        [Range(1, 60)]
+        float ActiveDiscoveryInterval = 3;
+
+        protected UdpClient serverUdpClient;
+        protected UdpClient clientUdpClient;
+
+#if UNITY_EDITOR
+        void OnValidate()
+        {
+            if (secretHandshake == 0)
+            {
+                secretHandshake = RandomLong();
+                UnityEditor.Undo.RecordObject(this, "Set secret handshake");
+            }
+        }
+#endif
+
+        public static long RandomLong()
+        {
+            int value1 = UnityEngine.Random.Range(int.MinValue, int.MaxValue);
+            int value2 = UnityEngine.Random.Range(int.MinValue, int.MaxValue);
+            return value1 + ((long)value2 << 32);
+        }
+
+        /// <summary>
+        /// virtual so that inheriting classes' Start() can call base.Start() too
+        /// </summary>
+        public virtual void Start()
+        {
+            // Server mode? then start advertising
+#if UNITY_SERVER
+            AdvertiseServer();
+#endif
+        }
+
+        // Ensure the ports are cleared no matter when Game/Unity UI exits
+        void OnApplicationQuit()
+        {
+            //Debug.Log("NetworkDiscoveryBase OnApplicationQuit");
+            Shutdown();
+        }
+
+        void OnDisable()
+        {
+            //Debug.Log("NetworkDiscoveryBase OnDisable");
+            Shutdown();
+        }
+
+        void OnDestroy()
+        {
+            //Debug.Log("NetworkDiscoveryBase OnDestroy");
+            Shutdown();
+        }
+
+        void Shutdown()
+        {
+            EndpMulticastLock();
+            if (serverUdpClient != null)
+            {
+                try
+                {
+                    serverUdpClient.Close();
+                }
+                catch (Exception)
+                {
+                    // it is just close, swallow the error
+                }
+
+                serverUdpClient = null;
+            }
+
+            if (clientUdpClient != null)
+            {
+                try
+                {
+                    clientUdpClient.Close();
+                }
+                catch (Exception)
+                {
+                    // it is just close, swallow the error
+                }
+
+                clientUdpClient = null;
+            }
+
+            CancelInvoke();
+        }
+
+        #region Server
+
+        /// <summary>
+        /// Advertise this server in the local network
+        /// </summary>
+        public void AdvertiseServer()
+        {
+            if (!SupportedOnThisPlatform)
+                throw new PlatformNotSupportedException("Network discovery not supported in this platform");
+
+            StopDiscovery();
+
+            // Setup port -- may throw exception
+            serverUdpClient = new UdpClient(serverBroadcastListenPort)
+            {
+                EnableBroadcast = true,
+                MulticastLoopback = false
+            };
+
+            // listen for client pings
+            _ = ServerListenAsync();
+        }
+
+        public async Task ServerListenAsync()
+        {
+            BeginMulticastLock();
+            while (true)
+            {
+                try
+                {
+                    await ReceiveRequestAsync(serverUdpClient);
+                }
+                catch (ObjectDisposedException)
+                {
+                    // socket has been closed
+                    break;
+                }
+                catch (Exception)
+                {
+                }
+            }
+        }
+
+        async Task ReceiveRequestAsync(UdpClient udpClient)
+        {
+            // only proceed if there is available data in network buffer, or otherwise Receive() will block
+            // average time for UdpClient.Available : 10 us
+
+            UdpReceiveResult udpReceiveResult = await udpClient.ReceiveAsync();
+
+            using (NetworkReaderPooled networkReader = NetworkReaderPool.Get(udpReceiveResult.Buffer))
+            {
+                long handshake = networkReader.ReadLong();
+                if (handshake != secretHandshake)
+                {
+                    // message is not for us
+                    throw new ProtocolViolationException("Invalid handshake");
+                }
+
+                Request request = networkReader.Read<Request>();
+
+                ProcessClientRequest(request, udpReceiveResult.RemoteEndPoint);
+            }
+        }
+
+        /// <summary>
+        /// Reply to the client to inform it of this server
+        /// </summary>
+        /// <remarks>
+        /// Override if you wish to ignore server requests based on
+        /// custom criteria such as language, full server game mode or difficulty
+        /// </remarks>
+        /// <param name="request">Request coming from client</param>
+        /// <param name="endpoint">Address of the client that sent the request</param>
+        protected virtual void ProcessClientRequest(Request request, IPEndPoint endpoint)
+        {
+            Response info = ProcessRequest(request, endpoint);
+
+            if (info == null)
+                return;
+
+            using (NetworkWriterPooled writer = NetworkWriterPool.Get())
+            {
+                try
+                {
+                    writer.WriteLong(secretHandshake);
+
+                    writer.Write(info);
+
+                    ArraySegment<byte> data = writer.ToArraySegment();
+                    // signature matches
+                    // send response
+                    serverUdpClient.Send(data.Array, data.Count, endpoint);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogException(ex, this);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Process the request from a client
+        /// </summary>
+        /// <remarks>
+        /// Override if you wish to provide more information to the clients
+        /// such as the name of the host player
+        /// </remarks>
+        /// <param name="request">Request coming from client</param>
+        /// <param name="endpoint">Address of the client that sent the request</param>
+        /// <returns>The message to be sent back to the client or null</returns>
+        protected abstract Response ProcessRequest(Request request, IPEndPoint endpoint);
+
+        // Android Multicast fix: https://github.com/vis2k/Mirror/pull/2887
+#if UNITY_ANDROID
+        AndroidJavaObject multicastLock;
+        bool hasMulticastLock;
+#endif
+        void BeginMulticastLock()
+		{
+#if UNITY_ANDROID
+            if (hasMulticastLock) return;
+                
+            if (Application.platform == RuntimePlatform.Android)
+            {
+                using (AndroidJavaObject activity = new AndroidJavaClass("com.unity3d.player.UnityPlayer").GetStatic<AndroidJavaObject>("currentActivity"))
+                {
+                    using (var wifiManager = activity.Call<AndroidJavaObject>("getSystemService", "wifi"))
+                    {
+                        multicastLock = wifiManager.Call<AndroidJavaObject>("createMulticastLock", "lock");
+                        multicastLock.Call("acquire");
+                        hasMulticastLock = true;
+                    }
+                }
+			}
+#endif
+        }
+
+        void EndpMulticastLock()
+        {
+#if UNITY_ANDROID
+            if (!hasMulticastLock) return;
+            
+            multicastLock?.Call("release");
+            hasMulticastLock = false;
+#endif
+        }
+
+#endregion
+
+        #region Client
+
+        /// <summary>
+        /// Start Active Discovery
+        /// </summary>
+        public void StartDiscovery()
+        {
+            if (!SupportedOnThisPlatform)
+                throw new PlatformNotSupportedException("Network discovery not supported in this platform");
+
+            StopDiscovery();
+
+            try
+            {
+                // Setup port
+                clientUdpClient = new UdpClient(0)
+                {
+                    EnableBroadcast = true,
+                    MulticastLoopback = false
+                };
+            }
+            catch (Exception)
+            {
+                // Free the port if we took it
+                //Debug.LogError("NetworkDiscoveryBase StartDiscovery Exception");
+                Shutdown();
+                throw;
+            }
+
+            _ = ClientListenAsync();
+
+            if (enableActiveDiscovery) InvokeRepeating(nameof(BroadcastDiscoveryRequest), 0, ActiveDiscoveryInterval);
+        }
+
+        /// <summary>
+        /// Stop Active Discovery
+        /// </summary>
+        public void StopDiscovery()
+        {
+            //Debug.Log("NetworkDiscoveryBase StopDiscovery");
+            Shutdown();
+        }
+
+        /// <summary>
+        /// Awaits for server response
+        /// </summary>
+        /// <returns>ClientListenAsync Task</returns>
+        public async Task ClientListenAsync()
+        {
+            // while clientUpdClient to fix: 
+            // https://github.com/vis2k/Mirror/pull/2908
+            //
+            // If, you cancel discovery the clientUdpClient is set to null.
+            // However, nothing cancels ClientListenAsync. If we change the if(true)
+            // to check if the client is null. You can properly cancel the discovery, 
+            // and kill the listen thread.
+            //
+            // Prior to this fix, if you cancel the discovery search. It crashes the 
+            // thread, and is super noisy in the output. As well as causes issues on 
+            // the quest.
+            while (clientUdpClient != null)
+            {
+                try
+                {
+                    await ReceiveGameBroadcastAsync(clientUdpClient);
+                }
+                catch (ObjectDisposedException)
+                {
+                    // socket was closed, no problem
+                    return;
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogException(ex);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sends discovery request from client
+        /// </summary>
+        public void BroadcastDiscoveryRequest()
+        {
+            if (clientUdpClient == null)
+                return;
+
+            if (NetworkClient.isConnected)
+            {
+                StopDiscovery();
+                return;
+            }
+
+            IPEndPoint endPoint = new IPEndPoint(IPAddress.Broadcast, serverBroadcastListenPort);
+
+            using (NetworkWriterPooled writer = NetworkWriterPool.Get())
+            {
+                writer.WriteLong(secretHandshake);
+
+                try
+                {
+                    Request request = GetRequest();
+
+                    writer.Write(request);
+
+                    ArraySegment<byte> data = writer.ToArraySegment();
+
+                    clientUdpClient.SendAsync(data.Array, data.Count, endPoint);
+                }
+                catch (Exception)
+                {
+                    // It is ok if we can't broadcast to one of the addresses
+                }
+            }
+        }
+
+        /// <summary>
+        /// Create a message that will be broadcasted on the network to discover servers
+        /// </summary>
+        /// <remarks>
+        /// Override if you wish to include additional data in the discovery message
+        /// such as desired game mode, language, difficulty, etc... </remarks>
+        /// <returns>An instance of ServerRequest with data to be broadcasted</returns>
+        protected virtual Request GetRequest() => default;
+
+        async Task ReceiveGameBroadcastAsync(UdpClient udpClient)
+        {
+            // only proceed if there is available data in network buffer, or otherwise Receive() will block
+            // average time for UdpClient.Available : 10 us
+
+            UdpReceiveResult udpReceiveResult = await udpClient.ReceiveAsync();
+
+            using (NetworkReaderPooled networkReader = NetworkReaderPool.Get(udpReceiveResult.Buffer))
+            {
+                if (networkReader.ReadLong() != secretHandshake)
+                    return;
+
+                Response response = networkReader.Read<Response>();
+
+                ProcessResponse(response, udpReceiveResult.RemoteEndPoint);
+            }
+        }
+
+        /// <summary>
+        /// Process the answer from a server
+        /// </summary>
+        /// <remarks>
+        /// A client receives a reply from a server, this method processes the
+        /// reply and raises an event
+        /// </remarks>
+        /// <param name="response">Response that came from the server</param>
+        /// <param name="endpoint">Address of the server that replied</param>
+        protected abstract void ProcessResponse(Response response, IPEndPoint endpoint);
+
+        #endregion
+    }
+}

Assets/Mirror/Components/Discovery/NetworkDiscoveryBase.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b9971d60ce61f4e39b07cd9e7e0c68fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Discovery/NetworkDiscoveryHUD.cs

@@ -0,0 +1,132 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror.Discovery
+{
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/Network Discovery HUD")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-discovery")]
+    [RequireComponent(typeof(NetworkDiscovery))]
+    public class NetworkDiscoveryHUD : MonoBehaviour
+    {
+        readonly Dictionary<long, ServerResponse> discoveredServers = new Dictionary<long, ServerResponse>();
+        Vector2 scrollViewPos = Vector2.zero;
+
+        public NetworkDiscovery networkDiscovery;
+
+#if UNITY_EDITOR
+        void OnValidate()
+        {
+            if (networkDiscovery == null)
+            {
+                networkDiscovery = GetComponent<NetworkDiscovery>();
+                UnityEditor.Events.UnityEventTools.AddPersistentListener(networkDiscovery.OnServerFound, OnDiscoveredServer);
+                UnityEditor.Undo.RecordObjects(new Object[] { this, networkDiscovery }, "Set NetworkDiscovery");
+            }
+        }
+#endif
+
+        void OnGUI()
+        {
+            if (NetworkManager.singleton == null)
+                return;
+
+            if (!NetworkClient.isConnected && !NetworkServer.active && !NetworkClient.active)
+                DrawGUI();
+
+            if (NetworkServer.active || NetworkClient.active)
+                StopButtons();
+        }
+
+        void DrawGUI()
+        {
+            GUILayout.BeginArea(new Rect(10, 10, 300, 500));
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button("Find Servers"))
+            {
+                discoveredServers.Clear();
+                networkDiscovery.StartDiscovery();
+            }
+
+            // LAN Host
+            if (GUILayout.Button("Start Host"))
+            {
+                discoveredServers.Clear();
+                NetworkManager.singleton.StartHost();
+                networkDiscovery.AdvertiseServer();
+            }
+
+            // Dedicated server
+            if (GUILayout.Button("Start Server"))
+            {
+                discoveredServers.Clear();
+                NetworkManager.singleton.StartServer();
+                networkDiscovery.AdvertiseServer();
+            }
+
+            GUILayout.EndHorizontal();
+
+            // show list of found server
+
+            GUILayout.Label($"Discovered Servers [{discoveredServers.Count}]:");
+
+            // servers
+            scrollViewPos = GUILayout.BeginScrollView(scrollViewPos);
+
+            foreach (ServerResponse info in discoveredServers.Values)
+                if (GUILayout.Button(info.EndPoint.Address.ToString()))
+                    Connect(info);
+
+            GUILayout.EndScrollView();
+            GUILayout.EndArea();
+        }
+
+        void StopButtons()
+        {
+            GUILayout.BeginArea(new Rect(10, 40, 100, 25));
+
+            // stop host if host mode
+            if (NetworkServer.active && NetworkClient.isConnected)
+            {
+                if (GUILayout.Button("Stop Host"))
+                {
+                    NetworkManager.singleton.StopHost();
+                    networkDiscovery.StopDiscovery();
+                }
+            }
+            // stop client if client-only
+            else if (NetworkClient.isConnected)
+            {
+                if (GUILayout.Button("Stop Client"))
+                {
+                    NetworkManager.singleton.StopClient();
+                    networkDiscovery.StopDiscovery();
+                }
+            }
+            // stop server if server-only
+            else if (NetworkServer.active)
+            {
+                if (GUILayout.Button("Stop Server"))
+                {
+                    NetworkManager.singleton.StopServer();
+                    networkDiscovery.StopDiscovery();
+                }
+            }
+
+            GUILayout.EndArea();
+        }
+
+        void Connect(ServerResponse info)
+        {
+            networkDiscovery.StopDiscovery();
+            NetworkManager.singleton.StartClient(info.uri);
+        }
+
+        public void OnDiscoveredServer(ServerResponse info)
+        {
+            // Note that you can check the versioning to decide if you can connect to the server or not using this method
+            discoveredServers[info.serverId] = info;
+        }
+    }
+}

Assets/Mirror/Components/Discovery/NetworkDiscoveryHUD.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 88c37d3deca7a834d80cfd8d3cfcc510
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Discovery/ServerRequest.cs

@@ -0,0 +1,4 @@
+namespace Mirror.Discovery
+{
+    public struct ServerRequest : NetworkMessage {}
+}

Assets/Mirror/Components/Discovery/ServerRequest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ea7254bf7b9454da4adad881d94cd141
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Discovery/ServerResponse.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Net;
+
+namespace Mirror.Discovery
+{
+    public struct ServerResponse : NetworkMessage
+    {
+        // The server that sent this
+        // this is a property so that it is not serialized,  but the
+        // client fills this up after we receive it
+        public IPEndPoint EndPoint { get; set; }
+
+        public Uri uri;
+
+        // Prevent duplicate server appearance when a connection can be made via LAN on multiple NICs
+        public long serverId;
+    }
+}

Assets/Mirror/Components/Discovery/ServerResponse.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 36f97227fdf2d7a4e902db5bfc43039c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Experimental.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: bfbf2a1f2b300c5489dcab219ef2846e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Experimental/NetworkLerpRigidbody.cs

@@ -0,0 +1,93 @@
+using UnityEngine;
+
+namespace Mirror.Experimental
+{
+    [AddComponentMenu("Network/ Experimental/Network Lerp Rigidbody")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-lerp-rigidbody")]
+    public class NetworkLerpRigidbody : NetworkBehaviour
+    {
+        [Header("Settings")]
+        [SerializeField] internal Rigidbody target = null;
+        [Tooltip("How quickly current velocity approaches target velocity")]
+        [SerializeField] float lerpVelocityAmount = 0.5f;
+        [Tooltip("How quickly current position approaches target position")]
+        [SerializeField] float lerpPositionAmount = 0.5f;
+
+        [Tooltip("Set to true if moves come from owner client, set to false if moves always come from server")]
+        [SerializeField] bool clientAuthority = false;
+
+        float nextSyncTime;
+
+
+        [SyncVar()]
+        Vector3 targetVelocity;
+
+        [SyncVar()]
+        Vector3 targetPosition;
+
+        /// <summary>
+        /// Ignore value if is host or client with Authority
+        /// </summary>
+        /// <returns></returns>
+        bool IgnoreSync => isServer || ClientWithAuthority;
+
+        bool ClientWithAuthority => clientAuthority && hasAuthority;
+
+        void OnValidate()
+        {
+            if (target == null)
+            {
+                target = GetComponent<Rigidbody>();
+            }
+        }
+
+        void Update()
+        {
+            if (isServer)
+            {
+                SyncToClients();
+            }
+            else if (ClientWithAuthority)
+            {
+                SendToServer();
+            }
+        }
+
+        void SyncToClients()
+        {
+            targetVelocity = target.velocity;
+            targetPosition = target.position;
+        }
+
+        void SendToServer()
+        {
+            float now = Time.time;
+            if (now > nextSyncTime)
+            {
+                nextSyncTime = now + syncInterval;
+                CmdSendState(target.velocity, target.position);
+            }
+        }
+
+        [Command]
+        void CmdSendState(Vector3 velocity, Vector3 position)
+        {
+            target.velocity = velocity;
+            target.position = position;
+            targetVelocity = velocity;
+            targetPosition = position;
+        }
+
+        void FixedUpdate()
+        {
+            if (IgnoreSync) { return; }
+
+            target.velocity = Vector3.Lerp(target.velocity, targetVelocity, lerpVelocityAmount);
+            target.position = Vector3.Lerp(target.position, targetPosition, lerpPositionAmount);
+            // add velocity to position as position would have moved on server at that velocity
+            target.position += target.velocity * Time.fixedDeltaTime;
+
+            // TODO does this also need to sync acceleration so and update velocity?
+        }
+    }
+}

Assets/Mirror/Components/Experimental/NetworkLerpRigidbody.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7f032128052c95a46afb0ddd97d994cc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Experimental/NetworkRigidbody.cs

@@ -0,0 +1,361 @@
+using UnityEngine;
+
+namespace Mirror.Experimental
+{
+    [AddComponentMenu("Network/ Experimental/Network Rigidbody")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-rigidbody")]
+    public class NetworkRigidbody : NetworkBehaviour
+    {
+        [Header("Settings")]
+        [SerializeField] internal Rigidbody target = null;
+
+        [Tooltip("Set to true if moves come from owner client, set to false if moves always come from server")]
+        public bool clientAuthority = false;
+
+        [Header("Velocity")]
+
+        [Tooltip("Syncs Velocity every SyncInterval")]
+        [SerializeField] bool syncVelocity = true;
+
+        [Tooltip("Set velocity to 0 each frame (only works if syncVelocity is false")]
+        [SerializeField] bool clearVelocity = false;
+
+        [Tooltip("Only Syncs Value if distance between previous and current is great than sensitivity")]
+        [SerializeField] float velocitySensitivity = 0.1f;
+
+
+        [Header("Angular Velocity")]
+
+        [Tooltip("Syncs AngularVelocity every SyncInterval")]
+        [SerializeField] bool syncAngularVelocity = true;
+
+        [Tooltip("Set angularVelocity to 0 each frame (only works if syncAngularVelocity is false")]
+        [SerializeField] bool clearAngularVelocity = false;
+
+        [Tooltip("Only Syncs Value if distance between previous and current is great than sensitivity")]
+        [SerializeField] float angularVelocitySensitivity = 0.1f;
+
+        /// <summary>
+        /// Values sent on client with authority after they are sent to the server
+        /// </summary>
+        readonly ClientSyncState previousValue = new ClientSyncState();
+
+        void OnValidate()
+        {
+            if (target == null)
+            {
+                target = GetComponent<Rigidbody>();
+            }
+        }
+
+
+        #region Sync vars
+        [SyncVar(hook = nameof(OnVelocityChanged))]
+        Vector3 velocity;
+
+        [SyncVar(hook = nameof(OnAngularVelocityChanged))]
+        Vector3 angularVelocity;
+
+        [SyncVar(hook = nameof(OnIsKinematicChanged))]
+        bool isKinematic;
+
+        [SyncVar(hook = nameof(OnUseGravityChanged))]
+        bool useGravity;
+
+        [SyncVar(hook = nameof(OnuDragChanged))]
+        float drag;
+
+        [SyncVar(hook = nameof(OnAngularDragChanged))]
+        float angularDrag;
+
+        /// <summary>
+        /// Ignore value if is host or client with Authority
+        /// </summary>
+        /// <returns></returns>
+        bool IgnoreSync => isServer || ClientWithAuthority;
+
+        bool ClientWithAuthority => clientAuthority && hasAuthority;
+
+        void OnVelocityChanged(Vector3 _, Vector3 newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.velocity = newValue;
+        }
+
+
+        void OnAngularVelocityChanged(Vector3 _, Vector3 newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.angularVelocity = newValue;
+        }
+
+        void OnIsKinematicChanged(bool _, bool newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.isKinematic = newValue;
+        }
+
+        void OnUseGravityChanged(bool _, bool newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.useGravity = newValue;
+        }
+
+        void OnuDragChanged(float _, float newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.drag = newValue;
+        }
+
+        void OnAngularDragChanged(float _, float newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.angularDrag = newValue;
+        }
+        #endregion
+
+
+        internal void Update()
+        {
+            if (isServer)
+            {
+                SyncToClients();
+            }
+            else if (ClientWithAuthority)
+            {
+                SendToServer();
+            }
+        }
+
+        internal void FixedUpdate()
+        {
+            if (clearAngularVelocity && !syncAngularVelocity)
+            {
+                target.angularVelocity = Vector3.zero;
+            }
+
+            if (clearVelocity && !syncVelocity)
+            {
+                target.velocity = Vector3.zero;
+            }
+        }
+
+        /// <summary>
+        /// Updates sync var values on server so that they sync to the client
+        /// </summary>
+        [Server]
+        void SyncToClients()
+        {
+            // only update if they have changed more than Sensitivity
+
+            Vector3 currentVelocity = syncVelocity ? target.velocity : default;
+            Vector3 currentAngularVelocity = syncAngularVelocity ? target.angularVelocity : default;
+
+            bool velocityChanged = syncVelocity && ((previousValue.velocity - currentVelocity).sqrMagnitude > velocitySensitivity * velocitySensitivity);
+            bool angularVelocityChanged = syncAngularVelocity && ((previousValue.angularVelocity - currentAngularVelocity).sqrMagnitude > angularVelocitySensitivity * angularVelocitySensitivity);
+
+            if (velocityChanged)
+            {
+                velocity = currentVelocity;
+                previousValue.velocity = currentVelocity;
+            }
+
+            if (angularVelocityChanged)
+            {
+                angularVelocity = currentAngularVelocity;
+                previousValue.angularVelocity = currentAngularVelocity;
+            }
+
+            // other rigidbody settings
+            isKinematic = target.isKinematic;
+            useGravity = target.useGravity;
+            drag = target.drag;
+            angularDrag = target.angularDrag;
+        }
+
+        /// <summary>
+        /// Uses Command to send values to server
+        /// </summary>
+        [Client]
+        void SendToServer()
+        {
+            if (!hasAuthority)
+            {
+                Debug.LogWarning("SendToServer called without authority");
+                return;
+            }
+
+            SendVelocity();
+            SendRigidBodySettings();
+        }
+
+        [Client]
+        void SendVelocity()
+        {
+            float now = Time.time;
+            if (now < previousValue.nextSyncTime)
+                return;
+
+            Vector3 currentVelocity = syncVelocity ? target.velocity : default;
+            Vector3 currentAngularVelocity = syncAngularVelocity ? target.angularVelocity : default;
+
+            bool velocityChanged = syncVelocity && ((previousValue.velocity - currentVelocity).sqrMagnitude > velocitySensitivity * velocitySensitivity);
+            bool angularVelocityChanged = syncAngularVelocity && ((previousValue.angularVelocity - currentAngularVelocity).sqrMagnitude > angularVelocitySensitivity * angularVelocitySensitivity);
+
+            // if angularVelocity has changed it is likely that velocity has also changed so just sync both values
+            // however if only velocity has changed just send velocity
+            if (angularVelocityChanged)
+            {
+                CmdSendVelocityAndAngular(currentVelocity, currentAngularVelocity);
+                previousValue.velocity = currentVelocity;
+                previousValue.angularVelocity = currentAngularVelocity;
+            }
+            else if (velocityChanged)
+            {
+                CmdSendVelocity(currentVelocity);
+                previousValue.velocity = currentVelocity;
+            }
+
+
+            // only update syncTime if either has changed
+            if (angularVelocityChanged || velocityChanged)
+            {
+                previousValue.nextSyncTime = now + syncInterval;
+            }
+        }
+
+        [Client]
+        void SendRigidBodySettings()
+        {
+            // These shouldn't change often so it is ok to send in their own Command
+            if (previousValue.isKinematic != target.isKinematic)
+            {
+                CmdSendIsKinematic(target.isKinematic);
+                previousValue.isKinematic = target.isKinematic;
+            }
+            if (previousValue.useGravity != target.useGravity)
+            {
+                CmdSendUseGravity(target.useGravity);
+                previousValue.useGravity = target.useGravity;
+            }
+            if (previousValue.drag != target.drag)
+            {
+                CmdSendDrag(target.drag);
+                previousValue.drag = target.drag;
+            }
+            if (previousValue.angularDrag != target.angularDrag)
+            {
+                CmdSendAngularDrag(target.angularDrag);
+                previousValue.angularDrag = target.angularDrag;
+            }
+        }
+
+        /// <summary>
+        /// Called when only Velocity has changed on the client
+        /// </summary>
+        [Command]
+        void CmdSendVelocity(Vector3 velocity)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.velocity = velocity;
+            target.velocity = velocity;
+        }
+
+        /// <summary>
+        /// Called when angularVelocity has changed on the client
+        /// </summary>
+        [Command]
+        void CmdSendVelocityAndAngular(Vector3 velocity, Vector3 angularVelocity)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            if (syncVelocity)
+            {
+                this.velocity = velocity;
+
+                target.velocity = velocity;
+
+            }
+            this.angularVelocity = angularVelocity;
+            target.angularVelocity = angularVelocity;
+        }
+
+        [Command]
+        void CmdSendIsKinematic(bool isKinematic)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.isKinematic = isKinematic;
+            target.isKinematic = isKinematic;
+        }
+
+        [Command]
+        void CmdSendUseGravity(bool useGravity)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.useGravity = useGravity;
+            target.useGravity = useGravity;
+        }
+
+        [Command]
+        void CmdSendDrag(float drag)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.drag = drag;
+            target.drag = drag;
+        }
+
+        [Command]
+        void CmdSendAngularDrag(float angularDrag)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.angularDrag = angularDrag;
+            target.angularDrag = angularDrag;
+        }
+
+        /// <summary>
+        /// holds previously synced values
+        /// </summary>
+        public class ClientSyncState
+        {
+            /// <summary>
+            /// Next sync time that velocity will be synced, based on syncInterval.
+            /// </summary>
+            public float nextSyncTime;
+            public Vector3 velocity;
+            public Vector3 angularVelocity;
+            public bool isKinematic;
+            public bool useGravity;
+            public float drag;
+            public float angularDrag;
+        }
+    }
+}

Assets/Mirror/Components/Experimental/NetworkRigidbody.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 83392ae5c1b731446909f252fd494ae4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Experimental/NetworkRigidbody2D.cs

@@ -0,0 +1,360 @@
+using UnityEngine;
+
+namespace Mirror.Experimental
+{
+    [AddComponentMenu("Network/ Experimental/Network Rigidbody 2D")]
+    public class NetworkRigidbody2D : NetworkBehaviour
+    {
+        [Header("Settings")]
+        [SerializeField] internal Rigidbody2D target = null;
+
+        [Tooltip("Set to true if moves come from owner client, set to false if moves always come from server")]
+        public  bool clientAuthority = false;
+
+        [Header("Velocity")]
+
+        [Tooltip("Syncs Velocity every SyncInterval")]
+        [SerializeField] bool syncVelocity = true;
+
+        [Tooltip("Set velocity to 0 each frame (only works if syncVelocity is false")]
+        [SerializeField] bool clearVelocity = false;
+
+        [Tooltip("Only Syncs Value if distance between previous and current is great than sensitivity")]
+        [SerializeField] float velocitySensitivity = 0.1f;
+
+
+        [Header("Angular Velocity")]
+
+        [Tooltip("Syncs AngularVelocity every SyncInterval")]
+        [SerializeField] bool syncAngularVelocity = true;
+
+        [Tooltip("Set angularVelocity to 0 each frame (only works if syncAngularVelocity is false")]
+        [SerializeField] bool clearAngularVelocity = false;
+
+        [Tooltip("Only Syncs Value if distance between previous and current is great than sensitivity")]
+        [SerializeField] float angularVelocitySensitivity = 0.1f;
+
+        /// <summary>
+        /// Values sent on client with authority after they are sent to the server
+        /// </summary>
+        readonly ClientSyncState previousValue = new ClientSyncState();
+
+        void OnValidate()
+        {
+            if (target == null)
+            {
+                target = GetComponent<Rigidbody2D>();
+            }
+        }
+
+
+        #region Sync vars
+        [SyncVar(hook = nameof(OnVelocityChanged))]
+        Vector2 velocity;
+
+        [SyncVar(hook = nameof(OnAngularVelocityChanged))]
+        float angularVelocity;
+
+        [SyncVar(hook = nameof(OnIsKinematicChanged))]
+        bool isKinematic;
+
+        [SyncVar(hook = nameof(OnGravityScaleChanged))]
+        float gravityScale;
+
+        [SyncVar(hook = nameof(OnuDragChanged))]
+        float drag;
+
+        [SyncVar(hook = nameof(OnAngularDragChanged))]
+        float angularDrag;
+
+        /// <summary>
+        /// Ignore value if is host or client with Authority
+        /// </summary>
+        /// <returns></returns>
+        bool IgnoreSync => isServer || ClientWithAuthority;
+
+        bool ClientWithAuthority => clientAuthority && hasAuthority;
+
+        void OnVelocityChanged(Vector2 _, Vector2 newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.velocity = newValue;
+        }
+
+
+        void OnAngularVelocityChanged(float _, float newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.angularVelocity = newValue;
+        }
+
+        void OnIsKinematicChanged(bool _, bool newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.isKinematic = newValue;
+        }
+
+        void OnGravityScaleChanged(float _, float newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.gravityScale = newValue;
+        }
+
+        void OnuDragChanged(float _, float newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.drag = newValue;
+        }
+
+        void OnAngularDragChanged(float _, float newValue)
+        {
+            if (IgnoreSync)
+                return;
+
+            target.angularDrag = newValue;
+        }
+        #endregion
+
+
+        internal void Update()
+        {
+            if (isServer)
+            {
+                SyncToClients();
+            }
+            else if (ClientWithAuthority)
+            {
+                SendToServer();
+            }
+        }
+
+        internal void FixedUpdate()
+        {
+            if (clearAngularVelocity && !syncAngularVelocity)
+            {
+                target.angularVelocity = 0f;
+            }
+
+            if (clearVelocity && !syncVelocity)
+            {
+                target.velocity = Vector2.zero;
+            }
+        }
+
+        /// <summary>
+        /// Updates sync var values on server so that they sync to the client
+        /// </summary>
+        [Server]
+        void SyncToClients()
+        {
+            // only update if they have changed more than Sensitivity
+
+            Vector2 currentVelocity = syncVelocity ? target.velocity : default;
+            float currentAngularVelocity = syncAngularVelocity ? target.angularVelocity : default;
+
+            bool velocityChanged = syncVelocity && ((previousValue.velocity - currentVelocity).sqrMagnitude > velocitySensitivity * velocitySensitivity);
+            bool angularVelocityChanged = syncAngularVelocity && ((previousValue.angularVelocity - currentAngularVelocity) > angularVelocitySensitivity);
+
+            if (velocityChanged)
+            {
+                velocity = currentVelocity;
+                previousValue.velocity = currentVelocity;
+            }
+
+            if (angularVelocityChanged)
+            {
+                angularVelocity = currentAngularVelocity;
+                previousValue.angularVelocity = currentAngularVelocity;
+            }
+
+            // other rigidbody settings
+            isKinematic = target.isKinematic;
+            gravityScale = target.gravityScale;
+            drag = target.drag;
+            angularDrag = target.angularDrag;
+        }
+
+        /// <summary>
+        /// Uses Command to send values to server
+        /// </summary>
+        [Client]
+        void SendToServer()
+        {
+            if (!hasAuthority)
+            {
+                Debug.LogWarning("SendToServer called without authority");
+                return;
+            }
+
+            SendVelocity();
+            SendRigidBodySettings();
+        }
+
+        [Client]
+        void SendVelocity()
+        {
+            float now = Time.time;
+            if (now < previousValue.nextSyncTime)
+                return;
+
+            Vector2 currentVelocity = syncVelocity ? target.velocity : default;
+            float currentAngularVelocity = syncAngularVelocity ? target.angularVelocity : default;
+
+            bool velocityChanged = syncVelocity && ((previousValue.velocity - currentVelocity).sqrMagnitude > velocitySensitivity * velocitySensitivity);
+            bool angularVelocityChanged = syncAngularVelocity && previousValue.angularVelocity != currentAngularVelocity;//((previousValue.angularVelocity - currentAngularVelocity).sqrMagnitude > angularVelocitySensitivity * angularVelocitySensitivity);
+
+            // if angularVelocity has changed it is likely that velocity has also changed so just sync both values
+            // however if only velocity has changed just send velocity
+            if (angularVelocityChanged)
+            {
+                CmdSendVelocityAndAngular(currentVelocity, currentAngularVelocity);
+                previousValue.velocity = currentVelocity;
+                previousValue.angularVelocity = currentAngularVelocity;
+            }
+            else if (velocityChanged)
+            {
+                CmdSendVelocity(currentVelocity);
+                previousValue.velocity = currentVelocity;
+            }
+
+
+            // only update syncTime if either has changed
+            if (angularVelocityChanged || velocityChanged)
+            {
+                previousValue.nextSyncTime = now + syncInterval;
+            }
+        }
+
+        [Client]
+        void SendRigidBodySettings()
+        {
+            // These shouldn't change often so it is ok to send in their own Command
+            if (previousValue.isKinematic != target.isKinematic)
+            {
+                CmdSendIsKinematic(target.isKinematic);
+                previousValue.isKinematic = target.isKinematic;
+            }
+            if (previousValue.gravityScale != target.gravityScale)
+            {
+                CmdChangeGravityScale(target.gravityScale);
+                previousValue.gravityScale = target.gravityScale;
+            }
+            if (previousValue.drag != target.drag)
+            {
+                CmdSendDrag(target.drag);
+                previousValue.drag = target.drag;
+            }
+            if (previousValue.angularDrag != target.angularDrag)
+            {
+                CmdSendAngularDrag(target.angularDrag);
+                previousValue.angularDrag = target.angularDrag;
+            }
+        }
+
+        /// <summary>
+        /// Called when only Velocity has changed on the client
+        /// </summary>
+        [Command]
+        void CmdSendVelocity(Vector2 velocity)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.velocity = velocity;
+            target.velocity = velocity;
+        }
+
+        /// <summary>
+        /// Called when angularVelocity has changed on the client
+        /// </summary>
+        [Command]
+        void CmdSendVelocityAndAngular(Vector2 velocity, float angularVelocity)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            if (syncVelocity)
+            {
+                this.velocity = velocity;
+
+                target.velocity = velocity;
+
+            }
+            this.angularVelocity = angularVelocity;
+            target.angularVelocity = angularVelocity;
+        }
+
+        [Command]
+        void CmdSendIsKinematic(bool isKinematic)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.isKinematic = isKinematic;
+            target.isKinematic = isKinematic;
+        }
+
+        [Command]
+        void CmdChangeGravityScale(float gravityScale)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.gravityScale = gravityScale;
+            target.gravityScale = gravityScale;
+        }
+
+        [Command]
+        void CmdSendDrag(float drag)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.drag = drag;
+            target.drag = drag;
+        }
+
+        [Command]
+        void CmdSendAngularDrag(float angularDrag)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            this.angularDrag = angularDrag;
+            target.angularDrag = angularDrag;
+        }
+
+        /// <summary>
+        /// holds previously synced values
+        /// </summary>
+        public class ClientSyncState
+        {
+            /// <summary>
+            /// Next sync time that velocity will be synced, based on syncInterval.
+            /// </summary>
+            public float nextSyncTime;
+            public Vector2 velocity;
+            public float angularVelocity;
+            public bool isKinematic;
+            public float gravityScale;
+            public float drag;
+            public float angularDrag;
+        }
+    }
+}

Assets/Mirror/Components/Experimental/NetworkRigidbody2D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ab2cbc52526ea384ba280d13cd1a57b9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/GUIConsole.cs

@@ -0,0 +1,115 @@
+// People should be able to see and report errors to the developer very easily.
+//
+// Unity's Developer Console only works in development builds and it only shows
+// errors. This class provides a console that works in all builds and also shows
+// log and warnings in development builds.
+//
+// Note: we don't include the stack trace, because that can also be grabbed from
+// the log files if needed.
+//
+// Note: there is no 'hide' button because we DO want people to see those errors
+// and report them back to us.
+//
+// Note: normal Debug.Log messages can be shown by building in Debug/Development
+//       mode.
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Mirror
+{
+    struct LogEntry
+    {
+        public string message;
+        public LogType type;
+
+        public LogEntry(string message, LogType type)
+        {
+            this.message = message;
+            this.type = type;
+        }
+    }
+
+    public class GUIConsole : MonoBehaviour
+    {
+        public int height = 150;
+
+        // only keep the recent 'n' entries. otherwise memory would grow forever
+        // and drawing would get slower and slower.
+        public int maxLogCount = 50;
+
+        // log as queue so we can remove the first entry easily
+        Queue<LogEntry> log = new Queue<LogEntry>();
+
+        // hotkey to show/hide at runtime for easier debugging
+        // (sometimes we need to temporarily hide/show it)
+        // => F12 makes sense. nobody can find ^ in other games.
+        public KeyCode hotKey = KeyCode.F12;
+
+        // GUI
+        bool visible;
+        Vector2 scroll = Vector2.zero;
+
+        void Awake()
+        {
+            Application.logMessageReceived += OnLog;
+        }
+
+        // OnLog logs everything, even Debug.Log messages in release builds
+        // => this makes a lot of things easier. e.g. addon initialization logs.
+        // => it's really better to have than not to have those
+        void OnLog(string message, string stackTrace, LogType type)
+        {
+            // is this important?
+            // => always show exceptions & errors
+            // => usually a good idea to show warnings too, otherwise it's too
+            //    easy to miss OnDeserialize warnings etc. in builds
+            bool isImportant = type == LogType.Error || type == LogType.Exception || type == LogType.Warning;
+
+            // use stack trace only if important
+            // (otherwise users would have to find and search the log file.
+            //  seeing it in the console directly is way easier to deal with.)
+            // => only add \n if stack trace is available (only in debug builds)
+            if (isImportant && !string.IsNullOrWhiteSpace(stackTrace))
+                message += $"\n{stackTrace}";
+
+            // add to queue
+            log.Enqueue(new LogEntry(message, type));
+
+            // respect max entries
+            if (log.Count > maxLogCount)
+                log.Dequeue();
+
+            // become visible if it was important
+            // (no need to become visible for regular log. let the user decide.)
+            if (isImportant)
+                visible = true;
+
+            // auto scroll
+            scroll.y = float.MaxValue;
+        }
+
+        void Update()
+        {
+            if (Input.GetKeyDown(hotKey))
+                visible = !visible;
+        }
+
+        void OnGUI()
+        {
+            if (!visible) return;
+
+            scroll = GUILayout.BeginScrollView(scroll, "Box", GUILayout.Width(Screen.width), GUILayout.Height(height));
+            foreach (LogEntry entry in log)
+            {
+                if (entry.type == LogType.Error || entry.type == LogType.Exception)
+                    GUI.color = Color.red;
+                else if (entry.type == LogType.Warning)
+                    GUI.color = Color.yellow;
+
+                GUILayout.Label(entry.message);
+                GUI.color = Color.white;
+            }
+            GUILayout.EndScrollView();
+        }
+    }
+}

Assets/Mirror/Components/GUIConsole.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9021b6cc314944290986ab6feb48db79
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c66f27e006ab94253b39a55a3b213651
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/Distance.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fa4cbc6b9c584db4971985cb9f369077
+timeCreated: 1613110605

Assets/Mirror/Components/InterestManagement/Distance/DistanceInterestManagement.cs

@@ -0,0 +1,74 @@
+// straight forward Vector3.Distance based interest management.
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Distance/Distance Interest Management")]
+    public class DistanceInterestManagement : InterestManagement
+    {
+        [Tooltip("The maximum range that objects will be visible at. Add DistanceInterestManagementCustomRange onto NetworkIdentities for custom ranges.")]
+        public int visRange = 10;
+
+        [Tooltip("Rebuild all every 'rebuildInterval' seconds.")]
+        public float rebuildInterval = 1;
+        double lastRebuildTime;
+
+        // helper function to get vis range for a given object, or default.
+        int GetVisRange(NetworkIdentity identity)
+        {
+            return identity.TryGetComponent(out DistanceInterestManagementCustomRange custom) ? custom.visRange : visRange;
+        }
+
+        [ServerCallback]
+        public override void Reset()
+        {
+            lastRebuildTime = 0D;
+        }
+
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            int range = GetVisRange(identity);
+            return Vector3.Distance(identity.transform.position, newObserver.identity.transform.position) < range;
+        }
+
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            // cache range and .transform because both call GetComponent.
+            int range = GetVisRange(identity);
+            Vector3 position = identity.transform.position;
+
+            // brute force distance check
+            // -> only player connections can be observers, so it's enough if we
+            //    go through all connections instead of all spawned identities.
+            // -> compared to UNET's sphere cast checking, this one is orders of
+            //    magnitude faster. if we have 10k monsters and run a sphere
+            //    cast 10k times, we will see a noticeable lag even with physics
+            //    layers. but checking to every connection is fast.
+            foreach (NetworkConnectionToClient conn in NetworkServer.connections.Values)
+            {
+                // authenticated and joined world with a player?
+                if (conn != null && conn.isAuthenticated && conn.identity != null)
+                {
+                    // check distance
+                    if (Vector3.Distance(conn.identity.transform.position, position) < range)
+                    {
+                        newObservers.Add(conn);
+                    }
+                }
+            }
+        }
+
+        // internal so we can update from tests
+        [ServerCallback]
+        internal void Update()
+        {
+            // rebuild all spawned NetworkIdentity's observers every interval
+            if (NetworkTime.localTime >= lastRebuildTime + rebuildInterval)
+            {
+                RebuildAll();
+                lastRebuildTime = NetworkTime.localTime;
+            }
+        }
+    }
+}

Assets/Mirror/Components/InterestManagement/Distance/DistanceInterestManagement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8f60becab051427fbdd3c8ac9ab4712b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/Distance/DistanceInterestManagementCustomRange.cs

@@ -0,0 +1,15 @@
+// add this to NetworkIdentities for custom range if needed.
+// only works with DistanceInterestManagement.
+using UnityEngine;
+
+namespace Mirror
+{
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/ Interest Management/ Distance/Distance Custom Range")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/guides/interest-management")]
+    public class DistanceInterestManagementCustomRange : NetworkBehaviour
+    {
+        [Tooltip("The maximum range that objects will be visible at.")]
+        public int visRange = 20;
+    }
+}

Assets/Mirror/Components/InterestManagement/Distance/DistanceInterestManagementCustomRange.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b2e242ee38a14076a39934172a19079b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/Match.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5eca5245ae6bb460e9a92f7e14d5493a
+timeCreated: 1622649517

Assets/Mirror/Components/InterestManagement/Match/MatchInterestManagement.cs

@@ -0,0 +1,160 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Match/Match Interest Management")]
+    public class MatchInterestManagement : InterestManagement
+    {
+        readonly Dictionary<Guid, HashSet<NetworkIdentity>> matchObjects =
+            new Dictionary<Guid, HashSet<NetworkIdentity>>();
+
+        readonly Dictionary<NetworkIdentity, Guid> lastObjectMatch =
+            new Dictionary<NetworkIdentity, Guid>();
+
+        readonly HashSet<Guid> dirtyMatches = new HashSet<Guid>();
+
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            if (!identity.TryGetComponent<NetworkMatch>(out NetworkMatch networkMatch))
+                return;
+
+            Guid currentMatch = networkMatch.matchId;
+            lastObjectMatch[identity] = currentMatch;
+
+            // Guid.Empty is never a valid matchId...do not add to matchObjects collection
+            if (currentMatch == Guid.Empty)
+                return;
+
+            // Debug.Log($"MatchInterestManagement.OnSpawned({identity.name}) currentMatch: {currentMatch}");
+            if (!matchObjects.TryGetValue(currentMatch, out HashSet<NetworkIdentity> objects))
+            {
+                objects = new HashSet<NetworkIdentity>();
+                matchObjects.Add(currentMatch, objects);
+            }
+
+            objects.Add(identity);
+        }
+
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            lastObjectMatch.TryGetValue(identity, out Guid currentMatch);
+            lastObjectMatch.Remove(identity);
+            if (currentMatch != Guid.Empty && matchObjects.TryGetValue(currentMatch, out HashSet<NetworkIdentity> objects) && objects.Remove(identity))
+                RebuildMatchObservers(currentMatch);
+        }
+
+        // internal so we can update from tests
+        [ServerCallback]
+        internal void Update()
+        {
+            // for each spawned:
+            //   if match changed:
+            //     add previous to dirty
+            //     add new to dirty
+            foreach (NetworkIdentity netIdentity in NetworkServer.spawned.Values)
+            {
+                // Ignore objects that don't have a NetworkMatch component
+                if (!netIdentity.TryGetComponent<NetworkMatch>(out NetworkMatch networkMatch))
+                    continue;
+
+                Guid newMatch = networkMatch.matchId;
+                lastObjectMatch.TryGetValue(netIdentity, out Guid currentMatch);
+
+                // Guid.Empty is never a valid matchId
+                // Nothing to do if matchId hasn't changed
+                if (newMatch == Guid.Empty || newMatch == currentMatch)
+                    continue;
+
+                // Mark new/old matches as dirty so they get rebuilt
+                UpdateDirtyMatches(newMatch, currentMatch);
+
+                // This object is in a new match so observers in the prior match
+                // and the new match need to rebuild their respective observers lists.
+                UpdateMatchObjects(netIdentity, newMatch, currentMatch);
+            }
+
+            // rebuild all dirty matchs
+            foreach (Guid dirtyMatch in dirtyMatches)
+                RebuildMatchObservers(dirtyMatch);
+
+            dirtyMatches.Clear();
+        }
+
+        void UpdateDirtyMatches(Guid newMatch, Guid currentMatch)
+        {
+            // Guid.Empty is never a valid matchId
+            if (currentMatch != Guid.Empty)
+                dirtyMatches.Add(currentMatch);
+
+            dirtyMatches.Add(newMatch);
+        }
+
+        void UpdateMatchObjects(NetworkIdentity netIdentity, Guid newMatch, Guid currentMatch)
+        {
+            // Remove this object from the hashset of the match it just left
+            // Guid.Empty is never a valid matchId
+            if (currentMatch != Guid.Empty)
+                matchObjects[currentMatch].Remove(netIdentity);
+
+            // Set this to the new match this object just entered
+            lastObjectMatch[netIdentity] = newMatch;
+
+            // Make sure this new match is in the dictionary
+            if (!matchObjects.ContainsKey(newMatch))
+                matchObjects.Add(newMatch, new HashSet<NetworkIdentity>());
+
+            // Add this object to the hashset of the new match
+            matchObjects[newMatch].Add(netIdentity);
+        }
+
+        void RebuildMatchObservers(Guid matchId)
+        {
+            foreach (NetworkIdentity netIdentity in matchObjects[matchId])
+                if (netIdentity != null)
+                    NetworkServer.RebuildObservers(netIdentity, false);
+        }
+
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            // Never observed if no NetworkMatch component
+            if (!identity.TryGetComponent<NetworkMatch>(out NetworkMatch identityNetworkMatch))
+                return false;
+
+            // Guid.Empty is never a valid matchId
+            if (identityNetworkMatch.matchId == Guid.Empty)
+                return false;
+
+            // Never observed if no NetworkMatch component
+            if (!newObserver.identity.TryGetComponent<NetworkMatch>(out NetworkMatch newObserverNetworkMatch))
+                return false;
+
+            // Guid.Empty is never a valid matchId
+            if (newObserverNetworkMatch.matchId == Guid.Empty)
+                return false;
+
+            return identityNetworkMatch.matchId == newObserverNetworkMatch.matchId;
+        }
+
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            if (!identity.TryGetComponent<NetworkMatch>(out NetworkMatch networkMatch))
+                return;
+
+            Guid matchId = networkMatch.matchId;
+
+            // Guid.Empty is never a valid matchId
+            if (matchId == Guid.Empty)
+                return;
+
+            if (!matchObjects.TryGetValue(matchId, out HashSet<NetworkIdentity> objects))
+                return;
+
+            // Add everything in the hashset for this object's current match
+            foreach (NetworkIdentity networkIdentity in objects)
+                if (networkIdentity != null && networkIdentity.connectionToClient != null)
+                    newObservers.Add(networkIdentity.connectionToClient);
+        }
+    }
+}

Assets/Mirror/Components/InterestManagement/Match/MatchInterestManagement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d09f5c8bf2f4747b7a9284ef5d9ce2a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/Match/NetworkMatch.cs

@@ -0,0 +1,15 @@
+// simple component that holds match information
+using System;
+using UnityEngine;
+
+namespace Mirror
+{
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/ Interest Management/ Match/Network Match")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/guides/interest-management")]
+    public class NetworkMatch : NetworkBehaviour
+    {
+        ///<summary>Set this to the same value on all networked objects that belong to a given match</summary>
+        public Guid matchId;
+    }
+}

Assets/Mirror/Components/InterestManagement/Match/NetworkMatch.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5d17e718851449a6879986e45c458fb7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/Scene.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7655d309a46a4bd4860edf964228b3f6
+timeCreated: 1622649517

Assets/Mirror/Components/InterestManagement/Scene/SceneInterestManagement.cs

@@ -0,0 +1,108 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Scene/Scene Interest Management")]
+    public class SceneInterestManagement : InterestManagement
+    {
+        // Use Scene instead of string scene.name because when additively
+        // loading multiples of a subscene the name won't be unique
+        readonly Dictionary<Scene, HashSet<NetworkIdentity>> sceneObjects =
+            new Dictionary<Scene, HashSet<NetworkIdentity>>();
+
+        readonly Dictionary<NetworkIdentity, Scene> lastObjectScene =
+            new Dictionary<NetworkIdentity, Scene>();
+
+        HashSet<Scene> dirtyScenes = new HashSet<Scene>();
+
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            Scene currentScene = identity.gameObject.scene;
+            lastObjectScene[identity] = currentScene;
+            // Debug.Log($"SceneInterestManagement.OnSpawned({identity.name}) currentScene: {currentScene}");
+            if (!sceneObjects.TryGetValue(currentScene, out HashSet<NetworkIdentity> objects))
+            {
+                objects = new HashSet<NetworkIdentity>();
+                sceneObjects.Add(currentScene, objects);
+            }
+
+            objects.Add(identity);
+        }
+
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            Scene currentScene = lastObjectScene[identity];
+            lastObjectScene.Remove(identity);
+            if (sceneObjects.TryGetValue(currentScene, out HashSet<NetworkIdentity> objects) && objects.Remove(identity))
+                RebuildSceneObservers(currentScene);
+        }
+
+        // internal so we can update from tests
+        [ServerCallback]
+        internal void Update()
+        {
+            // for each spawned:
+            //   if scene changed:
+            //     add previous to dirty
+            //     add new to dirty
+            foreach (NetworkIdentity identity in NetworkServer.spawned.Values)
+            {
+                Scene currentScene = lastObjectScene[identity];
+                Scene newScene = identity.gameObject.scene;
+                if (newScene == currentScene)
+                    continue;
+
+                // Mark new/old scenes as dirty so they get rebuilt
+                dirtyScenes.Add(currentScene);
+                dirtyScenes.Add(newScene);
+
+                // This object is in a new scene so observers in the prior scene
+                // and the new scene need to rebuild their respective observers lists.
+
+                // Remove this object from the hashset of the scene it just left
+                sceneObjects[currentScene].Remove(identity);
+
+                // Set this to the new scene this object just entered
+                lastObjectScene[identity] = newScene;
+
+                // Make sure this new scene is in the dictionary
+                if (!sceneObjects.ContainsKey(newScene))
+                    sceneObjects.Add(newScene, new HashSet<NetworkIdentity>());
+
+                // Add this object to the hashset of the new scene
+                sceneObjects[newScene].Add(identity);
+            }
+
+            // rebuild all dirty scenes
+            foreach (Scene dirtyScene in dirtyScenes)
+                RebuildSceneObservers(dirtyScene);
+
+            dirtyScenes.Clear();
+        }
+
+        void RebuildSceneObservers(Scene scene)
+        {
+            foreach (NetworkIdentity netIdentity in sceneObjects[scene])
+                if (netIdentity != null)
+                    NetworkServer.RebuildObservers(netIdentity, false);
+        }
+
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            return identity.gameObject.scene == newObserver.identity.gameObject.scene;
+        }
+
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            if (!sceneObjects.TryGetValue(identity.gameObject.scene, out HashSet<NetworkIdentity> objects))
+                return;
+
+            // Add everything in the hashset for this object's current scene
+            foreach (NetworkIdentity networkIdentity in objects)
+                if (networkIdentity != null && networkIdentity.connectionToClient != null)
+                    newObservers.Add(networkIdentity.connectionToClient);
+        }
+    }
+}

Assets/Mirror/Components/InterestManagement/Scene/SceneInterestManagement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b979f26c95d34324ba005bfacfa9c4fc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/SpatialHashing.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cfa12b73503344d49b398b01bcb07967
+timeCreated: 1613110634

Assets/Mirror/Components/InterestManagement/SpatialHashing/Grid2D.cs

@@ -0,0 +1,88 @@
+// Grid2D from uMMORPG: get/set values of type T at any point
+// -> not named 'Grid' because Unity already has a Grid type. causes warnings.
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    public class Grid2D<T>
+    {
+        // the grid
+        // note that we never remove old keys.
+        // => over time, HashSet<T>s will be allocated for every possible
+        //    grid position in the world
+        // => Clear() doesn't clear them so we don't constantly reallocate the
+        //    entries when populating the grid in every Update() call
+        // => makes the code a lot easier too
+        // => this is FINE because in the worst case, every grid position in the
+        //    game world is filled with a player anyway!
+        Dictionary<Vector2Int, HashSet<T>> grid = new Dictionary<Vector2Int, HashSet<T>>();
+
+        // cache a 9 neighbor grid of vector2 offsets so we can use them more easily
+        Vector2Int[] neighbourOffsets =
+        {
+            Vector2Int.up,
+            Vector2Int.up + Vector2Int.left,
+            Vector2Int.up + Vector2Int.right,
+            Vector2Int.left,
+            Vector2Int.zero,
+            Vector2Int.right,
+            Vector2Int.down,
+            Vector2Int.down + Vector2Int.left,
+            Vector2Int.down + Vector2Int.right
+        };
+
+        // helper function so we can add an entry without worrying
+        public void Add(Vector2Int position, T value)
+        {
+            // initialize set in grid if it's not in there yet
+            if (!grid.TryGetValue(position, out HashSet<T> hashSet))
+            {
+                hashSet = new HashSet<T>();
+                grid[position] = hashSet;
+            }
+
+            // add to it
+            hashSet.Add(value);
+        }
+
+        // helper function to get set at position without worrying
+        // -> result is passed as parameter to avoid allocations
+        // -> result is not cleared before. this allows us to pass the HashSet from
+        //    GetWithNeighbours and avoid .UnionWith which is very expensive.
+        void GetAt(Vector2Int position, HashSet<T> result)
+        {
+            // return the set at position
+            if (grid.TryGetValue(position, out HashSet<T> hashSet))
+            {
+                foreach (T entry in hashSet)
+                    result.Add(entry);
+            }
+        }
+
+        // helper function to get at position and it's 8 neighbors without worrying
+        // -> result is passed as parameter to avoid allocations
+        public void GetWithNeighbours(Vector2Int position, HashSet<T> result)
+        {
+            // clear result first
+            result.Clear();
+
+            // add neighbours
+            foreach (Vector2Int offset in neighbourOffsets)
+                GetAt(position + offset, result);
+        }
+
+        // clear: clears the whole grid
+        // IMPORTANT: we already allocated HashSet<T>s and don't want to do
+        //            reallocate every single update when we rebuild the grid.
+        //            => so simply remove each position's entries, but keep
+        //               every position in there
+        //            => see 'grid' comments above!
+        //            => named ClearNonAlloc to make it more obvious!
+        public void ClearNonAlloc()
+        {
+            foreach (HashSet<T> hashSet in grid.Values)
+                hashSet.Clear();
+        }
+    }
+}

Assets/Mirror/Components/InterestManagement/SpatialHashing/Grid2D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c5232a4d2854116a35d52b80ec07752
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/SpatialHashing/SpatialHashingInterestManagement.cs

@@ -0,0 +1,144 @@
+// extremely fast spatial hashing interest management based on uMMORPG GridChecker.
+// => 30x faster in initial tests
+// => scales way higher
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Spatial Hash/Spatial Hashing Interest Management")]
+    public class SpatialHashingInterestManagement : InterestManagement
+    {
+        [Tooltip("The maximum range that objects will be visible at.")]
+        public int visRange = 30;
+
+        // if we see 8 neighbors then 1 entry is visRange/3
+        public int resolution => visRange / 3;
+
+        [Tooltip("Rebuild all every 'rebuildInterval' seconds.")]
+        public float rebuildInterval = 1;
+        double lastRebuildTime;
+
+        public enum CheckMethod
+        {
+            XZ_FOR_3D,
+            XY_FOR_2D
+        }
+        [Tooltip("Spatial Hashing supports 3D (XZ) and 2D (XY) games.")]
+        public CheckMethod checkMethod = CheckMethod.XZ_FOR_3D;
+
+        // debugging
+        public bool showSlider;
+
+        // the grid
+        Grid2D<NetworkConnectionToClient> grid = new Grid2D<NetworkConnectionToClient>();
+
+        // project 3d world position to grid position
+        Vector2Int ProjectToGrid(Vector3 position) =>
+            checkMethod == CheckMethod.XZ_FOR_3D
+            ? Vector2Int.RoundToInt(new Vector2(position.x, position.z) / resolution)
+            : Vector2Int.RoundToInt(new Vector2(position.x, position.y) / resolution);
+
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            // calculate projected positions
+            Vector2Int projected = ProjectToGrid(identity.transform.position);
+            Vector2Int observerProjected = ProjectToGrid(newObserver.identity.transform.position);
+
+            // distance needs to be at max one of the 8 neighbors, which is
+            //   1 for the direct neighbors
+            //   1.41 for the diagonal neighbors (= sqrt(2))
+            // => use sqrMagnitude and '2' to avoid computations. same result.
+            return (projected - observerProjected).sqrMagnitude <= 2;
+        }
+
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            // add everyone in 9 neighbour grid
+            // -> pass observers to GetWithNeighbours directly to avoid allocations
+            //    and expensive .UnionWith computations.
+            Vector2Int current = ProjectToGrid(identity.transform.position);
+            grid.GetWithNeighbours(current, newObservers);
+        }
+
+        [ServerCallback]
+        public override void Reset()
+        {
+            lastRebuildTime = 0D;
+        }
+
+        // update everyone's position in the grid
+        // (internal so we can update from tests)
+        [ServerCallback]
+        internal void Update()
+        {
+            // NOTE: unlike Scene/MatchInterestManagement, this rebuilds ALL
+            //       entities every INTERVAL. consider the other approach later.
+
+            // IMPORTANT: refresh grid every update!
+            // => newly spawned entities get observers assigned via
+            //    OnCheckObservers. this can happen any time and we don't want
+            //    them broadcast to old (moved or destroyed) connections.
+            // => players do move all the time. we want them to always be in the
+            //    correct grid position.
+            // => note that the actual 'rebuildall' doesn't need to happen all
+            //    the time.
+            // NOTE: consider refreshing grid only every 'interval' too. but not
+            //       for now. stability & correctness matter.
+
+            // clear old grid results before we update everyone's position.
+            // (this way we get rid of destroyed connections automatically)
+            //
+            // NOTE: keeps allocated HashSets internally.
+            //       clearing & populating every frame works without allocations
+            grid.ClearNonAlloc();
+
+            // put every connection into the grid at it's main player's position
+            // NOTE: player sees in a radius around him. NOT around his pet too.
+            foreach (NetworkConnectionToClient connection in NetworkServer.connections.Values)
+            {
+                // authenticated and joined world with a player?
+                if (connection.isAuthenticated && connection.identity != null)
+                {
+                    // calculate current grid position
+                    Vector2Int position = ProjectToGrid(connection.identity.transform.position);
+
+                    // put into grid
+                    grid.Add(position, connection);
+                }
+            }
+
+            // rebuild all spawned entities' observers every 'interval'
+            // this will call OnRebuildObservers which then returns the
+            // observers at grid[position] for each entity.
+            if (NetworkTime.localTime >= lastRebuildTime + rebuildInterval)
+            {
+                RebuildAll();
+                lastRebuildTime = NetworkTime.localTime;
+            }
+        }
+
+// OnGUI allocates even if it does nothing. avoid in release.
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+        // slider from dotsnet. it's nice to play around with in the benchmark
+        // demo.
+        void OnGUI()
+        {
+            if (!showSlider) return;
+
+            // only show while server is running. not on client, etc.
+            if (!NetworkServer.active) return;
+
+            int height = 30;
+            int width = 250;
+            GUILayout.BeginArea(new Rect(Screen.width / 2 - width / 2, Screen.height - height, width, height));
+            GUILayout.BeginHorizontal("Box");
+            GUILayout.Label("Radius:");
+            visRange = Mathf.RoundToInt(GUILayout.HorizontalSlider(visRange, 0, 200, GUILayout.Width(150)));
+            GUILayout.Label(visRange.ToString());
+            GUILayout.EndHorizontal();
+            GUILayout.EndArea();
+        }
+#endif
+    }
+}

Assets/Mirror/Components/InterestManagement/SpatialHashing/SpatialHashingInterestManagement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 39adc6e09d5544ed955a50ce8600355a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/Team.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2d418e60072433b4bbebbf5f3a7de1bb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/Team/NetworkTeam.cs

@@ -0,0 +1,17 @@
+// simple component that holds team information
+using UnityEngine;
+
+namespace Mirror
+{
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/ Interest Management/ Team/Network Team")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/guides/interest-management")]
+    public class NetworkTeam : NetworkBehaviour
+    {
+        [Tooltip("Set this to the same value on all networked objects that belong to a given team")]
+        public string teamId = string.Empty;
+
+        [Tooltip("When enabled this object is visible to all clients. Typically this would be true for player objects")]
+        public bool forceShown;
+    }
+}

Assets/Mirror/Components/InterestManagement/Team/NetworkTeam.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2576730625b1632468cbcbfe5e721f88
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/InterestManagement/Team/TeamInterestManagement.cs

@@ -0,0 +1,187 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Team/Team Interest Management")]
+    public class TeamInterestManagement : InterestManagement
+    {
+        readonly Dictionary<string, HashSet<NetworkIdentity>> teamObjects =
+            new Dictionary<string, HashSet<NetworkIdentity>>();
+
+        readonly Dictionary<NetworkIdentity, string> lastObjectTeam =
+            new Dictionary<NetworkIdentity, string>();
+
+        readonly HashSet<string> dirtyTeams = new HashSet<string>();
+
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            if (!identity.TryGetComponent<NetworkTeam>(out NetworkTeam networkTeam))
+                return;
+
+            string currentTeam = networkTeam.teamId;
+            lastObjectTeam[identity] = currentTeam;
+
+            // string.Empty is never a valid teamId...do not add to teamObjects collection
+            if (currentTeam == string.Empty)
+                return;
+
+            // Debug.Log($"MatchInterestManagement.OnSpawned({identity.name}) currentMatch: {currentTeam}");
+            if (!teamObjects.TryGetValue(currentTeam, out HashSet<NetworkIdentity> objects))
+            {
+                objects = new HashSet<NetworkIdentity>();
+                teamObjects.Add(currentTeam, objects);
+            }
+
+            objects.Add(identity);
+        }
+
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            lastObjectTeam.TryGetValue(identity, out string currentTeam);
+            lastObjectTeam.Remove(identity);
+            if (currentTeam != string.Empty && teamObjects.TryGetValue(currentTeam, out HashSet<NetworkIdentity> objects) && objects.Remove(identity))
+                RebuildTeamObservers(currentTeam);
+        }
+
+        // internal so we can update from tests
+        [ServerCallback]
+        internal void Update()
+        {
+            // for each spawned:
+            //   if team changed:
+            //     add previous to dirty
+            //     add new to dirty
+            foreach (NetworkIdentity netIdentity in NetworkServer.spawned.Values)
+            {
+                // Ignore objects that don't have a NetworkTeam component
+                if (!netIdentity.TryGetComponent<NetworkTeam>(out NetworkTeam networkTeam))
+                    continue;
+
+                string newTeam = networkTeam.teamId;
+                if (!lastObjectTeam.TryGetValue(netIdentity, out string currentTeam))
+                    continue;
+
+                // string.Empty is never a valid teamId
+                // Nothing to do if teamId hasn't changed
+                if (string.IsNullOrWhiteSpace(newTeam) || newTeam == currentTeam)
+                    continue;
+
+                // Mark new/old Teams as dirty so they get rebuilt
+                UpdateDirtyTeams(newTeam, currentTeam);
+
+                // This object is in a new team so observers in the prior team
+                // and the new team need to rebuild their respective observers lists.
+                UpdateTeamObjects(netIdentity, newTeam, currentTeam);
+            }
+
+            // rebuild all dirty teams
+            foreach (string dirtyTeam in dirtyTeams)
+                RebuildTeamObservers(dirtyTeam);
+
+            dirtyTeams.Clear();
+        }
+
+        void UpdateDirtyTeams(string newTeam, string currentTeam)
+        {
+            // string.Empty is never a valid teamId
+            if (currentTeam != string.Empty)
+                dirtyTeams.Add(currentTeam);
+
+            dirtyTeams.Add(newTeam);
+        }
+
+        void UpdateTeamObjects(NetworkIdentity netIdentity, string newTeam, string currentTeam)
+        {
+            // Remove this object from the hashset of the team it just left
+            // string.Empty is never a valid teamId
+            if (!string.IsNullOrWhiteSpace(currentTeam))
+                teamObjects[currentTeam].Remove(netIdentity);
+
+            // Set this to the new team this object just entered
+            lastObjectTeam[netIdentity] = newTeam;
+
+            // Make sure this new team is in the dictionary
+            if (!teamObjects.ContainsKey(newTeam))
+                teamObjects.Add(newTeam, new HashSet<NetworkIdentity>());
+
+            // Add this object to the hashset of the new team
+            teamObjects[newTeam].Add(netIdentity);
+        }
+
+        void RebuildTeamObservers(string teamId)
+        {
+            foreach (NetworkIdentity netIdentity in teamObjects[teamId])
+                if (netIdentity != null)
+                    NetworkServer.RebuildObservers(netIdentity, false);
+        }
+
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            // Always observed if no NetworkTeam component
+            if (!identity.TryGetComponent<NetworkTeam>(out NetworkTeam identityNetworkTeam))
+                return true;
+
+            if (identityNetworkTeam.forceShown)
+                return true;
+
+            // string.Empty is never a valid teamId
+            if (string.IsNullOrWhiteSpace(identityNetworkTeam.teamId))
+                return false;
+
+            // Always observed if no NetworkTeam component
+            if (!newObserver.identity.TryGetComponent<NetworkTeam>(out NetworkTeam newObserverNetworkTeam))
+                return true;
+
+            if (newObserverNetworkTeam.forceShown)
+                return true;
+
+            // string.Empty is never a valid teamId
+            if (string.IsNullOrWhiteSpace(newObserverNetworkTeam.teamId))
+                return false;
+
+            // Observed only if teamId's match
+            return identityNetworkTeam.teamId == newObserverNetworkTeam.teamId;
+        }
+
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            // If this object doesn't have a NetworkTeam then it's visible to all clients
+            if (!identity.TryGetComponent<NetworkTeam>(out NetworkTeam networkTeam))
+            {
+                AddAllConnections(newObservers);
+                return;
+            }
+
+            // If this object has NetworkTeam and forceShown == true then it's visible to all clients
+            if (networkTeam.forceShown)
+            {
+                AddAllConnections(newObservers);
+                return;
+            }
+
+            // string.Empty is never a valid teamId
+            if (networkTeam.teamId == string.Empty)
+                return;
+
+            // Abort if this team hasn't been created yet by OnSpawned or UpdateTeamObjects
+            if (!teamObjects.TryGetValue(networkTeam.teamId, out HashSet<NetworkIdentity> objects))
+                return;
+
+            // Add everything in the hashset for this object's current team
+            foreach (NetworkIdentity networkIdentity in objects)
+                if (networkIdentity != null && networkIdentity.connectionToClient != null)
+                    newObservers.Add(networkIdentity.connectionToClient);
+        }
+
+        void AddAllConnections(HashSet<NetworkConnectionToClient> newObservers)
+        {
+            foreach (NetworkConnectionToClient conn in NetworkServer.connections.Values)
+            {
+                // authenticated and joined world with a player?
+                if (conn != null && conn.isAuthenticated && conn.identity != null)
+                    newObservers.Add(conn);
+            }
+        }
+    }
+}

Assets/Mirror/Components/InterestManagement/Team/TeamInterestManagement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dceb9a7085758fd4590419ff5b14b636
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/Mirror.Components.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "Mirror.Components",
+    "references": [
+        "Mirror"
+    ],
+    "optionalUnityReferences": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": []
+}

Assets/Mirror/Components/Mirror.Components.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 72872094b21c16e48b631b2224833d49
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkAnimator.cs

@@ -0,0 +1,634 @@
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Mirror
+{
+    /// <summary>
+    /// A component to synchronize Mecanim animation states for networked objects.
+    /// </summary>
+    /// <remarks>
+    /// <para>The animation of game objects can be networked by this component. There are two models of authority for networked movement:</para>
+    /// <para>If the object has authority on the client, then it should be animated locally on the owning client. The animation state information will be sent from the owning client to the server, then broadcast to all of the other clients. This is common for player objects.</para>
+    /// <para>If the object has authority on the server, then it should be animated on the server and state information will be sent to all clients. This is common for objects not related to a specific client, such as an enemy unit.</para>
+    /// <para>The NetworkAnimator synchronizes all animation parameters of the selected Animator. It does not automatically synchronize triggers. The function SetTrigger can by used by an object with authority to fire an animation trigger on other clients.</para>
+    /// </remarks>
+    [AddComponentMenu("Network/Network Animator")]
+    [RequireComponent(typeof(NetworkIdentity))]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-animator")]
+    public class NetworkAnimator : NetworkBehaviour
+    {
+        [Header("Authority")]
+        [Tooltip("Set to true if animations come from owner client,  set to false if animations always come from server")]
+        public bool clientAuthority;
+
+        /// <summary>
+        /// The animator component to synchronize.
+        /// </summary>
+        [FormerlySerializedAs("m_Animator")]
+        [Header("Animator")]
+        [Tooltip("Animator that will have parameters synchronized")]
+        public Animator animator;
+
+        /// <summary>
+        /// Syncs animator.speed
+        /// </summary>
+        [SyncVar(hook = nameof(OnAnimatorSpeedChanged))]
+        float animatorSpeed;
+        float previousSpeed;
+
+        // Note: not an object[] array because otherwise initialization is real annoying
+        int[] lastIntParameters;
+        float[] lastFloatParameters;
+        bool[] lastBoolParameters;
+        AnimatorControllerParameter[] parameters;
+
+        // multiple layers
+        int[] animationHash;
+        int[] transitionHash;
+        float[] layerWeight;
+        double nextSendTime;
+
+        bool SendMessagesAllowed
+        {
+            get
+            {
+                if (isServer)
+                {
+                    if (!clientAuthority)
+                        return true;
+
+                    // This is a special case where we have client authority but we have not assigned the client who has
+                    // authority over it, no animator data will be sent over the network by the server.
+                    //
+                    // So we check here for a connectionToClient and if it is null we will
+                    // let the server send animation data until we receive an owner.
+                    if (netIdentity != null && netIdentity.connectionToClient == null)
+                        return true;
+                }
+
+                return (hasAuthority && clientAuthority);
+            }
+        }
+
+        void Awake()
+        {
+            // store the animator parameters in a variable - the "Animator.parameters" getter allocates
+            // a new parameter array every time it is accessed so we should avoid doing it in a loop
+            parameters = animator.parameters
+                .Where(par => !animator.IsParameterControlledByCurve(par.nameHash))
+                .ToArray();
+            lastIntParameters = new int[parameters.Length];
+            lastFloatParameters = new float[parameters.Length];
+            lastBoolParameters = new bool[parameters.Length];
+
+            animationHash = new int[animator.layerCount];
+            transitionHash = new int[animator.layerCount];
+            layerWeight = new float[animator.layerCount];
+        }
+
+        void FixedUpdate()
+        {
+            if (!SendMessagesAllowed)
+                return;
+
+            if (!animator.enabled)
+                return;
+
+            CheckSendRate();
+
+            for (int i = 0; i < animator.layerCount; i++)
+            {
+                int stateHash;
+                float normalizedTime;
+                if (!CheckAnimStateChanged(out stateHash, out normalizedTime, i))
+                {
+                    continue;
+                }
+
+                using (NetworkWriterPooled writer = NetworkWriterPool.Get())
+                {
+                    WriteParameters(writer);
+                    SendAnimationMessage(stateHash, normalizedTime, i, layerWeight[i], writer.ToArray());
+                }
+            }
+
+            CheckSpeed();
+        }
+
+        void CheckSpeed()
+        {
+            float newSpeed = animator.speed;
+            if (Mathf.Abs(previousSpeed - newSpeed) > 0.001f)
+            {
+                previousSpeed = newSpeed;
+                if (isServer)
+                {
+                    animatorSpeed = newSpeed;
+                }
+                else if (isClient)
+                {
+                    CmdSetAnimatorSpeed(newSpeed);
+                }
+            }
+        }
+
+        void OnAnimatorSpeedChanged(float _, float value)
+        {
+            // skip if host or client with authority
+            // they will have already set the speed so don't set again
+            if (isServer || (hasAuthority && clientAuthority))
+                return;
+
+            animator.speed = value;
+        }
+
+        bool CheckAnimStateChanged(out int stateHash, out float normalizedTime, int layerId)
+        {
+            bool change = false;
+            stateHash = 0;
+            normalizedTime = 0;
+
+            float lw = animator.GetLayerWeight(layerId);
+            if (Mathf.Abs(lw - layerWeight[layerId]) > 0.001f)
+            {
+                layerWeight[layerId] = lw;
+                change = true;
+            }
+
+            if (animator.IsInTransition(layerId))
+            {
+                AnimatorTransitionInfo tt = animator.GetAnimatorTransitionInfo(layerId);
+                if (tt.fullPathHash != transitionHash[layerId])
+                {
+                    // first time in this transition
+                    transitionHash[layerId] = tt.fullPathHash;
+                    animationHash[layerId] = 0;
+                    return true;
+                }
+                return change;
+            }
+
+            AnimatorStateInfo st = animator.GetCurrentAnimatorStateInfo(layerId);
+            if (st.fullPathHash != animationHash[layerId])
+            {
+                // first time in this animation state
+                if (animationHash[layerId] != 0)
+                {
+                    // came from another animation directly - from Play()
+                    stateHash = st.fullPathHash;
+                    normalizedTime = st.normalizedTime;
+                }
+                transitionHash[layerId] = 0;
+                animationHash[layerId] = st.fullPathHash;
+                return true;
+            }
+            return change;
+        }
+
+        void CheckSendRate()
+        {
+            double now = NetworkTime.localTime;
+            if (SendMessagesAllowed && syncInterval >= 0 && now > nextSendTime)
+            {
+                nextSendTime = now + syncInterval;
+
+                using (NetworkWriterPooled writer = NetworkWriterPool.Get())
+                {
+                    if (WriteParameters(writer))
+                        SendAnimationParametersMessage(writer.ToArray());
+                }
+            }
+        }
+
+        void SendAnimationMessage(int stateHash, float normalizedTime, int layerId, float weight, byte[] parameters)
+        {
+            if (isServer)
+            {
+                RpcOnAnimationClientMessage(stateHash, normalizedTime, layerId, weight, parameters);
+            }
+            else if (isClient)
+            {
+                CmdOnAnimationServerMessage(stateHash, normalizedTime, layerId, weight, parameters);
+            }
+        }
+
+        void SendAnimationParametersMessage(byte[] parameters)
+        {
+            if (isServer)
+            {
+                RpcOnAnimationParametersClientMessage(parameters);
+            }
+            else if (isClient)
+            {
+                CmdOnAnimationParametersServerMessage(parameters);
+            }
+        }
+
+        void HandleAnimMsg(int stateHash, float normalizedTime, int layerId, float weight, NetworkReader reader)
+        {
+            if (hasAuthority && clientAuthority)
+                return;
+
+            // usually transitions will be triggered by parameters, if not, play anims directly.
+            // NOTE: this plays "animations", not transitions, so any transitions will be skipped.
+            // NOTE: there is no API to play a transition(?)
+            if (stateHash != 0 && animator.enabled)
+            {
+                animator.Play(stateHash, layerId, normalizedTime);
+            }
+
+            animator.SetLayerWeight(layerId, weight);
+
+            ReadParameters(reader);
+        }
+
+        void HandleAnimParamsMsg(NetworkReader reader)
+        {
+            if (hasAuthority && clientAuthority)
+                return;
+
+            ReadParameters(reader);
+        }
+
+        void HandleAnimTriggerMsg(int hash)
+        {
+            if (animator.enabled)
+                animator.SetTrigger(hash);
+        }
+
+        void HandleAnimResetTriggerMsg(int hash)
+        {
+            if (animator.enabled)
+                animator.ResetTrigger(hash);
+        }
+
+        ulong NextDirtyBits()
+        {
+            ulong dirtyBits = 0;
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                AnimatorControllerParameter par = parameters[i];
+                bool changed = false;
+                if (par.type == AnimatorControllerParameterType.Int)
+                {
+                    int newIntValue = animator.GetInteger(par.nameHash);
+                    changed = newIntValue != lastIntParameters[i];
+                    if (changed)
+                        lastIntParameters[i] = newIntValue;
+                }
+                else if (par.type == AnimatorControllerParameterType.Float)
+                {
+                    float newFloatValue = animator.GetFloat(par.nameHash);
+                    changed = Mathf.Abs(newFloatValue - lastFloatParameters[i]) > 0.001f;
+                    // only set lastValue if it was changed, otherwise value could slowly drift within the 0.001f limit each frame
+                    if (changed)
+                        lastFloatParameters[i] = newFloatValue;
+                }
+                else if (par.type == AnimatorControllerParameterType.Bool)
+                {
+                    bool newBoolValue = animator.GetBool(par.nameHash);
+                    changed = newBoolValue != lastBoolParameters[i];
+                    if (changed)
+                        lastBoolParameters[i] = newBoolValue;
+                }
+                if (changed)
+                {
+                    dirtyBits |= 1ul << i;
+                }
+            }
+            return dirtyBits;
+        }
+
+        bool WriteParameters(NetworkWriter writer, bool forceAll = false)
+        {
+            ulong dirtyBits = forceAll ? (~0ul) : NextDirtyBits();
+            writer.WriteULong(dirtyBits);
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                if ((dirtyBits & (1ul << i)) == 0)
+                    continue;
+
+                AnimatorControllerParameter par = parameters[i];
+                if (par.type == AnimatorControllerParameterType.Int)
+                {
+                    int newIntValue = animator.GetInteger(par.nameHash);
+                    writer.WriteInt(newIntValue);
+                }
+                else if (par.type == AnimatorControllerParameterType.Float)
+                {
+                    float newFloatValue = animator.GetFloat(par.nameHash);
+                    writer.WriteFloat(newFloatValue);
+                }
+                else if (par.type == AnimatorControllerParameterType.Bool)
+                {
+                    bool newBoolValue = animator.GetBool(par.nameHash);
+                    writer.WriteBool(newBoolValue);
+                }
+            }
+            return dirtyBits != 0;
+        }
+
+        void ReadParameters(NetworkReader reader)
+        {
+            bool animatorEnabled = animator.enabled;
+            // need to read values from NetworkReader even if animator is disabled
+
+            ulong dirtyBits = reader.ReadULong();
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                if ((dirtyBits & (1ul << i)) == 0)
+                    continue;
+
+                AnimatorControllerParameter par = parameters[i];
+                if (par.type == AnimatorControllerParameterType.Int)
+                {
+                    int newIntValue = reader.ReadInt();
+                    if (animatorEnabled)
+                        animator.SetInteger(par.nameHash, newIntValue);
+                }
+                else if (par.type == AnimatorControllerParameterType.Float)
+                {
+                    float newFloatValue = reader.ReadFloat();
+                    if (animatorEnabled)
+                        animator.SetFloat(par.nameHash, newFloatValue);
+                }
+                else if (par.type == AnimatorControllerParameterType.Bool)
+                {
+                    bool newBoolValue = reader.ReadBool();
+                    if (animatorEnabled)
+                        animator.SetBool(par.nameHash, newBoolValue);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Custom Serialization
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="initialState"></param>
+        /// <returns></returns>
+        public override bool OnSerialize(NetworkWriter writer, bool initialState)
+        {
+            bool changed = base.OnSerialize(writer, initialState);
+            if (initialState)
+            {
+                for (int i = 0; i < animator.layerCount; i++)
+                {
+                    if (animator.IsInTransition(i))
+                    {
+                        AnimatorStateInfo st = animator.GetNextAnimatorStateInfo(i);
+                        writer.WriteInt(st.fullPathHash);
+                        writer.WriteFloat(st.normalizedTime);
+                    }
+                    else
+                    {
+                        AnimatorStateInfo st = animator.GetCurrentAnimatorStateInfo(i);
+                        writer.WriteInt(st.fullPathHash);
+                        writer.WriteFloat(st.normalizedTime);
+                    }
+                    writer.WriteFloat(animator.GetLayerWeight(i));
+                }
+                WriteParameters(writer, initialState);
+                return true;
+            }
+            return changed;
+        }
+
+        /// <summary>
+        /// Custom Deserialization
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="initialState"></param>
+        public override void OnDeserialize(NetworkReader reader, bool initialState)
+        {
+            base.OnDeserialize(reader, initialState);
+            if (initialState)
+            {
+                for (int i = 0; i < animator.layerCount; i++)
+                {
+                    int stateHash = reader.ReadInt();
+                    float normalizedTime = reader.ReadFloat();
+                    animator.SetLayerWeight(i, reader.ReadFloat());
+                    animator.Play(stateHash, i, normalizedTime);
+                }
+
+                ReadParameters(reader);
+            }
+        }
+
+        /// <summary>
+        /// Causes an animation trigger to be invoked for a networked object.
+        /// <para>If local authority is set, and this is called from the client, then the trigger will be invoked on the server and all clients. If not, then this is called on the server, and the trigger will be called on all clients.</para>
+        /// </summary>
+        /// <param name="triggerName">Name of trigger.</param>
+        public void SetTrigger(string triggerName)
+        {
+            SetTrigger(Animator.StringToHash(triggerName));
+        }
+
+        /// <summary>
+        /// Causes an animation trigger to be invoked for a networked object.
+        /// </summary>
+        /// <param name="hash">Hash id of trigger (from the Animator).</param>
+        public void SetTrigger(int hash)
+        {
+            if (clientAuthority)
+            {
+                if (!isClient)
+                {
+                    Debug.LogWarning("Tried to set animation in the server for a client-controlled animator");
+                    return;
+                }
+
+                if (!hasAuthority)
+                {
+                    Debug.LogWarning("Only the client with authority can set animations");
+                    return;
+                }
+
+                if (isClient)
+                    CmdOnAnimationTriggerServerMessage(hash);
+
+                // call on client right away
+                HandleAnimTriggerMsg(hash);
+            }
+            else
+            {
+                if (!isServer)
+                {
+                    Debug.LogWarning("Tried to set animation in the client for a server-controlled animator");
+                    return;
+                }
+
+                HandleAnimTriggerMsg(hash);
+                RpcOnAnimationTriggerClientMessage(hash);
+            }
+        }
+
+        /// <summary>
+        /// Causes an animation trigger to be reset for a networked object.
+        /// <para>If local authority is set, and this is called from the client, then the trigger will be reset on the server and all clients. If not, then this is called on the server, and the trigger will be reset on all clients.</para>
+        /// </summary>
+        /// <param name="triggerName">Name of trigger.</param>
+        public void ResetTrigger(string triggerName)
+        {
+            ResetTrigger(Animator.StringToHash(triggerName));
+        }
+
+        /// <summary>
+        /// Causes an animation trigger to be reset for a networked object.
+        /// </summary>
+        /// <param name="hash">Hash id of trigger (from the Animator).</param>
+        public void ResetTrigger(int hash)
+        {
+            if (clientAuthority)
+            {
+                if (!isClient)
+                {
+                    Debug.LogWarning("Tried to reset animation in the server for a client-controlled animator");
+                    return;
+                }
+
+                if (!hasAuthority)
+                {
+                    Debug.LogWarning("Only the client with authority can reset animations");
+                    return;
+                }
+
+                if (isClient)
+                    CmdOnAnimationResetTriggerServerMessage(hash);
+
+                // call on client right away
+                HandleAnimResetTriggerMsg(hash);
+            }
+            else
+            {
+                if (!isServer)
+                {
+                    Debug.LogWarning("Tried to reset animation in the client for a server-controlled animator");
+                    return;
+                }
+
+                HandleAnimResetTriggerMsg(hash);
+                RpcOnAnimationResetTriggerClientMessage(hash);
+            }
+        }
+
+        #region server message handlers
+
+        [Command]
+        void CmdOnAnimationServerMessage(int stateHash, float normalizedTime, int layerId, float weight, byte[] parameters)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            //Debug.Log($"OnAnimationMessage for netId {netId}");
+
+            // handle and broadcast
+            using (NetworkReaderPooled networkReader = NetworkReaderPool.Get(parameters))
+            {
+                HandleAnimMsg(stateHash, normalizedTime, layerId, weight, networkReader);
+                RpcOnAnimationClientMessage(stateHash, normalizedTime, layerId, weight, parameters);
+            }
+        }
+
+        [Command]
+        void CmdOnAnimationParametersServerMessage(byte[] parameters)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            // handle and broadcast
+            using (NetworkReaderPooled networkReader = NetworkReaderPool.Get(parameters))
+            {
+                HandleAnimParamsMsg(networkReader);
+                RpcOnAnimationParametersClientMessage(parameters);
+            }
+        }
+
+        [Command]
+        void CmdOnAnimationTriggerServerMessage(int hash)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            // handle and broadcast
+            // host should have already the trigger
+            bool isHostOwner = isClient && hasAuthority;
+            if (!isHostOwner)
+            {
+                HandleAnimTriggerMsg(hash);
+            }
+
+            RpcOnAnimationTriggerClientMessage(hash);
+        }
+
+        [Command]
+        void CmdOnAnimationResetTriggerServerMessage(int hash)
+        {
+            // Ignore messages from client if not in client authority mode
+            if (!clientAuthority)
+                return;
+
+            // handle and broadcast
+            // host should have already the trigger
+            bool isHostOwner = isClient && hasAuthority;
+            if (!isHostOwner)
+            {
+                HandleAnimResetTriggerMsg(hash);
+            }
+
+            RpcOnAnimationResetTriggerClientMessage(hash);
+        }
+
+        [Command]
+        void CmdSetAnimatorSpeed(float newSpeed)
+        {
+            // set animator
+            animator.speed = newSpeed;
+            animatorSpeed = newSpeed;
+        }
+
+        #endregion
+
+        #region client message handlers
+
+        [ClientRpc]
+        void RpcOnAnimationClientMessage(int stateHash, float normalizedTime, int layerId, float weight, byte[] parameters)
+        {
+            using (NetworkReaderPooled networkReader = NetworkReaderPool.Get(parameters))
+                HandleAnimMsg(stateHash, normalizedTime, layerId, weight, networkReader);
+        }
+
+        [ClientRpc]
+        void RpcOnAnimationParametersClientMessage(byte[] parameters)
+        {
+            using (NetworkReaderPooled networkReader = NetworkReaderPool.Get(parameters))
+                HandleAnimParamsMsg(networkReader);
+        }
+
+        [ClientRpc]
+        void RpcOnAnimationTriggerClientMessage(int hash)
+        {
+            // host/owner handles this before it is sent
+            if (isServer || (clientAuthority && hasAuthority)) return;
+
+            HandleAnimTriggerMsg(hash);
+        }
+
+        [ClientRpc]
+        void RpcOnAnimationResetTriggerClientMessage(int hash)
+        {
+            // host/owner handles this before it is sent
+            if (isServer || (clientAuthority && hasAuthority)) return;
+
+            HandleAnimResetTriggerMsg(hash);
+        }
+
+        #endregion
+    }
+}

Assets/Mirror/Components/NetworkAnimator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7f6f3bf89aa97405989c802ba270f815
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkLobbyManager.cs

@@ -0,0 +1,18 @@
+using System;
+using UnityEngine;
+
+namespace Mirror
+{
+    /// <summary>
+    /// This is a specialized NetworkManager that includes a networked lobby.
+    /// </summary>
+    /// <remarks>
+    /// <para>The lobby has slots that track the joined players, and a maximum player count that is enforced. It requires that the NetworkLobbyPlayer component be on the lobby player objects.</para>
+    /// <para>NetworkLobbyManager is derived from NetworkManager, and so it implements many of the virtual functions provided by the NetworkManager class. To avoid accidentally replacing functionality of the NetworkLobbyManager, there are new virtual functions on the NetworkLobbyManager that begin with "OnLobby". These should be used on classes derived from NetworkLobbyManager instead of the virtual functions on NetworkManager.</para>
+    /// <para>The OnLobby*() functions have empty implementations on the NetworkLobbyManager base class, so the base class functions do not have to be called.</para>
+    /// </remarks>
+    [AddComponentMenu("Network/Network Lobby Manager")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-room-manager")]
+    [Obsolete("Use / inherit from NetworkRoomManager instead")]
+    public class NetworkLobbyManager : NetworkRoomManager {}
+}

Assets/Mirror/Components/NetworkLobbyManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a4c96e6dd99826849ab1431f94547141
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkLobbyPlayer.cs

@@ -0,0 +1,15 @@
+using System;
+using UnityEngine;
+
+namespace Mirror
+{
+    /// <summary>
+    /// This component works in conjunction with the NetworkLobbyManager to make up the multiplayer lobby system.
+    /// <para>The LobbyPrefab object of the NetworkLobbyManager must have this component on it. This component holds basic lobby player data required for the lobby to function. Game specific data for lobby players can be put in other components on the LobbyPrefab or in scripts derived from NetworkLobbyPlayer.</para>
+    /// </summary>
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/Network Lobby Player")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-room-player")]
+    [Obsolete("Use / inherit from NetworkRoomPlayer instead")]
+    public class NetworkLobbyPlayer : NetworkRoomPlayer {}
+}

Assets/Mirror/Components/NetworkLobbyPlayer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 777a368af85f2e84da7ea5666581921b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkPingDisplay.cs

@@ -0,0 +1,33 @@
+using System;
+using UnityEngine;
+
+namespace Mirror
+{
+    /// <summary>
+    /// Component that will display the clients ping in milliseconds
+    /// </summary>
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/Network Ping Display")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-ping-display")]
+    public class NetworkPingDisplay : MonoBehaviour
+    {
+        public Color color = Color.white;
+        public int padding = 2;
+        int width = 150;
+        int height = 25;
+
+        void OnGUI()
+        {
+            // only while client is active
+            if (!NetworkClient.active) return;
+
+            // show rtt in bottom right corner, right aligned
+            GUI.color = color;
+            Rect rect = new Rect(Screen.width - width - padding, Screen.height - height - padding, width, height);
+            GUIStyle style = GUI.skin.GetStyle("Label");
+            style.alignment = TextAnchor.MiddleRight;
+            GUI.Label(rect, $"RTT: {Math.Round(NetworkTime.rtt * 1000)}ms", style);
+            GUI.color = Color.white;
+        }
+    }
+}

Assets/Mirror/Components/NetworkPingDisplay.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc654f29862fc2643b948f772ebb9e68
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkRoomManager.cs

@@ -0,0 +1,714 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.Serialization;
+
+namespace Mirror
+{
+    /// <summary>
+    /// This is a specialized NetworkManager that includes a networked room.
+    /// </summary>
+    /// <remarks>
+    /// <para>The room has slots that track the joined players, and a maximum player count that is enforced. It requires that the NetworkRoomPlayer component be on the room player objects.</para>
+    /// <para>NetworkRoomManager is derived from NetworkManager, and so it implements many of the virtual functions provided by the NetworkManager class. To avoid accidentally replacing functionality of the NetworkRoomManager, there are new virtual functions on the NetworkRoomManager that begin with "OnRoom". These should be used on classes derived from NetworkRoomManager instead of the virtual functions on NetworkManager.</para>
+    /// <para>The OnRoom*() functions have empty implementations on the NetworkRoomManager base class, so the base class functions do not have to be called.</para>
+    /// </remarks>
+    [AddComponentMenu("Network/Network Room Manager")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-room-manager")]
+    public class NetworkRoomManager : NetworkManager
+    {
+        public struct PendingPlayer
+        {
+            public NetworkConnectionToClient conn;
+            public GameObject roomPlayer;
+        }
+
+        [Header("Room Settings")]
+
+        [FormerlySerializedAs("m_ShowRoomGUI")]
+        [SerializeField]
+        [Tooltip("This flag controls whether the default UI is shown for the room")]
+        public bool showRoomGUI = true;
+
+        [FormerlySerializedAs("m_MinPlayers")]
+        [SerializeField]
+        [Tooltip("Minimum number of players to auto-start the game")]
+        public int minPlayers = 1;
+
+        [FormerlySerializedAs("m_RoomPlayerPrefab")]
+        [SerializeField]
+        [Tooltip("Prefab to use for the Room Player")]
+        public NetworkRoomPlayer roomPlayerPrefab;
+
+        /// <summary>
+        /// The scene to use for the room. This is similar to the offlineScene of the NetworkManager.
+        /// </summary>
+        [Scene]
+        public string RoomScene;
+
+        /// <summary>
+        /// The scene to use for the playing the game from the room. This is similar to the onlineScene of the NetworkManager.
+        /// </summary>
+        [Scene]
+        public string GameplayScene;
+
+        /// <summary>
+        /// List of players that are in the Room
+        /// </summary>
+        [FormerlySerializedAs("m_PendingPlayers")]
+        public List<PendingPlayer> pendingPlayers = new List<PendingPlayer>();
+
+        [Header("Diagnostics")]
+
+        /// <summary>
+        /// True when all players have submitted a Ready message
+        /// </summary>
+        [Tooltip("Diagnostic flag indicating all players are ready to play")]
+        [FormerlySerializedAs("allPlayersReady")]
+        [SerializeField] bool _allPlayersReady;
+
+        /// <summary>
+        /// These slots track players that enter the room.
+        /// <para>The slotId on players is global to the game - across all players.</para>
+        /// </summary>
+        [Tooltip("List of Room Player objects")]
+        public List<NetworkRoomPlayer> roomSlots = new List<NetworkRoomPlayer>();
+
+        public bool allPlayersReady
+        {
+            get => _allPlayersReady;
+            set
+            {
+                bool wasReady = _allPlayersReady;
+                bool nowReady = value;
+
+                if (wasReady != nowReady)
+                {
+                    _allPlayersReady = value;
+
+                    if (nowReady)
+                    {
+                        OnRoomServerPlayersReady();
+                    }
+                    else
+                    {
+                        OnRoomServerPlayersNotReady();
+                    }
+                }
+            }
+        }
+
+        public override void OnValidate()
+        {
+            // always >= 0
+            maxConnections = Mathf.Max(maxConnections, 0);
+
+            // always <= maxConnections
+            minPlayers = Mathf.Min(minPlayers, maxConnections);
+
+            // always >= 0
+            minPlayers = Mathf.Max(minPlayers, 0);
+
+            if (roomPlayerPrefab != null)
+            {
+                NetworkIdentity identity = roomPlayerPrefab.GetComponent<NetworkIdentity>();
+                if (identity == null)
+                {
+                    roomPlayerPrefab = null;
+                    Debug.LogError("RoomPlayer prefab must have a NetworkIdentity component.");
+                }
+            }
+
+            base.OnValidate();
+        }
+
+        public void ReadyStatusChanged()
+        {
+            int CurrentPlayers = 0;
+            int ReadyPlayers = 0;
+
+            foreach (NetworkRoomPlayer item in roomSlots)
+            {
+                if (item != null)
+                {
+                    CurrentPlayers++;
+                    if (item.readyToBegin)
+                        ReadyPlayers++;
+                }
+            }
+
+            if (CurrentPlayers == ReadyPlayers)
+                CheckReadyToBegin();
+            else
+                allPlayersReady = false;
+        }
+
+        /// <summary>
+        /// Called on the server when a client is ready.
+        /// <para>The default implementation of this function calls NetworkServer.SetClientReady() to continue the network setup process.</para>
+        /// </summary>
+        /// <param name="conn">Connection from client.</param>
+        public override void OnServerReady(NetworkConnectionToClient conn)
+        {
+            Debug.Log($"NetworkRoomManager OnServerReady {conn}");
+            base.OnServerReady(conn);
+
+            if (conn != null && conn.identity != null)
+            {
+                GameObject roomPlayer = conn.identity.gameObject;
+
+                // if null or not a room player, don't replace it
+                if (roomPlayer != null && roomPlayer.GetComponent<NetworkRoomPlayer>() != null)
+                    SceneLoadedForPlayer(conn, roomPlayer);
+            }
+        }
+
+        void SceneLoadedForPlayer(NetworkConnectionToClient conn, GameObject roomPlayer)
+        {
+            Debug.Log($"NetworkRoom SceneLoadedForPlayer scene: {SceneManager.GetActiveScene().path} {conn}");
+
+            if (IsSceneActive(RoomScene))
+            {
+                // cant be ready in room, add to ready list
+                PendingPlayer pending;
+                pending.conn = conn;
+                pending.roomPlayer = roomPlayer;
+                pendingPlayers.Add(pending);
+                return;
+            }
+
+            GameObject gamePlayer = OnRoomServerCreateGamePlayer(conn, roomPlayer);
+            if (gamePlayer == null)
+            {
+                // get start position from base class
+                Transform startPos = GetStartPosition();
+                gamePlayer = startPos != null
+                    ? Instantiate(playerPrefab, startPos.position, startPos.rotation)
+                    : Instantiate(playerPrefab, Vector3.zero, Quaternion.identity);
+            }
+
+            if (!OnRoomServerSceneLoadedForPlayer(conn, roomPlayer, gamePlayer))
+                return;
+
+            // replace room player with game player
+            NetworkServer.ReplacePlayerForConnection(conn, gamePlayer, true);
+        }
+
+        /// <summary>
+        /// CheckReadyToBegin checks all of the players in the room to see if their readyToBegin flag is set.
+        /// <para>If all of the players are ready, then the server switches from the RoomScene to the PlayScene, essentially starting the game. This is called automatically in response to NetworkRoomPlayer.CmdChangeReadyState.</para>
+        /// </summary>
+        public void CheckReadyToBegin()
+        {
+            if (!IsSceneActive(RoomScene))
+                return;
+
+            int numberOfReadyPlayers = NetworkServer.connections.Count(conn => conn.Value != null && conn.Value.identity.gameObject.GetComponent<NetworkRoomPlayer>().readyToBegin);
+            bool enoughReadyPlayers = minPlayers <= 0 || numberOfReadyPlayers >= minPlayers;
+            if (enoughReadyPlayers)
+            {
+                pendingPlayers.Clear();
+                allPlayersReady = true;
+            }
+            else
+            {
+                allPlayersReady = false;
+            }
+        }
+
+        internal void CallOnClientEnterRoom()
+        {
+            OnRoomClientEnter();
+            foreach (NetworkRoomPlayer player in roomSlots)
+                if (player != null)
+                {
+                    player.OnClientEnterRoom();
+                }
+        }
+
+        internal void CallOnClientExitRoom()
+        {
+            OnRoomClientExit();
+            foreach (NetworkRoomPlayer player in roomSlots)
+                if (player != null)
+                {
+                    player.OnClientExitRoom();
+                }
+        }
+
+        #region server handlers
+
+        /// <summary>
+        /// Called on the server when a new client connects.
+        /// <para>Unity calls this on the Server when a Client connects to the Server. Use an override to tell the NetworkManager what to do when a client connects to the server.</para>
+        /// </summary>
+        /// <param name="conn">Connection from client.</param>
+        public override void OnServerConnect(NetworkConnectionToClient conn)
+        {
+            if (numPlayers >= maxConnections)
+            {
+                conn.Disconnect();
+                return;
+            }
+
+            // cannot join game in progress
+            if (!IsSceneActive(RoomScene))
+            {
+                conn.Disconnect();
+                return;
+            }
+
+            base.OnServerConnect(conn);
+            OnRoomServerConnect(conn);
+        }
+
+        /// <summary>
+        /// Called on the server when a client disconnects.
+        /// <para>This is called on the Server when a Client disconnects from the Server. Use an override to decide what should happen when a disconnection is detected.</para>
+        /// </summary>
+        /// <param name="conn">Connection from client.</param>
+        public override void OnServerDisconnect(NetworkConnectionToClient conn)
+        {
+            if (conn.identity != null)
+            {
+                NetworkRoomPlayer roomPlayer = conn.identity.GetComponent<NetworkRoomPlayer>();
+
+                if (roomPlayer != null)
+                    roomSlots.Remove(roomPlayer);
+
+                foreach (NetworkIdentity clientOwnedObject in conn.clientOwnedObjects)
+                {
+                    roomPlayer = clientOwnedObject.GetComponent<NetworkRoomPlayer>();
+                    if (roomPlayer != null)
+                        roomSlots.Remove(roomPlayer);
+                }
+            }
+
+            allPlayersReady = false;
+
+            foreach (NetworkRoomPlayer player in roomSlots)
+            {
+                if (player != null)
+                    player.GetComponent<NetworkRoomPlayer>().readyToBegin = false;
+            }
+
+            if (IsSceneActive(RoomScene))
+                RecalculateRoomPlayerIndices();
+
+            OnRoomServerDisconnect(conn);
+            base.OnServerDisconnect(conn);
+
+#if UNITY_SERVER
+            if (numPlayers < 1)
+                StopServer();
+#endif
+        }
+
+        // Sequential index used in round-robin deployment of players into instances and score positioning
+        public int clientIndex;
+
+        /// <summary>
+        /// Called on the server when a client adds a new player with NetworkClient.AddPlayer.
+        /// <para>The default implementation for this function creates a new player object from the playerPrefab.</para>
+        /// </summary>
+        /// <param name="conn">Connection from client.</param>
+        public override void OnServerAddPlayer(NetworkConnectionToClient conn)
+        {
+            // increment the index before adding the player, so first player starts at 1
+            clientIndex++;
+
+            if (IsSceneActive(RoomScene))
+            {
+                if (roomSlots.Count == maxConnections)
+                    return;
+
+                allPlayersReady = false;
+
+                //Debug.Log("NetworkRoomManager.OnServerAddPlayer playerPrefab: {roomPlayerPrefab.name}");
+
+                GameObject newRoomGameObject = OnRoomServerCreateRoomPlayer(conn);
+                if (newRoomGameObject == null)
+                    newRoomGameObject = Instantiate(roomPlayerPrefab.gameObject, Vector3.zero, Quaternion.identity);
+
+                NetworkServer.AddPlayerForConnection(conn, newRoomGameObject);
+            }
+            else
+                OnRoomServerAddPlayer(conn);
+        }
+
+        [Server]
+        public void RecalculateRoomPlayerIndices()
+        {
+            if (roomSlots.Count > 0)
+            {
+                for (int i = 0; i < roomSlots.Count; i++)
+                {
+                    roomSlots[i].index = i;
+                }
+            }
+        }
+
+        /// <summary>
+        /// This causes the server to switch scenes and sets the networkSceneName.
+        /// <para>Clients that connect to this server will automatically switch to this scene. This is called automatically if onlineScene or offlineScene are set, but it can be called from user code to switch scenes again while the game is in progress. This automatically sets clients to be not-ready. The clients must call NetworkClient.Ready() again to participate in the new scene.</para>
+        /// </summary>
+        /// <param name="newSceneName"></param>
+        public override void ServerChangeScene(string newSceneName)
+        {
+            if (newSceneName == RoomScene)
+            {
+                foreach (NetworkRoomPlayer roomPlayer in roomSlots)
+                {
+                    if (roomPlayer == null)
+                        continue;
+
+                    // find the game-player object for this connection, and destroy it
+                    NetworkIdentity identity = roomPlayer.GetComponent<NetworkIdentity>();
+
+                    if (NetworkServer.active)
+                    {
+                        // re-add the room object
+                        roomPlayer.GetComponent<NetworkRoomPlayer>().readyToBegin = false;
+                        NetworkServer.ReplacePlayerForConnection(identity.connectionToClient, roomPlayer.gameObject);
+                    }
+                }
+
+                allPlayersReady = false;
+            }
+
+            base.ServerChangeScene(newSceneName);
+        }
+
+        /// <summary>
+        /// Called on the server when a scene is completed loaded, when the scene load was initiated by the server with ServerChangeScene().
+        /// </summary>
+        /// <param name="sceneName">The name of the new scene.</param>
+        public override void OnServerSceneChanged(string sceneName)
+        {
+            if (sceneName != RoomScene)
+            {
+                // call SceneLoadedForPlayer on any players that become ready while we were loading the scene.
+                foreach (PendingPlayer pending in pendingPlayers)
+                    SceneLoadedForPlayer(pending.conn, pending.roomPlayer);
+
+                pendingPlayers.Clear();
+            }
+
+            OnRoomServerSceneChanged(sceneName);
+        }
+
+        /// <summary>
+        /// This is invoked when a server is started - including when a host is started.
+        /// <para>StartServer has multiple signatures, but they all cause this hook to be called.</para>
+        /// </summary>
+        public override void OnStartServer()
+        {
+            if (string.IsNullOrWhiteSpace(RoomScene))
+            {
+                Debug.LogError("NetworkRoomManager RoomScene is empty. Set the RoomScene in the inspector for the NetworkRoomManager");
+                return;
+            }
+
+            if (string.IsNullOrWhiteSpace(GameplayScene))
+            {
+                Debug.LogError("NetworkRoomManager PlayScene is empty. Set the PlayScene in the inspector for the NetworkRoomManager");
+                return;
+            }
+
+            OnRoomStartServer();
+        }
+
+        /// <summary>
+        /// This is invoked when a host is started.
+        /// <para>StartHost has multiple signatures, but they all cause this hook to be called.</para>
+        /// </summary>
+        public override void OnStartHost()
+        {
+            OnRoomStartHost();
+        }
+
+        /// <summary>
+        /// This is called when a server is stopped - including when a host is stopped.
+        /// </summary>
+        public override void OnStopServer()
+        {
+            roomSlots.Clear();
+            OnRoomStopServer();
+        }
+
+        /// <summary>
+        /// This is called when a host is stopped.
+        /// </summary>
+        public override void OnStopHost()
+        {
+            OnRoomStopHost();
+        }
+
+        #endregion
+
+        #region client handlers
+
+        /// <summary>
+        /// This is invoked when the client is started.
+        /// </summary>
+        public override void OnStartClient()
+        {
+            if (roomPlayerPrefab == null || roomPlayerPrefab.gameObject == null)
+                Debug.LogError("NetworkRoomManager no RoomPlayer prefab is registered. Please add a RoomPlayer prefab.");
+            else
+                NetworkClient.RegisterPrefab(roomPlayerPrefab.gameObject);
+
+            if (playerPrefab == null)
+                Debug.LogError("NetworkRoomManager no GamePlayer prefab is registered. Please add a GamePlayer prefab.");
+
+            OnRoomStartClient();
+        }
+
+        /// <summary>
+        /// Called on the client when connected to a server.
+        /// <para>The default implementation of this function sets the client as ready and adds a player. Override the function to dictate what happens when the client connects.</para>
+        /// </summary>
+        public override void OnClientConnect()
+        {
+#pragma warning disable 618
+            // obsolete method calls new method
+            OnRoomClientConnect(NetworkClient.connection);
+#pragma warning restore 618
+            base.OnClientConnect();
+        }
+
+        /// <summary>
+        /// Called on clients when disconnected from a server.
+        /// <para>This is called on the client when it disconnects from the server. Override this function to decide what happens when the client disconnects.</para>
+        /// </summary>
+        public override void OnClientDisconnect()
+        {
+#pragma warning disable 618
+            OnRoomClientDisconnect(NetworkClient.connection);
+#pragma warning restore 618
+            base.OnClientDisconnect();
+        }
+
+        /// <summary>
+        /// This is called when a client is stopped.
+        /// </summary>
+        public override void OnStopClient()
+        {
+            OnRoomStopClient();
+            CallOnClientExitRoom();
+            roomSlots.Clear();
+        }
+
+        /// <summary>
+        /// Called on clients when a scene has completed loaded, when the scene load was initiated by the server.
+        /// <para>Scene changes can cause player objects to be destroyed. The default implementation of OnClientSceneChanged in the NetworkManager is to add a player object for the connection if no player object exists.</para>
+        /// </summary>
+        public override void OnClientSceneChanged()
+        {
+            if (IsSceneActive(RoomScene))
+            {
+                if (NetworkClient.isConnected)
+                    CallOnClientEnterRoom();
+            }
+            else
+                CallOnClientExitRoom();
+
+            base.OnClientSceneChanged();
+#pragma warning disable 618
+            // obsolete method calls new method
+            OnRoomClientSceneChanged(NetworkClient.connection);
+#pragma warning restore 618
+        }
+
+        #endregion
+
+        #region room server virtuals
+
+        /// <summary>
+        /// This is called on the host when a host is started.
+        /// </summary>
+        public virtual void OnRoomStartHost() {}
+
+        /// <summary>
+        /// This is called on the host when the host is stopped.
+        /// </summary>
+        public virtual void OnRoomStopHost() {}
+
+        /// <summary>
+        /// This is called on the server when the server is started - including when a host is started.
+        /// </summary>
+        public virtual void OnRoomStartServer() {}
+
+        /// <summary>
+        /// This is called on the server when the server is started - including when a host is stopped.
+        /// </summary>
+        public virtual void OnRoomStopServer() {}
+
+        /// <summary>
+        /// This is called on the server when a new client connects to the server.
+        /// </summary>
+        /// <param name="conn">The new connection.</param>
+        public virtual void OnRoomServerConnect(NetworkConnectionToClient conn) {}
+
+        /// <summary>
+        /// This is called on the server when a client disconnects.
+        /// </summary>
+        /// <param name="conn">The connection that disconnected.</param>
+        public virtual void OnRoomServerDisconnect(NetworkConnectionToClient conn) {}
+
+        /// <summary>
+        /// This is called on the server when a networked scene finishes loading.
+        /// </summary>
+        /// <param name="sceneName">Name of the new scene.</param>
+        public virtual void OnRoomServerSceneChanged(string sceneName) {}
+
+        /// <summary>
+        /// This allows customization of the creation of the room-player object on the server.
+        /// <para>By default the roomPlayerPrefab is used to create the room-player, but this function allows that behaviour to be customized.</para>
+        /// </summary>
+        /// <param name="conn">The connection the player object is for.</param>
+        /// <returns>The new room-player object.</returns>
+        public virtual GameObject OnRoomServerCreateRoomPlayer(NetworkConnectionToClient conn)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// This allows customization of the creation of the GamePlayer object on the server.
+        /// <para>By default the gamePlayerPrefab is used to create the game-player, but this function allows that behaviour to be customized. The object returned from the function will be used to replace the room-player on the connection.</para>
+        /// </summary>
+        /// <param name="conn">The connection the player object is for.</param>
+        /// <param name="roomPlayer">The room player object for this connection.</param>
+        /// <returns>A new GamePlayer object.</returns>
+        public virtual GameObject OnRoomServerCreateGamePlayer(NetworkConnectionToClient conn, GameObject roomPlayer)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// This allows customization of the creation of the GamePlayer object on the server.
+        /// <para>This is only called for subsequent GamePlay scenes after the first one.</para>
+        /// <para>See <see cref="OnRoomServerCreateGamePlayer(NetworkConnectionToClient, GameObject)">OnRoomServerCreateGamePlayer(NetworkConnection, GameObject)</see> to customize the player object for the initial GamePlay scene.</para>
+        /// </summary>
+        /// <param name="conn">The connection the player object is for.</param>
+        public virtual void OnRoomServerAddPlayer(NetworkConnectionToClient conn)
+        {
+            base.OnServerAddPlayer(conn);
+        }
+
+        // for users to apply settings from their room player object to their in-game player object
+        /// <summary>
+        /// This is called on the server when it is told that a client has finished switching from the room scene to a game player scene.
+        /// <para>When switching from the room, the room-player is replaced with a game-player object. This callback function gives an opportunity to apply state from the room-player to the game-player object.</para>
+        /// </summary>
+        /// <param name="conn">The connection of the player</param>
+        /// <param name="roomPlayer">The room player object.</param>
+        /// <param name="gamePlayer">The game player object.</param>
+        /// <returns>False to not allow this player to replace the room player.</returns>
+        public virtual bool OnRoomServerSceneLoadedForPlayer(NetworkConnectionToClient conn, GameObject roomPlayer, GameObject gamePlayer)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// This is called on the server when all the players in the room are ready.
+        /// <para>The default implementation of this function uses ServerChangeScene() to switch to the game player scene. By implementing this callback you can customize what happens when all the players in the room are ready, such as adding a countdown or a confirmation for a group leader.</para>
+        /// </summary>
+        public virtual void OnRoomServerPlayersReady()
+        {
+            // all players are readyToBegin, start the game
+            ServerChangeScene(GameplayScene);
+        }
+
+        /// <summary>
+        /// This is called on the server when CheckReadyToBegin finds that players are not ready
+        /// <para>May be called multiple times while not ready players are joining</para>
+        /// </summary>
+        public virtual void OnRoomServerPlayersNotReady() {}
+
+        #endregion
+
+        #region room client virtuals
+
+        /// <summary>
+        /// This is a hook to allow custom behaviour when the game client enters the room.
+        /// </summary>
+        public virtual void OnRoomClientEnter() {}
+
+        /// <summary>
+        /// This is a hook to allow custom behaviour when the game client exits the room.
+        /// </summary>
+        public virtual void OnRoomClientExit() {}
+
+        /// <summary>
+        /// This is called on the client when it connects to server.
+        /// </summary>
+        public virtual void OnRoomClientConnect() {}
+
+        // Deprecated 2021-10-30
+        [Obsolete("Remove NetworkConnection from your override and use NetworkClient.connection instead.")]
+        public virtual void OnRoomClientConnect(NetworkConnection conn) => OnRoomClientConnect();
+
+        /// <summary>
+        /// This is called on the client when disconnected from a server.
+        /// </summary>
+        public virtual void OnRoomClientDisconnect() {}
+
+        // Deprecated 2021-10-30
+        [Obsolete("Remove NetworkConnection from your override and use NetworkClient.connection instead.")]
+        public virtual void OnRoomClientDisconnect(NetworkConnection conn) => OnRoomClientDisconnect();
+
+        /// <summary>
+        /// This is called on the client when a client is started.
+        /// </summary>
+        public virtual void OnRoomStartClient() {}
+
+        /// <summary>
+        /// This is called on the client when the client stops.
+        /// </summary>
+        public virtual void OnRoomStopClient() {}
+
+        /// <summary>
+        /// This is called on the client when the client is finished loading a new networked scene.
+        /// </summary>
+        public virtual void OnRoomClientSceneChanged() {}
+
+        // Deprecated 2021-10-30
+        [Obsolete("Remove NetworkConnection from your override and use NetworkClient.connection instead.")]
+        public virtual void OnRoomClientSceneChanged(NetworkConnection conn) => OnRoomClientSceneChanged();
+
+        /// <summary>
+        /// Called on the client when adding a player to the room fails.
+        /// <para>This could be because the room is full, or the connection is not allowed to have more players.</para>
+        /// </summary>
+        public virtual void OnRoomClientAddPlayerFailed() {}
+
+        #endregion
+
+        #region optional UI
+
+        /// <summary>
+        /// virtual so inheriting classes can roll their own
+        /// </summary>
+        public virtual void OnGUI()
+        {
+            if (!showRoomGUI)
+                return;
+
+            if (NetworkServer.active && IsSceneActive(GameplayScene))
+            {
+                GUILayout.BeginArea(new Rect(Screen.width - 150f, 10f, 140f, 30f));
+                if (GUILayout.Button("Return to Room"))
+                    ServerChangeScene(RoomScene);
+                GUILayout.EndArea();
+            }
+
+            if (IsSceneActive(RoomScene))
+                GUI.Box(new Rect(10f, 180f, 520f, 150f), "PLAYERS");
+        }
+
+        #endregion
+    }
+}

Assets/Mirror/Components/NetworkRoomManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 615e6c6589cf9e54cad646b5a11e0529
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkRoomPlayer.cs

@@ -0,0 +1,195 @@
+using UnityEngine;
+
+namespace Mirror
+{
+    /// <summary>
+    /// This component works in conjunction with the NetworkRoomManager to make up the multiplayer room system.
+    /// <para>The RoomPrefab object of the NetworkRoomManager must have this component on it. This component holds basic room player data required for the room to function. Game specific data for room players can be put in other components on the RoomPrefab or in scripts derived from NetworkRoomPlayer.</para>
+    /// </summary>
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/Network Room Player")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-room-player")]
+    public class NetworkRoomPlayer : NetworkBehaviour
+    {
+        /// <summary>
+        /// This flag controls whether the default UI is shown for the room player.
+        /// <para>As this UI is rendered using the old GUI system, it is only recommended for testing purposes.</para>
+        /// </summary>
+        [Tooltip("This flag controls whether the default UI is shown for the room player")]
+        public bool showRoomGUI = true;
+
+        [Header("Diagnostics")]
+
+        /// <summary>
+        /// Diagnostic flag indicating whether this player is ready for the game to begin.
+        /// <para>Invoke CmdChangeReadyState method on the client to set this flag.</para>
+        /// <para>When all players are ready to begin, the game will start. This should not be set directly, CmdChangeReadyState should be called on the client to set it on the server.</para>
+        /// </summary>
+        [Tooltip("Diagnostic flag indicating whether this player is ready for the game to begin")]
+        [SyncVar(hook = nameof(ReadyStateChanged))]
+        public bool readyToBegin;
+
+        /// <summary>
+        /// Diagnostic index of the player, e.g. Player1, Player2, etc.
+        /// </summary>
+        [Tooltip("Diagnostic index of the player, e.g. Player1, Player2, etc.")]
+        [SyncVar(hook = nameof(IndexChanged))]
+        public int index;
+
+        #region Unity Callbacks
+
+        /// <summary>
+        /// Do not use Start - Override OnStartHost / OnStartClient instead!
+        /// </summary>
+        public void Start()
+        {
+            if (NetworkManager.singleton is NetworkRoomManager room)
+            {
+                // NetworkRoomPlayer object must be set to DontDestroyOnLoad along with NetworkRoomManager
+                // in server and all clients, otherwise it will be respawned in the game scene which would
+                // have undesirable effects.
+                if (room.dontDestroyOnLoad)
+                    DontDestroyOnLoad(gameObject);
+
+                room.roomSlots.Add(this);
+
+                if (NetworkServer.active)
+                    room.RecalculateRoomPlayerIndices();
+
+                if (NetworkClient.active)
+                    room.CallOnClientEnterRoom();
+            }
+            else Debug.LogError("RoomPlayer could not find a NetworkRoomManager. The RoomPlayer requires a NetworkRoomManager object to function. Make sure that there is one in the scene.");
+        }
+
+        public virtual void OnDisable()
+        {
+            if (NetworkClient.active && NetworkManager.singleton is NetworkRoomManager room)
+            {
+                // only need to call this on client as server removes it before object is destroyed
+                room.roomSlots.Remove(this);
+
+                room.CallOnClientExitRoom();
+            }
+        }
+
+        #endregion
+
+        #region Commands
+
+        [Command]
+        public void CmdChangeReadyState(bool readyState)
+        {
+            readyToBegin = readyState;
+            NetworkRoomManager room = NetworkManager.singleton as NetworkRoomManager;
+            if (room != null)
+            {
+                room.ReadyStatusChanged();
+            }
+        }
+
+        #endregion
+
+        #region SyncVar Hooks
+
+        /// <summary>
+        /// This is a hook that is invoked on clients when the index changes.
+        /// </summary>
+        /// <param name="oldIndex">The old index value</param>
+        /// <param name="newIndex">The new index value</param>
+        public virtual void IndexChanged(int oldIndex, int newIndex) {}
+
+        /// <summary>
+        /// This is a hook that is invoked on clients when a RoomPlayer switches between ready or not ready.
+        /// <para>This function is called when the a client player calls CmdChangeReadyState.</para>
+        /// </summary>
+        /// <param name="newReadyState">New Ready State</param>
+        public virtual void ReadyStateChanged(bool oldReadyState, bool newReadyState) {}
+
+        #endregion
+
+        #region Room Client Virtuals
+
+        /// <summary>
+        /// This is a hook that is invoked on clients for all room player objects when entering the room.
+        /// <para>Note: isLocalPlayer is not guaranteed to be set until OnStartLocalPlayer is called.</para>
+        /// </summary>
+        public virtual void OnClientEnterRoom() {}
+
+        /// <summary>
+        /// This is a hook that is invoked on clients for all room player objects when exiting the room.
+        /// </summary>
+        public virtual void OnClientExitRoom() {}
+
+        #endregion
+
+        #region Optional UI
+
+        /// <summary>
+        /// Render a UI for the room. Override to provide your own UI
+        /// </summary>
+        public virtual void OnGUI()
+        {
+            if (!showRoomGUI)
+                return;
+
+            NetworkRoomManager room = NetworkManager.singleton as NetworkRoomManager;
+            if (room)
+            {
+                if (!room.showRoomGUI)
+                    return;
+
+                if (!NetworkManager.IsSceneActive(room.RoomScene))
+                    return;
+
+                DrawPlayerReadyState();
+                DrawPlayerReadyButton();
+            }
+        }
+
+        void DrawPlayerReadyState()
+        {
+            GUILayout.BeginArea(new Rect(20f + (index * 100), 200f, 90f, 130f));
+
+            GUILayout.Label($"Player [{index + 1}]");
+
+            if (readyToBegin)
+                GUILayout.Label("Ready");
+            else
+                GUILayout.Label("Not Ready");
+
+            if (((isServer && index > 0) || isServerOnly) && GUILayout.Button("REMOVE"))
+            {
+                // This button only shows on the Host for all players other than the Host
+                // Host and Players can't remove themselves (stop the client instead)
+                // Host can kick a Player this way.
+                GetComponent<NetworkIdentity>().connectionToClient.Disconnect();
+            }
+
+            GUILayout.EndArea();
+        }
+
+        void DrawPlayerReadyButton()
+        {
+            if (NetworkClient.active && isLocalPlayer)
+            {
+                GUILayout.BeginArea(new Rect(20f, 300f, 120f, 20f));
+
+                if (readyToBegin)
+                {
+                    if (GUILayout.Button("Cancel"))
+                        CmdChangeReadyState(false);
+                }
+                else
+                {
+                    if (GUILayout.Button("Ready"))
+                        CmdChangeReadyState(true);
+                }
+
+                GUILayout.EndArea();
+            }
+        }
+
+        #endregion
+    }
+}

Assets/Mirror/Components/NetworkRoomPlayer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 79874ac94d5b1314788ecf0e86bd23fd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkStatistics.cs

@@ -0,0 +1,192 @@
+using System;
+using UnityEngine;
+
+namespace Mirror
+{
+    /// <summary>
+    /// Shows Network messages and bytes sent & received per second.
+    /// <para>Add this component to the same object as Network Manager.</para>
+    /// </summary>
+    [AddComponentMenu("Network/Network Statistics")]
+    [DisallowMultipleComponent]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-statistics")]
+    public class NetworkStatistics : MonoBehaviour
+    {
+        // update interval
+        double intervalStartTime;
+
+        // ---------------------------------------------------------------------
+
+        // CLIENT
+        // long bytes to support >2GB
+        int clientIntervalReceivedPackets;
+        long clientIntervalReceivedBytes;
+        int clientIntervalSentPackets;
+        long clientIntervalSentBytes;
+
+        // results from last interval
+        // long bytes to support >2GB
+        int clientReceivedPacketsPerSecond;
+        long clientReceivedBytesPerSecond;
+        int clientSentPacketsPerSecond;
+        long clientSentBytesPerSecond;
+
+        // ---------------------------------------------------------------------
+
+        // SERVER
+        // capture interval
+        // long bytes to support >2GB
+        int serverIntervalReceivedPackets;
+        long serverIntervalReceivedBytes;
+        int serverIntervalSentPackets;
+        long serverIntervalSentBytes;
+
+        // results from last interval
+        // long bytes to support >2GB
+        int serverReceivedPacketsPerSecond;
+        long serverReceivedBytesPerSecond;
+        int serverSentPacketsPerSecond;
+        long serverSentBytesPerSecond;
+
+        // NetworkManager sets Transport.activeTransport in Awake().
+        // so let's hook into it in Start().
+        void Start()
+        {
+            // find available transport
+            Transport transport = Transport.activeTransport;
+            if (transport != null)
+            {
+                transport.OnClientDataReceived += OnClientReceive;
+                transport.OnClientDataSent += OnClientSend;
+                transport.OnServerDataReceived += OnServerReceive;
+                transport.OnServerDataSent += OnServerSend;
+            }
+            else Debug.LogError($"NetworkStatistics: no available or active Transport found on this platform: {Application.platform}");
+        }
+
+        void OnDestroy()
+        {
+            // remove transport hooks
+            Transport transport = Transport.activeTransport;
+            if (transport != null)
+            {
+                transport.OnClientDataReceived -= OnClientReceive;
+                transport.OnClientDataSent -= OnClientSend;
+                transport.OnServerDataReceived -= OnServerReceive;
+                transport.OnServerDataSent -= OnServerSend;
+            }
+        }
+
+        void OnClientReceive(ArraySegment<byte> data, int channelId)
+        {
+            ++clientIntervalReceivedPackets;
+            clientIntervalReceivedBytes += data.Count;
+        }
+
+        void OnClientSend(ArraySegment<byte> data, int channelId)
+        {
+            ++clientIntervalSentPackets;
+            clientIntervalSentBytes += data.Count;
+        }
+
+        void OnServerReceive(int connectionId, ArraySegment<byte> data, int channelId)
+        {
+            ++serverIntervalReceivedPackets;
+            serverIntervalReceivedBytes += data.Count;
+        }
+
+        void OnServerSend(int connectionId, ArraySegment<byte> data, int channelId)
+        {
+            ++serverIntervalSentPackets;
+            serverIntervalSentBytes += data.Count;
+        }
+
+        void Update()
+        {
+            // calculate results every second
+            if (NetworkTime.localTime >= intervalStartTime + 1)
+            {
+                if (NetworkClient.active) UpdateClient();
+                if (NetworkServer.active) UpdateServer();
+
+                intervalStartTime = NetworkTime.localTime;
+            }
+        }
+
+        void UpdateClient()
+        {
+            clientReceivedPacketsPerSecond = clientIntervalReceivedPackets;
+            clientReceivedBytesPerSecond = clientIntervalReceivedBytes;
+            clientSentPacketsPerSecond = clientIntervalSentPackets;
+            clientSentBytesPerSecond = clientIntervalSentBytes;
+
+            clientIntervalReceivedPackets = 0;
+            clientIntervalReceivedBytes = 0;
+            clientIntervalSentPackets = 0;
+            clientIntervalSentBytes = 0;
+        }
+
+        void UpdateServer()
+        {
+            serverReceivedPacketsPerSecond = serverIntervalReceivedPackets;
+            serverReceivedBytesPerSecond = serverIntervalReceivedBytes;
+            serverSentPacketsPerSecond = serverIntervalSentPackets;
+            serverSentBytesPerSecond = serverIntervalSentBytes;
+
+            serverIntervalReceivedPackets = 0;
+            serverIntervalReceivedBytes = 0;
+            serverIntervalSentPackets = 0;
+            serverIntervalSentBytes = 0;
+        }
+
+        void OnGUI()
+        {
+            // only show if either server or client active
+            if (NetworkClient.active || NetworkServer.active)
+            {
+                // create main GUI area
+                // 105 is below NetworkManager HUD in all cases.
+                GUILayout.BeginArea(new Rect(10, 105, 215, 300));
+
+                // show client / server stats if active
+                if (NetworkClient.active) OnClientGUI();
+                if (NetworkServer.active) OnServerGUI();
+
+                // end of GUI area
+                GUILayout.EndArea();
+            }
+        }
+
+        void OnClientGUI()
+        {
+            // background
+            GUILayout.BeginVertical("Box");
+            GUILayout.Label("<b>Client Statistics</b>");
+
+            // sending ("msgs" instead of "packets" to fit larger numbers)
+            GUILayout.Label($"Send: {clientSentPacketsPerSecond} msgs @ {Utils.PrettyBytes(clientSentBytesPerSecond)}/s");
+
+            // receiving ("msgs" instead of "packets" to fit larger numbers)
+            GUILayout.Label($"Recv: {clientReceivedPacketsPerSecond} msgs @ {Utils.PrettyBytes(clientReceivedBytesPerSecond)}/s");
+
+            // end background
+            GUILayout.EndVertical();
+        }
+
+        void OnServerGUI()
+        {
+            // background
+            GUILayout.BeginVertical("Box");
+            GUILayout.Label("<b>Server Statistics</b>");
+
+            // sending ("msgs" instead of "packets" to fit larger numbers)
+            GUILayout.Label($"Send: {serverSentPacketsPerSecond} msgs @ {Utils.PrettyBytes(serverSentBytesPerSecond)}/s");
+
+            // receiving ("msgs" instead of "packets" to fit larger numbers)
+            GUILayout.Label($"Recv: {serverReceivedPacketsPerSecond} msgs @ {Utils.PrettyBytes(serverReceivedBytesPerSecond)}/s");
+
+            // end background
+            GUILayout.EndVertical();
+        }
+    }
+}

Assets/Mirror/Components/NetworkStatistics.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6d7da4e566d24ea7b0e12178d934b648
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkTransform2k.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 44e823b93c7d2477c8796766dc364c59
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkTransform2k/NetworkTransform.cs

@@ -0,0 +1,17 @@
+// ʻOumuamua's light curve, assuming little systematic error, presents its
+// motion as tumbling, rather than smoothly rotating, and moving sufficiently
+// fast relative to the Sun.
+//
+// A small number of astronomers suggested that ʻOumuamua could be a product of
+// alien technology, but evidence in support of this hypothesis is weak.
+using UnityEngine;
+
+namespace Mirror
+{
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/Network Transform")]
+    public class NetworkTransform : NetworkTransformBase
+    {
+        protected override Transform targetComponent => transform;
+    }
+}

Assets/Mirror/Components/NetworkTransform2k/NetworkTransform.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2f74aedd71d9a4f55b3ce499326d45fb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkTransform2k/NetworkTransformBase.cs

@@ -0,0 +1,776 @@
+// NetworkTransform V2 aka project Oumuamua by vis2k (2021-07)
+// Snapshot Interpolation: https://gafferongames.com/post/snapshot_interpolation/
+//
+// Base class for NetworkTransform and NetworkTransformChild.
+// => simple unreliable sync without any interpolation for now.
+// => which means we don't need teleport detection either
+//
+// NOTE: several functions are virtual in case someone needs to modify a part.
+//
+// Channel: uses UNRELIABLE at all times.
+// -> out of order packets are dropped automatically
+// -> it's better than RELIABLE for several reasons:
+//    * head of line blocking would add delay
+//    * resending is mostly pointless
+//    * bigger data race:
+//      -> if we use a Cmd() at position X over reliable
+//      -> client gets Cmd() and X at the same time, but buffers X for bufferTime
+//      -> for unreliable, it would get X before the reliable Cmd(), still
+//         buffer for bufferTime but end up closer to the original time
+// comment out the below line to quickly revert the onlySyncOnChange feature
+#define onlySyncOnChange_BANDWIDTH_SAVING
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    public abstract class NetworkTransformBase : NetworkBehaviour
+    {
+        // TODO SyncDirection { CLIENT_TO_SERVER, SERVER_TO_CLIENT } is easier?
+        [Header("Authority")]
+        [Tooltip("Set to true if moves come from owner client, set to false if moves always come from server")]
+        public bool clientAuthority;
+
+        // Is this a client with authority over this transform?
+        // This component could be on the player object or any object that has been assigned authority to this client.
+        protected bool IsClientWithAuthority => hasAuthority && clientAuthority;
+
+        // target transform to sync. can be on a child.
+        protected abstract Transform targetComponent { get; }
+
+        [Header("Synchronization")]
+        [Range(0, 1)] public float sendInterval = 0.050f;
+        public bool syncPosition = true;
+        public bool syncRotation = true;
+        // scale sync is rare. off by default.
+        public bool syncScale = false;
+
+        double lastClientSendTime;
+        double lastServerSendTime;
+
+        // not all games need to interpolate. a board game might jump to the
+        // final position immediately.
+        [Header("Interpolation")]
+        public bool interpolatePosition = true;
+        public bool interpolateRotation = true;
+        public bool interpolateScale = false;
+
+        // "Experimentally I’ve found that the amount of delay that works best
+        //  at 2-5% packet loss is 3X the packet send rate"
+        // NOTE: we do NOT use a dyanmically changing buffer size.
+        //       it would come with a lot of complications, e.g. buffer time
+        //       advantages/disadvantages for different connections.
+        //       Glenn Fiedler's recommendation seems solid, and should cover
+        //       the vast majority of connections.
+        //       (a player with 2000ms latency will have issues no matter what)
+        [Header("Buffering")]
+        [Tooltip("Snapshots are buffered for sendInterval * multiplier seconds. If your expected client base is to run at non-ideal connection quality (2-5% packet loss), 3x supposedly works best.")]
+        public int bufferTimeMultiplier = 1;
+        public float bufferTime => sendInterval * bufferTimeMultiplier;
+        [Tooltip("Buffer size limit to avoid ever growing list memory consumption attacks.")]
+        public int bufferSizeLimit = 64;
+
+        [Tooltip("Start to accelerate interpolation if buffer size is >= threshold. Needs to be larger than bufferTimeMultiplier.")]
+        public int catchupThreshold = 4;
+
+        [Tooltip("Once buffer is larger catchupThreshold, accelerate by multiplier % per excess entry.")]
+        [Range(0, 1)] public float catchupMultiplier = 0.10f;
+
+#if onlySyncOnChange_BANDWIDTH_SAVING
+        [Header("Sync Only If Changed")]
+        [Tooltip("When true, changes are not sent unless greater than sensitivity values below.")]
+        public bool onlySyncOnChange = true;
+
+        // 3 was original, but testing under really bad network conditions, 2%-5% packet loss and 250-1200ms ping, 5 proved to eliminate any twitching.
+        [Tooltip("How much time, as a multiple of send interval, has passed before clearing buffers.")]
+        public float bufferResetMultiplier = 5;
+
+        [Header("Sensitivity"), Tooltip("Sensitivity of changes needed before an updated state is sent over the network")]
+        public float positionSensitivity = 0.01f;
+        public float rotationSensitivity = 0.01f;
+        public float scaleSensitivity = 0.01f;
+
+        protected bool positionChanged;
+        protected bool rotationChanged;
+        protected bool scaleChanged;
+
+        // Used to store last sent snapshots
+        protected NTSnapshot lastSnapshot;
+        protected bool cachedSnapshotComparison;
+        protected bool hasSentUnchangedPosition;
+#endif
+
+        // snapshots sorted by timestamp
+        // in the original article, glenn fiedler drops any snapshots older than
+        // the last received snapshot.
+        // -> instead, we insert into a sorted buffer
+        // -> the higher the buffer information density, the better
+        // -> we still drop anything older than the first element in the buffer
+        // => internal for testing
+        //
+        // IMPORTANT: of explicit 'NTSnapshot' type instead of 'Snapshot'
+        //            interface because List<interface> allocates through boxing
+        internal SortedList<double, NTSnapshot> serverBuffer = new SortedList<double, NTSnapshot>();
+        internal SortedList<double, NTSnapshot> clientBuffer = new SortedList<double, NTSnapshot>();
+
+        // absolute interpolation time, moved along with deltaTime
+        // (roughly between [0, delta] where delta is snapshot B - A timestamp)
+        // (can be bigger than delta when overshooting)
+        double serverInterpolationTime;
+        double clientInterpolationTime;
+
+        // only convert the static Interpolation function to Func<T> once to
+        // avoid allocations
+        Func<NTSnapshot, NTSnapshot, double, NTSnapshot> Interpolate = NTSnapshot.Interpolate;
+
+        [Header("Debug")]
+        public bool showGizmos;
+        public bool showOverlay;
+        public Color overlayColor = new Color(0, 0, 0, 0.5f);
+
+        // snapshot functions //////////////////////////////////////////////////
+        // construct a snapshot of the current state
+        // => internal for testing
+        protected virtual NTSnapshot ConstructSnapshot()
+        {
+            // NetworkTime.localTime for double precision until Unity has it too
+            return new NTSnapshot(
+                // our local time is what the other end uses as remote time
+                NetworkTime.localTime,
+                // the other end fills out local time itself
+                0,
+                targetComponent.localPosition,
+                targetComponent.localRotation,
+                targetComponent.localScale
+            );
+        }
+
+        // apply a snapshot to the Transform.
+        // -> start, end, interpolated are all passed in caes they are needed
+        // -> a regular game would apply the 'interpolated' snapshot
+        // -> a board game might want to jump to 'goal' directly
+        // (it's easier to always interpolate and then apply selectively,
+        //  instead of manually interpolating x, y, z, ... depending on flags)
+        // => internal for testing
+        //
+        // NOTE: stuck detection is unnecessary here.
+        //       we always set transform.position anyway, we can't get stuck.
+        protected virtual void ApplySnapshot(NTSnapshot start, NTSnapshot goal, NTSnapshot interpolated)
+        {
+            // local position/rotation for VR support
+            //
+            // if syncPosition/Rotation/Scale is disabled then we received nulls
+            // -> current position/rotation/scale would've been added as snapshot
+            // -> we still interpolated
+            // -> but simply don't apply it. if the user doesn't want to sync
+            //    scale, then we should not touch scale etc.
+            if (syncPosition)
+                targetComponent.localPosition = interpolatePosition ? interpolated.position : goal.position;
+
+            if (syncRotation)
+                targetComponent.localRotation = interpolateRotation ? interpolated.rotation : goal.rotation;
+
+            if (syncScale)
+                targetComponent.localScale = interpolateScale ? interpolated.scale : goal.scale;
+        }
+#if onlySyncOnChange_BANDWIDTH_SAVING
+        // Returns true if position, rotation AND scale are unchanged, within given sensitivity range.
+        protected virtual bool CompareSnapshots(NTSnapshot currentSnapshot)
+        {
+            positionChanged = Vector3.SqrMagnitude(lastSnapshot.position - currentSnapshot.position) > positionSensitivity * positionSensitivity;
+            rotationChanged = Quaternion.Angle(lastSnapshot.rotation, currentSnapshot.rotation) > rotationSensitivity;
+            scaleChanged = Vector3.SqrMagnitude(lastSnapshot.scale - currentSnapshot.scale) > scaleSensitivity * scaleSensitivity;
+
+            return (!positionChanged && !rotationChanged && !scaleChanged);
+        }
+#endif
+        // cmd /////////////////////////////////////////////////////////////////
+        // only unreliable. see comment above of this file.
+        [Command(channel = Channels.Unreliable)]
+        void CmdClientToServerSync(Vector3? position, Quaternion? rotation, Vector3? scale)
+        {
+            OnClientToServerSync(position, rotation, scale);
+            //For client authority, immediately pass on the client snapshot to all other
+            //clients instead of waiting for server to send its snapshots.
+            if (clientAuthority)
+            {
+                RpcServerToClientSync(position, rotation, scale);
+            }
+        }
+
+        // local authority client sends sync message to server for broadcasting
+        protected virtual void OnClientToServerSync(Vector3? position, Quaternion? rotation, Vector3? scale)
+        {
+            // only apply if in client authority mode
+            if (!clientAuthority) return;
+
+            // protect against ever growing buffer size attacks
+            if (serverBuffer.Count >= bufferSizeLimit) return;
+
+            // only player owned objects (with a connection) can send to
+            // server. we can get the timestamp from the connection.
+            double timestamp = connectionToClient.remoteTimeStamp;
+#if onlySyncOnChange_BANDWIDTH_SAVING
+            if (onlySyncOnChange)
+            {
+                double timeIntervalCheck = bufferResetMultiplier * sendInterval;
+
+                if (serverBuffer.Count > 0 && serverBuffer.Values[serverBuffer.Count - 1].remoteTimestamp + timeIntervalCheck < timestamp)
+                {
+                    Reset();
+                }
+            }
+#endif
+            // position, rotation, scale can have no value if same as last time.
+            // saves bandwidth.
+            // but we still need to feed it to snapshot interpolation. we can't
+            // just have gaps in there if nothing has changed. for example, if
+            //   client sends snapshot at t=0
+            //   client sends nothing for 10s because not moved
+            //   client sends snapshot at t=10
+            // then the server would assume that it's one super slow move and
+            // replay it for 10 seconds.
+            if (!position.HasValue) position = serverBuffer.Count > 0 ? serverBuffer.Values[serverBuffer.Count - 1].position : targetComponent.localPosition;
+            if (!rotation.HasValue) rotation = serverBuffer.Count > 0 ? serverBuffer.Values[serverBuffer.Count - 1].rotation : targetComponent.localRotation;
+            if (!scale.HasValue) scale = serverBuffer.Count > 0 ? serverBuffer.Values[serverBuffer.Count - 1].scale : targetComponent.localScale;
+
+            // construct snapshot with batch timestamp to save bandwidth
+            NTSnapshot snapshot = new NTSnapshot(
+                timestamp,
+                NetworkTime.localTime,
+                position.Value, rotation.Value, scale.Value
+            );
+
+            // add to buffer (or drop if older than first element)
+            SnapshotInterpolation.InsertIfNewEnough(snapshot, serverBuffer);
+        }
+
+        // rpc /////////////////////////////////////////////////////////////////
+        // only unreliable. see comment above of this file.
+        [ClientRpc(channel = Channels.Unreliable)]
+        void RpcServerToClientSync(Vector3? position, Quaternion? rotation, Vector3? scale) =>
+            OnServerToClientSync(position, rotation, scale);
+
+        // server broadcasts sync message to all clients
+        protected virtual void OnServerToClientSync(Vector3? position, Quaternion? rotation, Vector3? scale)
+        {
+            // in host mode, the server sends rpcs to all clients.
+            // the host client itself will receive them too.
+            // -> host server is always the source of truth
+            // -> we can ignore any rpc on the host client
+            // => otherwise host objects would have ever growing clientBuffers
+            // (rpc goes to clients. if isServer is true too then we are host)
+            if (isServer) return;
+
+            // don't apply for local player with authority
+            if (IsClientWithAuthority) return;
+
+            // protect against ever growing buffer size attacks
+            if (clientBuffer.Count >= bufferSizeLimit) return;
+
+            // on the client, we receive rpcs for all entities.
+            // not all of them have a connectionToServer.
+            // but all of them go through NetworkClient.connection.
+            // we can get the timestamp from there.
+            double timestamp = NetworkClient.connection.remoteTimeStamp;
+#if onlySyncOnChange_BANDWIDTH_SAVING
+            if (onlySyncOnChange)
+            {
+                double timeIntervalCheck = bufferResetMultiplier * sendInterval;
+
+                if (clientBuffer.Count > 0 && clientBuffer.Values[clientBuffer.Count - 1].remoteTimestamp + timeIntervalCheck < timestamp)
+                {
+                    Reset();
+                }
+            }
+#endif
+            // position, rotation, scale can have no value if same as last time.
+            // saves bandwidth.
+            // but we still need to feed it to snapshot interpolation. we can't
+            // just have gaps in there if nothing has changed. for example, if
+            //   client sends snapshot at t=0
+            //   client sends nothing for 10s because not moved
+            //   client sends snapshot at t=10
+            // then the server would assume that it's one super slow move and
+            // replay it for 10 seconds.
+            if (!position.HasValue) position = clientBuffer.Count > 0 ? clientBuffer.Values[clientBuffer.Count - 1].position : targetComponent.localPosition;
+            if (!rotation.HasValue) rotation = clientBuffer.Count > 0 ? clientBuffer.Values[clientBuffer.Count - 1].rotation : targetComponent.localRotation;
+            if (!scale.HasValue) scale = clientBuffer.Count > 0 ? clientBuffer.Values[clientBuffer.Count - 1].scale : targetComponent.localScale;
+
+            // construct snapshot with batch timestamp to save bandwidth
+            NTSnapshot snapshot = new NTSnapshot(
+                timestamp,
+                NetworkTime.localTime,
+                position.Value, rotation.Value, scale.Value
+            );
+
+            // add to buffer (or drop if older than first element)
+            SnapshotInterpolation.InsertIfNewEnough(snapshot, clientBuffer);
+        }
+
+        // update //////////////////////////////////////////////////////////////
+        void UpdateServer()
+        {
+            // broadcast to all clients each 'sendInterval'
+            // (client with authority will drop the rpc)
+            // NetworkTime.localTime for double precision until Unity has it too
+            //
+            // IMPORTANT:
+            // snapshot interpolation requires constant sending.
+            // DO NOT only send if position changed. for example:
+            // ---
+            // * client sends first position at t=0
+            // * ... 10s later ...
+            // * client moves again, sends second position at t=10
+            // ---
+            // * server gets first position at t=0
+            // * server gets second position at t=10
+            // * server moves from first to second within a time of 10s
+            //   => would be a super slow move, instead of a wait & move.
+            //
+            // IMPORTANT:
+            // DO NOT send nulls if not changed 'since last send' either. we
+            // send unreliable and don't know which 'last send' the other end
+            // received successfully.
+            //
+            // Checks to ensure server only sends snapshots if object is
+            // on server authority(!clientAuthority) mode because on client
+            // authority mode snapshots are broadcasted right after the authoritative
+            // client updates server in the command function(see above), OR,
+            // since host does not send anything to update the server, any client
+            // authoritative movement done by the host will have to be broadcasted
+            // here by checking IsClientWithAuthority.
+            if (NetworkTime.localTime >= lastServerSendTime + sendInterval &&
+                (!clientAuthority || IsClientWithAuthority))
+            {
+                // send snapshot without timestamp.
+                // receiver gets it from batch timestamp to save bandwidth.
+                NTSnapshot snapshot = ConstructSnapshot();
+#if onlySyncOnChange_BANDWIDTH_SAVING
+                cachedSnapshotComparison = CompareSnapshots(snapshot);
+                if (cachedSnapshotComparison && hasSentUnchangedPosition && onlySyncOnChange) { return; }
+#endif
+
+#if onlySyncOnChange_BANDWIDTH_SAVING
+                RpcServerToClientSync(
+                    // only sync what the user wants to sync
+                    syncPosition && positionChanged ? snapshot.position : default(Vector3?),
+                    syncRotation && rotationChanged ? snapshot.rotation : default(Quaternion?),
+                    syncScale && scaleChanged ? snapshot.scale : default(Vector3?)
+                );
+#else
+                RpcServerToClientSync(
+                    // only sync what the user wants to sync
+                    syncPosition ? snapshot.position : default(Vector3?),
+                    syncRotation ? snapshot.rotation : default(Quaternion?),
+                    syncScale ? snapshot.scale : default(Vector3?)
+                );
+#endif
+
+                lastServerSendTime = NetworkTime.localTime;
+#if onlySyncOnChange_BANDWIDTH_SAVING
+                if (cachedSnapshotComparison)
+                {
+                    hasSentUnchangedPosition = true;
+                }
+                else
+                {
+                    hasSentUnchangedPosition = false;
+                    lastSnapshot = snapshot;
+                }
+#endif
+            }
+
+            // apply buffered snapshots IF client authority
+            // -> in server authority, server moves the object
+            //    so no need to apply any snapshots there.
+            // -> don't apply for host mode player objects either, even if in
+            //    client authority mode. if it doesn't go over the network,
+            //    then we don't need to do anything.
+            if (clientAuthority && !hasAuthority)
+            {
+                // compute snapshot interpolation & apply if any was spit out
+                // TODO we don't have Time.deltaTime double yet. float is fine.
+                if (SnapshotInterpolation.Compute(
+                    NetworkTime.localTime, Time.deltaTime,
+                    ref serverInterpolationTime,
+                    bufferTime, serverBuffer,
+                    catchupThreshold, catchupMultiplier,
+                    Interpolate,
+                    out NTSnapshot computed))
+                {
+                    NTSnapshot start = serverBuffer.Values[0];
+                    NTSnapshot goal = serverBuffer.Values[1];
+                    ApplySnapshot(start, goal, computed);
+                }
+            }
+        }
+
+        void UpdateClient()
+        {
+            // client authority, and local player (= allowed to move myself)?
+            if (IsClientWithAuthority)
+            {
+                // https://github.com/vis2k/Mirror/pull/2992/
+                if (!NetworkClient.ready) return;
+
+                // send to server each 'sendInterval'
+                // NetworkTime.localTime for double precision until Unity has it too
+                //
+                // IMPORTANT:
+                // snapshot interpolation requires constant sending.
+                // DO NOT only send if position changed. for example:
+                // ---
+                // * client sends first position at t=0
+                // * ... 10s later ...
+                // * client moves again, sends second position at t=10
+                // ---
+                // * server gets first position at t=0
+                // * server gets second position at t=10
+                // * server moves from first to second within a time of 10s
+                //   => would be a super slow move, instead of a wait & move.
+                //
+                // IMPORTANT:
+                // DO NOT send nulls if not changed 'since last send' either. we
+                // send unreliable and don't know which 'last send' the other end
+                // received successfully.
+                if (NetworkTime.localTime >= lastClientSendTime + sendInterval)
+                {
+                    // send snapshot without timestamp.
+                    // receiver gets it from batch timestamp to save bandwidth.
+                    NTSnapshot snapshot = ConstructSnapshot();
+#if onlySyncOnChange_BANDWIDTH_SAVING
+                    cachedSnapshotComparison = CompareSnapshots(snapshot);
+                    if (cachedSnapshotComparison && hasSentUnchangedPosition && onlySyncOnChange) { return; }
+#endif
+
+#if onlySyncOnChange_BANDWIDTH_SAVING
+                    CmdClientToServerSync(
+                        // only sync what the user wants to sync
+                        syncPosition && positionChanged ? snapshot.position : default(Vector3?),
+                        syncRotation && rotationChanged ? snapshot.rotation : default(Quaternion?),
+                        syncScale && scaleChanged ? snapshot.scale : default(Vector3?)
+                    );
+#else
+                    CmdClientToServerSync(
+                        // only sync what the user wants to sync
+                        syncPosition ? snapshot.position : default(Vector3?),
+                        syncRotation ? snapshot.rotation : default(Quaternion?),
+                        syncScale ? snapshot.scale : default(Vector3?)
+                    );
+#endif
+
+                    lastClientSendTime = NetworkTime.localTime;
+#if onlySyncOnChange_BANDWIDTH_SAVING
+                    if (cachedSnapshotComparison)
+                    {
+                        hasSentUnchangedPosition = true;
+                    }
+                    else
+                    {
+                        hasSentUnchangedPosition = false;
+                        lastSnapshot = snapshot;
+                    }
+#endif
+                }
+            }
+            // for all other clients (and for local player if !authority),
+            // we need to apply snapshots from the buffer
+            else
+            {
+                // compute snapshot interpolation & apply if any was spit out
+                // TODO we don't have Time.deltaTime double yet. float is fine.
+                if (SnapshotInterpolation.Compute(
+                    NetworkTime.localTime, Time.deltaTime,
+                    ref clientInterpolationTime,
+                    bufferTime, clientBuffer,
+                    catchupThreshold, catchupMultiplier,
+                    Interpolate,
+                    out NTSnapshot computed))
+                {
+                    NTSnapshot start = clientBuffer.Values[0];
+                    NTSnapshot goal = clientBuffer.Values[1];
+                    ApplySnapshot(start, goal, computed);
+                }
+            }
+        }
+
+        void Update()
+        {
+            // if server then always sync to others.
+            if (isServer) UpdateServer();
+            // 'else if' because host mode shouldn't send anything to server.
+            // it is the server. don't overwrite anything there.
+            else if (isClient) UpdateClient();
+        }
+
+        // common Teleport code for client->server and server->client
+        protected virtual void OnTeleport(Vector3 destination)
+        {
+            // reset any in-progress interpolation & buffers
+            Reset();
+
+            // set the new position.
+            // interpolation will automatically continue.
+            targetComponent.position = destination;
+
+            // TODO
+            // what if we still receive a snapshot from before the interpolation?
+            // it could easily happen over unreliable.
+            // -> maybe add destionation as first entry?
+        }
+
+        // common Teleport code for client->server and server->client
+        protected virtual void OnTeleport(Vector3 destination, Quaternion rotation)
+        {
+            // reset any in-progress interpolation & buffers
+            Reset();
+
+            // set the new position.
+            // interpolation will automatically continue.
+            targetComponent.position = destination;
+            targetComponent.rotation = rotation;
+
+            // TODO
+            // what if we still receive a snapshot from before the interpolation?
+            // it could easily happen over unreliable.
+            // -> maybe add destionation as first entry?
+        }
+
+        // server->client teleport to force position without interpolation.
+        // otherwise it would interpolate to a (far away) new position.
+        // => manually calling Teleport is the only 100% reliable solution.
+        [ClientRpc]
+        public void RpcTeleport(Vector3 destination)
+        {
+            // NOTE: even in client authority mode, the server is always allowed
+            //       to teleport the player. for example:
+            //       * CmdEnterPortal() might teleport the player
+            //       * Some people use client authority with server sided checks
+            //         so the server should be able to reset position if needed.
+
+            // TODO what about host mode?
+            OnTeleport(destination);
+        }
+
+        // server->client teleport to force position and rotation without interpolation.
+        // otherwise it would interpolate to a (far away) new position.
+        // => manually calling Teleport is the only 100% reliable solution.
+        [ClientRpc]
+        public void RpcTeleport(Vector3 destination, Quaternion rotation)
+        {
+            // NOTE: even in client authority mode, the server is always allowed
+            //       to teleport the player. for example:
+            //       * CmdEnterPortal() might teleport the player
+            //       * Some people use client authority with server sided checks
+            //         so the server should be able to reset position if needed.
+
+            // TODO what about host mode?
+            OnTeleport(destination, rotation);
+        }
+
+        // Deprecated 2022-01-19
+        [Obsolete("Use RpcTeleport(Vector3, Quaternion) instead.")]
+        [ClientRpc]
+        public void RpcTeleportAndRotate(Vector3 destination, Quaternion rotation)
+        {
+            OnTeleport(destination, rotation);
+        }
+
+        // client->server teleport to force position without interpolation.
+        // otherwise it would interpolate to a (far away) new position.
+        // => manually calling Teleport is the only 100% reliable solution.
+        [Command]
+        public void CmdTeleport(Vector3 destination)
+        {
+            // client can only teleport objects that it has authority over.
+            if (!clientAuthority) return;
+
+            // TODO what about host mode?
+            OnTeleport(destination);
+
+            // if a client teleports, we need to broadcast to everyone else too
+            // TODO the teleported client should ignore the rpc though.
+            //      otherwise if it already moved again after teleporting,
+            //      the rpc would come a little bit later and reset it once.
+            // TODO or not? if client ONLY calls Teleport(pos), the position
+            //      would only be set after the rpc. unless the client calls
+            //      BOTH Teleport(pos) and targetComponent.position=pos
+            RpcTeleport(destination);
+        }
+
+        // client->server teleport to force position and rotation without interpolation.
+        // otherwise it would interpolate to a (far away) new position.
+        // => manually calling Teleport is the only 100% reliable solution.
+        [Command]
+        public void CmdTeleport(Vector3 destination, Quaternion rotation)
+        {
+            // client can only teleport objects that it has authority over.
+            if (!clientAuthority) return;
+
+            // TODO what about host mode?
+            OnTeleport(destination, rotation);
+
+            // if a client teleports, we need to broadcast to everyone else too
+            // TODO the teleported client should ignore the rpc though.
+            //      otherwise if it already moved again after teleporting,
+            //      the rpc would come a little bit later and reset it once.
+            // TODO or not? if client ONLY calls Teleport(pos), the position
+            //      would only be set after the rpc. unless the client calls
+            //      BOTH Teleport(pos) and targetComponent.position=pos
+            RpcTeleport(destination, rotation);
+        }
+
+        // Deprecated 2022-01-19
+        [Obsolete("Use CmdTeleport(Vector3, Quaternion) instead.")]
+        [Command]
+        public void CmdTeleportAndRotate(Vector3 destination, Quaternion rotation)
+        {
+            if (!clientAuthority) return;
+            OnTeleport(destination, rotation);
+            RpcTeleport(destination, rotation);
+        }
+
+        public virtual void Reset()
+        {
+            // disabled objects aren't updated anymore.
+            // so let's clear the buffers.
+            serverBuffer.Clear();
+            clientBuffer.Clear();
+
+            // reset interpolation time too so we start at t=0 next time
+            serverInterpolationTime = 0;
+            clientInterpolationTime = 0;
+        }
+
+        protected virtual void OnDisable() => Reset();
+        protected virtual void OnEnable() => Reset();
+
+        protected virtual void OnValidate()
+        {
+            // make sure that catchup threshold is > buffer multiplier.
+            // for a buffer multiplier of '3', we usually have at _least_ 3
+            // buffered snapshots. often 4-5 even.
+            //
+            // catchUpThreshold should be a minimum of bufferTimeMultiplier + 3,
+            // to prevent clashes with SnapshotInterpolation looking for at least
+            // 3 old enough buffers, else catch up will be implemented while there
+            // is not enough old buffers, and will result in jitter.
+            // (validated with several real world tests by ninja & imer)
+            catchupThreshold = Mathf.Max(bufferTimeMultiplier + 3, catchupThreshold);
+
+            // buffer limit should be at least multiplier to have enough in there
+            bufferSizeLimit = Mathf.Max(bufferTimeMultiplier, bufferSizeLimit);
+        }
+        
+        public override bool OnSerialize(NetworkWriter writer, bool initialState)
+        {
+            // sync target component's position on spawn.
+            // fixes https://github.com/vis2k/Mirror/pull/3051/
+            // (Spawn message wouldn't sync NTChild positions either)
+            if (initialState)
+            {
+                if (syncPosition) writer.WriteVector3(targetComponent.localPosition);
+                if (syncRotation) writer.WriteQuaternion(targetComponent.localRotation);
+                if (syncScale)    writer.WriteVector3(targetComponent.localScale);
+                return true;
+            }
+            return false;
+        }
+
+        public override void OnDeserialize(NetworkReader reader, bool initialState)
+        {
+            // sync target component's position on spawn.
+            // fixes https://github.com/vis2k/Mirror/pull/3051/
+            // (Spawn message wouldn't sync NTChild positions either)
+            if (initialState)
+            {
+                if (syncPosition) targetComponent.localPosition = reader.ReadVector3();
+                if (syncRotation) targetComponent.localRotation = reader.ReadQuaternion();
+                if (syncScale)    targetComponent.localScale = reader.ReadVector3();
+            }
+        }
+
+        // OnGUI allocates even if it does nothing. avoid in release.
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+        // debug ///////////////////////////////////////////////////////////////
+        protected virtual void OnGUI()
+        {
+            if (!showOverlay) return;
+
+            // show data next to player for easier debugging. this is very useful!
+            // IMPORTANT: this is basically an ESP hack for shooter games.
+            //            DO NOT make this available with a hotkey in release builds
+            if (!Debug.isDebugBuild) return;
+
+            // project position to screen
+            Vector3 point = Camera.main.WorldToScreenPoint(targetComponent.position);
+
+            // enough alpha, in front of camera and in screen?
+            if (point.z >= 0 && Utils.IsPointInScreen(point))
+            {
+                // catchup is useful to show too
+                int serverBufferExcess = Mathf.Max(serverBuffer.Count - catchupThreshold, 0);
+                int clientBufferExcess = Mathf.Max(clientBuffer.Count - catchupThreshold, 0);
+                float serverCatchup = serverBufferExcess * catchupMultiplier;
+                float clientCatchup = clientBufferExcess * catchupMultiplier;
+
+                GUI.color = overlayColor;
+                GUILayout.BeginArea(new Rect(point.x, Screen.height - point.y, 200, 100));
+
+                // always show both client & server buffers so it's super
+                // obvious if we accidentally populate both.
+                GUILayout.Label($"Server Buffer:{serverBuffer.Count}");
+                if (serverCatchup > 0)
+                    GUILayout.Label($"Server Catchup:{serverCatchup * 100:F2}%");
+
+                GUILayout.Label($"Client Buffer:{clientBuffer.Count}");
+                if (clientCatchup > 0)
+                    GUILayout.Label($"Client Catchup:{clientCatchup * 100:F2}%");
+
+                GUILayout.EndArea();
+                GUI.color = Color.white;
+            }
+        }
+
+        protected virtual void DrawGizmos(SortedList<double, NTSnapshot> buffer)
+        {
+            // only draw if we have at least two entries
+            if (buffer.Count < 2) return;
+
+            // calcluate threshold for 'old enough' snapshots
+            double threshold = NetworkTime.localTime - bufferTime;
+            Color oldEnoughColor = new Color(0, 1, 0, 0.5f);
+            Color notOldEnoughColor = new Color(0.5f, 0.5f, 0.5f, 0.3f);
+
+            // draw the whole buffer for easier debugging.
+            // it's worth seeing how much we have buffered ahead already
+            for (int i = 0; i < buffer.Count; ++i)
+            {
+                // color depends on if old enough or not
+                NTSnapshot entry = buffer.Values[i];
+                bool oldEnough = entry.localTimestamp <= threshold;
+                Gizmos.color = oldEnough ? oldEnoughColor : notOldEnoughColor;
+                Gizmos.DrawCube(entry.position, Vector3.one);
+            }
+
+            // extra: lines between start<->position<->goal
+            Gizmos.color = Color.green;
+            Gizmos.DrawLine(buffer.Values[0].position, targetComponent.position);
+            Gizmos.color = Color.white;
+            Gizmos.DrawLine(targetComponent.position, buffer.Values[1].position);
+        }
+
+        protected virtual void OnDrawGizmos()
+        {
+            // This fires in edit mode but that spams NRE's so check isPlaying
+            if (!Application.isPlaying) return;
+            if (!showGizmos) return;
+
+            if (isServer) DrawGizmos(serverBuffer);
+            if (isClient) DrawGizmos(clientBuffer);
+        }
+#endif
+    }
+}

Assets/Mirror/Components/NetworkTransform2k/NetworkTransformBase.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2e77294d8ccbc4e7cb8ca2bd0d3e99ea
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkTransform2k/NetworkTransformChild.cs

@@ -0,0 +1,14 @@
+// A component to synchronize the position of child transforms of networked objects.
+// There must be a NetworkTransform on the root object of the hierarchy. There can be multiple NetworkTransformChild components on an object. This does not use physics for synchronization, it simply synchronizes the localPosition and localRotation of the child transform and lerps towards the recieved values.
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/Network Transform Child")]
+    public class NetworkTransformChild : NetworkTransformBase
+    {
+        [Header("Target")]
+        public Transform target;
+        protected override Transform targetComponent => target;
+    }
+}

Assets/Mirror/Components/NetworkTransform2k/NetworkTransformChild.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 734b48bea0b204338958ee3d885e11f0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Components/NetworkTransform2k/NetworkTransformSnapshot.cs

@@ -0,0 +1,64 @@
+// snapshot for snapshot interpolation
+// https://gafferongames.com/post/snapshot_interpolation/
+// position, rotation, scale for compatibility for now.
+using UnityEngine;
+
+namespace Mirror
+{
+    // NetworkTransform Snapshot
+    public struct NTSnapshot : Snapshot
+    {
+        // time or sequence are needed to throw away older snapshots.
+        //
+        // glenn fiedler starts with a 16 bit sequence number.
+        // supposedly this is meant as a simplified example.
+        // in the end we need the remote timestamp for accurate interpolation
+        // and buffering over time.
+        //
+        // note: in theory, IF server sends exactly(!) at the same interval then
+        //       the 16 bit ushort timestamp would be enough to calculate the
+        //       remote time (sequence * sendInterval). but Unity's update is
+        //       not guaranteed to run on the exact intervals / do catchup.
+        //       => remote timestamp is better for now
+        //
+        // [REMOTE TIME, NOT LOCAL TIME]
+        // => DOUBLE for long term accuracy & batching gives us double anyway
+        public double remoteTimestamp { get; set; }
+        // the local timestamp (when we received it)
+        // used to know if the first two snapshots are old enough to start.
+        public double localTimestamp { get; set; }
+
+        public Vector3 position;
+        public Quaternion rotation;
+        public Vector3 scale;
+
+        public NTSnapshot(double remoteTimestamp, double localTimestamp, Vector3 position, Quaternion rotation, Vector3 scale)
+        {
+            this.remoteTimestamp = remoteTimestamp;
+            this.localTimestamp = localTimestamp;
+            this.position = position;
+            this.rotation = rotation;
+            this.scale = scale;
+        }
+
+        public static NTSnapshot Interpolate(NTSnapshot from, NTSnapshot to, double t)
+        {
+            // NOTE:
+            // Vector3 & Quaternion components are float anyway, so we can
+            // keep using the functions with 't' as float instead of double.
+            return new NTSnapshot(
+                // interpolated snapshot is applied directly. don't need timestamps.
+                0, 0,
+                // lerp position/rotation/scale unclamped in case we ever need
+                // to extrapolate. atm SnapshotInterpolation never does.
+                Vector3.LerpUnclamped(from.position, to.position, (float)t),
+                // IMPORTANT: LerpUnclamped(0, 60, 1.5) extrapolates to ~86.
+                //            SlerpUnclamped(0, 60, 1.5) extrapolates to 90!
+                //            (0, 90, 1.5) is even worse. for Lerp.
+                //            => Slerp works way better for our euler angles.
+                Quaternion.SlerpUnclamped(from.rotation, to.rotation, (float)t),
+                Vector3.LerpUnclamped(from.scale, to.scale, (float)t)
+            );
+        }
+    }
+}

Assets/Mirror/Components/NetworkTransform2k/NetworkTransformSnapshot.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d3dae77b43dc4e1dbb2012924b2da79c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2539267b6934a4026a505690a1e1eda2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Editor/AndroidManifestHelper.cs

@@ -0,0 +1,113 @@
+// Android NetworkDiscovery Multicast fix
+// https://github.com/vis2k/Mirror/pull/2887
+using UnityEditor;
+using UnityEngine;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using System.Xml;
+using System.IO;
+#if UNITY_ANDROID
+using UnityEditor.Android;
+#endif
+
+
+[InitializeOnLoad]
+public class AndroidManifestHelper : IPreprocessBuildWithReport, IPostprocessBuildWithReport
+#if UNITY_ANDROID
+	, IPostGenerateGradleAndroidProject
+#endif
+{
+    public int callbackOrder { get { return 99999; } }
+
+#if UNITY_ANDROID
+    public void OnPostGenerateGradleAndroidProject(string path)
+	{
+        string manifestFolder = Path.Combine(path, "src/main");
+        string sourceFile = manifestFolder + "/AndroidManifest.xml";
+        // Load android manfiest file
+        XmlDocument doc = new XmlDocument();
+        doc.Load(sourceFile);
+
+        string androidNamepsaceURI;
+        XmlElement element = (XmlElement)doc.SelectSingleNode("/manifest");
+        if (element == null)
+        {
+            UnityEngine.Debug.LogError("Could not find manifest tag in android manifest.");
+            return;
+        }
+
+        // Get android namespace URI from the manifest
+        androidNamepsaceURI = element.GetAttribute("xmlns:android");
+        if (string.IsNullOrEmpty(androidNamepsaceURI))
+        {
+            UnityEngine.Debug.LogError("Could not find Android Namespace in manifest.");
+            return;
+        }
+        AddOrRemoveTag(doc,
+               androidNamepsaceURI,
+               "/manifest",
+               "uses-permission",
+               "android.permission.CHANGE_WIFI_MULTICAST_STATE",
+               true,
+               false);
+        AddOrRemoveTag(doc,
+               androidNamepsaceURI,
+               "/manifest",
+               "uses-permission",
+               "android.permission.INTERNET",
+               true,
+               false);
+        doc.Save(sourceFile);
+    }
+#endif
+
+    static void AddOrRemoveTag(XmlDocument doc, string @namespace, string path, string elementName, string name, bool required, bool modifyIfFound, params string[] attrs) // name, value pairs	
+    {
+        var nodes = doc.SelectNodes(path + "/" + elementName);
+        XmlElement element = null;
+        foreach (XmlElement e in nodes)
+        {
+            if (name == null || name == e.GetAttribute("name", @namespace))
+            {
+                element = e;
+                break;
+            }
+        }
+
+        if (required)
+        {
+            if (element == null)
+            {
+                var parent = doc.SelectSingleNode(path);
+                element = doc.CreateElement(elementName);
+                element.SetAttribute("name", @namespace, name);
+                parent.AppendChild(element);
+            }
+
+            for (int i = 0; i < attrs.Length; i += 2)
+            {
+                if (modifyIfFound || string.IsNullOrEmpty(element.GetAttribute(attrs[i], @namespace)))
+                {
+                    if (attrs[i + 1] != null)
+                    {
+                        element.SetAttribute(attrs[i], @namespace, attrs[i + 1]);
+                    }
+                    else
+                    {
+                        element.RemoveAttribute(attrs[i], @namespace);
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (element != null && modifyIfFound)
+            {
+                element.ParentNode.RemoveChild(element);
+            }
+        }
+    }
+
+    public void OnPostprocessBuild(BuildReport report) {}
+	public void OnPreprocessBuild(BuildReport report) {}
+}

Assets/Mirror/Editor/AndroidManifestHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 80cc70189403d7444bbffd185ca28462
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Editor/EditorHelper.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mirror
+{
+    public static class EditorHelper
+    {
+        public static string FindPath<T>()
+        {
+            string typeName = typeof(T).Name;
+
+            string[] guidsFound = AssetDatabase.FindAssets($"t:Script {typeName}");
+            if (guidsFound.Length >= 1 && !string.IsNullOrWhiteSpace(guidsFound[0]))
+            {
+                if (guidsFound.Length > 1)
+                {
+                    Debug.LogWarning($"Found more than one{typeName}");
+                }
+
+                string path = AssetDatabase.GUIDToAssetPath(guidsFound[0]);
+                return Path.GetDirectoryName(path);
+            }
+            else
+            {
+                Debug.LogError($"Could not find path of {typeName}");
+                return string.Empty;
+            }
+        }
+    }
+}

Assets/Mirror/Editor/EditorHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dba787f167ff29c4288532af1ec3584c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mirror/Editor/Empty.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 62c8dc5bb12bbc6428bb66ccbac57000
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: