aha

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,192 @@
+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<NetworkConnectionToClient> connectionsPendingDisconnect = new HashSet<NetworkConnectionToClient>();
+
+        #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 unregistered in this method.</para>
+        /// </summary>
+        public override void OnStopServer()
+        {
+            // unregister the handler for the authentication request
+            NetworkServer.UnregisterHandler<AuthRequestMessage>();
+        }
+
+        /// <summary>
+        /// Called on server from OnServerConnectInternal 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 OnClientConnectInternal when a client needs to authenticate
+        /// </summary>
+        public override void OnClientAuthenticate()
+        {
+            AuthRequestMessage authRequestMessage = new AuthRequestMessage
+            {
+                authUsername = username,
+                authPassword = password
+            };
+
+            NetworkClient.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,18 @@
+fileFormatVersion: 2
+guid: 28496b776660156428f00cf78289c1ec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Authenticators/BasicAuthenticator.cs
+  uploadId: 736421

Assets/Mirror/Authenticators/DeviceAuthenticator.cs

@@ -0,0 +1,129 @@
+using System;
+using UnityEngine;
+
+namespace Mirror.Authenticators
+{
+    /// <summary>
+    /// An authenticator 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 OnServerConnectInternal 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 OnClientConnectInternal 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.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,18 @@
+fileFormatVersion: 2
+guid: 60960a6ba81a842deb2fdcdc93788242
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Authenticators/DeviceAuthenticator.cs
+  uploadId: 736421

Assets/Mirror/Authenticators/Mirror.Authenticators.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Mirror.Authenticators",
+    "rootNamespace": "",
+    "references": [
+        "GUID:30817c1a0e6d646d99c048fc403f5979"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

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

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: e720aa64e3f58fb4880566a322584340
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Authenticators/Mirror.Authenticators.asmdef
+  uploadId: 736421

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,18 @@
+fileFormatVersion: 2
+guid: 24d8269a07b8e4edfa374753a91c946e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Authenticators/TimeoutAuthenticator.cs
+  uploadId: 736421

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,14 @@
+fileFormatVersion: 2
+guid: 325984b52e4128546bc7558552f8b1d2
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/CompilerSymbols/Mirror.CompilerSymbols.asmdef
+  uploadId: 736421

Assets/Mirror/CompilerSymbols/PreprocessorDefine.cs

@@ -0,0 +1,45 @@
+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()
+        {
+#if UNITY_2021_2_OR_NEWER
+            string currentDefines = PlayerSettings.GetScriptingDefineSymbols(UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(EditorUserBuildSettings.selectedBuildTargetGroup));
+#else
+            // Deprecated in Unity 2023.1
+            string currentDefines = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
+#endif
+            // Remove oldest when adding next month's symbol.
+            // Keep a rolling 12 months of symbols.
+            HashSet<string> defines = new HashSet<string>(currentDefines.Split(';'))
+            {
+                "MIRROR",
+                "MIRROR_89_OR_NEWER",
+                "MIRROR_90_OR_NEWER",
+                "MIRROR_93_OR_NEWER",
+                "MIRROR_96_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)
+            {
+#if UNITY_2021_2_OR_NEWER
+                PlayerSettings.SetScriptingDefineSymbols(UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(EditorUserBuildSettings.selectedBuildTargetGroup), newDefines);
+#else
+                // Deprecated in Unity 2023.1
+                PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, newDefines);
+#endif
+            }
+        }
+    }
+}

Assets/Mirror/CompilerSymbols/PreprocessorDefine.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: f1d66fe74ec6f42dd974cba37d25d453
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/CompilerSymbols/PreprocessorDefine.cs
+  uploadId: 736421

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,18 @@
+fileFormatVersion: 2
+guid: a65b9283f7a724e70b8e17cb277f4c1e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/AssemblyInfo.cs
+  uploadId: 736421

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,93 @@
+using System;
+using System.Net;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace Mirror.Discovery
+{
+    [Serializable]
+    public class ServerFoundUnityEvent<TResponseType> : UnityEvent<TResponseType> {};
+
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/Network Discovery")]
+    public class NetworkDiscovery : NetworkDiscoveryBase<ServerRequest, ServerResponse>
+    {
+        #region Server
+
+        /// <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,18 @@
+fileFormatVersion: 2
+guid: c761308e733c51245b2e8bb4201f46dc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/Discovery/NetworkDiscovery.cs
+  uploadId: 736421

Assets/Mirror/Components/Discovery/NetworkDiscoveryBase.cs

@@ -0,0 +1,473 @@
+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; } }
+
+        [SerializeField]
+        [Tooltip("If true, broadcasts a discovery request every ActiveDiscoveryInterval seconds")]
+        public bool enableActiveDiscovery = true;
+
+        // broadcast address needs to be configurable on iOS:
+        // https://github.com/vis2k/Mirror/pull/3255
+        [Tooltip("iOS may require LAN IP address here (e.g. 192.168.x.x), otherwise leave blank.")]
+        public string BroadcastAddress = "";
+
+        [SerializeField]
+        [Tooltip("The UDP port the server will listen for multi-cast messages")]
+        protected int serverBroadcastListenPort = 47777;
+
+        [SerializeField]
+        [Tooltip("Time in seconds between multi-cast messages")]
+        [Range(1, 60)]
+        float ActiveDiscoveryInterval = 3;
+
+        [Tooltip("Transport to be advertised during discovery")]
+        public Transport transport;
+
+        [Tooltip("Invoked when a server is found")]
+        public ServerFoundUnityEvent<Response> OnServerFound;
+
+        // 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;
+
+        public long ServerId { get; private set; }
+
+        protected UdpClient serverUdpClient;
+        protected UdpClient clientUdpClient;
+
+#if UNITY_EDITOR
+        public virtual void OnValidate()
+        {
+            if (transport == null)
+                transport = GetComponent<Transport>();
+
+            if (secretHandshake == 0)
+            {
+                secretHandshake = RandomLong();
+                UnityEditor.Undo.RecordObject(this, "Set secret handshake");
+            }
+        }
+#endif
+
+        /// <summary>
+        /// virtual so that inheriting classes' Start() can call base.Start() too
+        /// </summary>
+        public virtual void Start()
+        {
+            ServerId = RandomLong();
+
+            // active transport gets initialized in Awake
+            // so make sure we set it here in Start() after Awake
+            // Or just let the user assign it in the inspector
+            if (transport == null)
+                transport = Transport.active;
+
+            // Server mode? then start advertising
+            if (Utils.IsHeadless())
+            {
+                AdvertiseServer();
+            }
+        }
+
+        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);
+        }
+
+        // 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
+            };
+
+            //Debug.Log($"Discovery: Advertising Server {Dns.GetHostName()}");
+
+            // 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);
+
+            if (!string.IsNullOrWhiteSpace(BroadcastAddress))
+            {
+                try
+                {
+                    endPoint = new IPEndPoint(IPAddress.Parse(BroadcastAddress), serverBroadcastListenPort);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogException(ex);
+                }
+            }
+
+            using (NetworkWriterPooled writer = NetworkWriterPool.Get())
+            {
+                writer.WriteLong(secretHandshake);
+
+                try
+                {
+                    Request request = GetRequest();
+
+                    writer.Write(request);
+
+                    ArraySegment<byte> data = writer.ToArraySegment();
+
+                    //Debug.Log($"Discovery: Sending BroadcastDiscoveryRequest {request}");
+                    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,18 @@
+fileFormatVersion: 2
+guid: b9971d60ce61f4e39b07cd9e7e0c68fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/Discovery/NetworkDiscoveryBase.cs
+  uploadId: 736421

Assets/Mirror/Components/Discovery/NetworkDiscoveryHUD.cs

@@ -0,0 +1,144 @@
+using System.Collections.Generic;
+using System.Linq;
+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 (Application.isPlaying) return;
+            Reset();
+        }
+
+        void Reset()
+        {
+            networkDiscovery = GetComponent<NetworkDiscovery>();
+
+            // Add default event handler if not already present
+            if (!Enumerable.Range(0, networkDiscovery.OnServerFound.GetPersistentEventCount())
+                .Any(i => networkDiscovery.OnServerFound.GetPersistentMethodName(i) == nameof(OnDiscoveredServer)))
+            {
+                UnityEditor.Events.UnityEventTools.AddPersistentListener(networkDiscovery.OnServerFound, OnDiscoveredServer);
+                UnityEditor.Undo.RecordObjects(new UnityEngine.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)
+        {
+            Debug.Log($"Discovered Server: {info.serverId} | {info.EndPoint} | {info.uri}");
+
+            // 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,18 @@
+fileFormatVersion: 2
+guid: 88c37d3deca7a834d80cfd8d3cfcc510
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/Discovery/NetworkDiscoveryHUD.cs
+  uploadId: 736421

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,18 @@
+fileFormatVersion: 2
+guid: ea7254bf7b9454da4adad881d94cd141
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/Discovery/ServerRequest.cs
+  uploadId: 736421

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,18 @@
+fileFormatVersion: 2
+guid: 36f97227fdf2d7a4e902db5bfc43039c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/Discovery/ServerResponse.cs
+  uploadId: 736421

Assets/Mirror/Components/GUIConsole.cs

@@ -0,0 +1,133 @@
+// 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 = 80;
+        public int offsetY = 40;
+
+        // only keep the recent 'n' entries. otherwise memory would grow forever
+        // and drawing would get slower and slower.
+        public int maxLogCount = 50;
+
+        // Unity Editor has the Console window, we don't need to show it there.
+        // unless for testing, so keep it as option.
+        public bool showInEditor = false;
+
+        // log as queue so we can remove the first entry easily
+        readonly Queue<LogEntry> log = new Queue<LogEntry>();
+
+        // hotkey to show/hide at runtime for easier debugging
+        // (sometimes we need to temporarily hide/show it)
+        // Default is BackQuote, because F keys are already assigned in browsers
+        [Tooltip("Hotkey to show/hide the console at runtime\nBack Quote is usually on the left above Tab\nChange with caution - F keys are generally already taken in Browsers")]
+        public KeyCode hotKey = KeyCode.BackQuote;
+
+        // GUI
+        bool visible;
+        Vector2 scroll = Vector2.zero;
+
+        // only show at runtime, or if showInEditor is enabled
+        bool show => !Application.isEditor || showInEditor;
+
+        void Awake()
+        {
+            // only show at runtime, or if showInEditor is enabled
+            if (show)
+                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 (show && Input.GetKeyDown(hotKey))
+                visible = !visible;
+        }
+
+        void OnGUI()
+        {
+            if (!visible) return;
+
+            // If this offset is changed, also change width in NetworkManagerHUD::OnGUI
+            int offsetX = 300 + 20;
+
+            GUILayout.BeginArea(new Rect(offsetX, offsetY, Screen.width - offsetX - 10, height));
+
+            scroll = GUILayout.BeginScrollView(scroll, "Box", GUILayout.Width(Screen.width - offsetX - 10), 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();
+
+            GUILayout.EndArea();
+        }
+    }
+}

Assets/Mirror/Components/GUIConsole.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9021b6cc314944290986ab6feb48db79
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/GUIConsole.cs
+  uploadId: 736421

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,89 @@
+// 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 = 500;
+
+        [Tooltip("Rebuild all every 'rebuildInterval' seconds.")]
+        public float rebuildInterval = 1;
+        double lastRebuildTime;
+
+        // cache custom ranges to avoid runtime TryGetComponent lookups
+        readonly Dictionary<NetworkIdentity, DistanceInterestManagementCustomRange> CustomRanges = new Dictionary<NetworkIdentity, DistanceInterestManagementCustomRange>();
+
+        // helper function to get vis range for a given object, or default.
+        [ServerCallback]
+        int GetVisRange(NetworkIdentity identity)
+        {
+            return CustomRanges.TryGetValue(identity, out DistanceInterestManagementCustomRange custom) ? custom.visRange : visRange;
+        }
+
+        [ServerCallback]
+        public override void ResetState()
+        {
+            lastRebuildTime = 0D;
+            CustomRanges.Clear();
+        }
+
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            if (identity.TryGetComponent(out DistanceInterestManagementCustomRange custom))
+                CustomRanges[identity] = custom;
+        }
+
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            CustomRanges.Remove(identity);
+        }
+
+        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);
+                    }
+                }
+            }
+        }
+
+        [ServerCallback]
+        void LateUpdate()
+        {
+            // 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,18 @@
+fileFormatVersion: 2
+guid: 8f60becab051427fbdd3c8ac9ab4712b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/Distance/DistanceInterestManagement.cs
+  uploadId: 736421

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 = 100;
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: b2e242ee38a14076a39934172a19079b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/Distance/DistanceInterestManagementCustomRange.cs
+  uploadId: 736421

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,164 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Match/Match Interest Management")]
+    public class MatchInterestManagement : InterestManagement
+    {
+        [Header("Diagnostics")]
+        [ReadOnly, SerializeField]
+        internal ushort matchCount;
+
+        readonly Dictionary<Guid, HashSet<NetworkMatch>> matchObjects =
+            new Dictionary<Guid, HashSet<NetworkMatch>>();
+
+        readonly HashSet<Guid> dirtyMatches = new HashSet<Guid>();
+
+        // LateUpdate so that all spawns/despawns/changes are done
+        [ServerCallback]
+        void LateUpdate()
+        {
+            // Rebuild all dirty matches
+            // dirtyMatches will be empty if no matches changed members
+            // by spawning or destroying or changing matchId in this frame.
+            foreach (Guid dirtyMatch in dirtyMatches)
+            {
+                // rebuild always, even if matchObjects[dirtyMatch] is empty.
+                // Players might have left the match, but they may still be spawned.
+                RebuildMatchObservers(dirtyMatch);
+
+                // clean up empty entries in the dict
+                if (matchObjects[dirtyMatch].Count == 0)
+                    matchObjects.Remove(dirtyMatch);
+            }
+
+            dirtyMatches.Clear();
+
+            matchCount = (ushort)matchObjects.Count;
+        }
+
+        [ServerCallback]
+        void RebuildMatchObservers(Guid matchId)
+        {
+            foreach (NetworkMatch networkMatch in matchObjects[matchId])
+                if (networkMatch.netIdentity != null)
+                    NetworkServer.RebuildObservers(networkMatch.netIdentity, false);
+        }
+
+        // called by NetworkMatch.matchId setter
+        [ServerCallback]
+        internal void OnMatchChanged(NetworkMatch networkMatch, Guid oldMatch)
+        {
+            // This object is in a new match so observers in the prior match
+            // and the new match need to rebuild their respective observers lists.
+
+            // Remove this object from the hashset of the match it just left
+            // Guid.Empty is never a valid matchId
+            if (oldMatch != Guid.Empty)
+            {
+                dirtyMatches.Add(oldMatch);
+                matchObjects[oldMatch].Remove(networkMatch);
+            }
+
+            // Guid.Empty is never a valid matchId
+            if (networkMatch.matchId == Guid.Empty)
+                return;
+
+            dirtyMatches.Add(networkMatch.matchId);
+
+            // Make sure this new match is in the dictionary
+            if (!matchObjects.ContainsKey(networkMatch.matchId))
+                matchObjects[networkMatch.matchId] = new HashSet<NetworkMatch>();
+
+            // Add this object to the hashset of the new match
+            matchObjects[networkMatch.matchId].Add(networkMatch);
+        }
+
+        [ServerCallback]
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            if (!identity.TryGetComponent(out NetworkMatch networkMatch))
+                return;
+
+            Guid networkMatchId = networkMatch.matchId;
+
+            // Guid.Empty is never a valid matchId...do not add to matchObjects collection
+            if (networkMatchId == Guid.Empty)
+                return;
+
+            // Debug.Log($"MatchInterestManagement.OnSpawned({identity.name}) currentMatch: {currentMatch}");
+            if (!matchObjects.TryGetValue(networkMatchId, out HashSet<NetworkMatch> objects))
+            {
+                objects = new HashSet<NetworkMatch>();
+                matchObjects.Add(networkMatchId, objects);
+            }
+
+            objects.Add(networkMatch);
+
+            // Match ID could have been set in NetworkBehaviour::OnStartServer on this object.
+            // Since that's after OnCheckObserver is called it would be missed, so force Rebuild here.
+            // Add the current match to dirtyMatches for LateUpdate to rebuild it.
+            dirtyMatches.Add(networkMatchId);
+        }
+
+        [ServerCallback]
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            // Don't RebuildSceneObservers here - that will happen in LateUpdate.
+            // Multiple objects could be destroyed in same frame and we don't
+            // want to rebuild for each one...let LateUpdate do it once.
+            // We must add the current match to dirtyMatches for LateUpdate to rebuild it.
+            if (identity.TryGetComponent(out NetworkMatch currentMatch))
+            {
+                if (currentMatch.matchId != Guid.Empty &&
+                    matchObjects.TryGetValue(currentMatch.matchId, out HashSet<NetworkMatch> objects) &&
+                    objects.Remove(currentMatch))
+                    dirtyMatches.Add(currentMatch.matchId);
+            }
+        }
+
+        [ServerCallback]
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            // Never observed if no NetworkMatch component
+            if (!identity.TryGetComponent(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(out NetworkMatch newObserverNetworkMatch))
+                return false;
+
+            // Guid.Empty is never a valid matchId
+            if (newObserverNetworkMatch.matchId == Guid.Empty)
+                return false;
+
+            return identityNetworkMatch.matchId == newObserverNetworkMatch.matchId;
+        }
+
+        [ServerCallback]
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            if (!identity.TryGetComponent(out NetworkMatch networkMatch))
+                return;
+
+            // Guid.Empty is never a valid matchId
+            if (networkMatch.matchId == Guid.Empty)
+                return;
+
+            // Abort if this match hasn't been created yet by OnSpawned or OnMatchChanged
+            if (!matchObjects.TryGetValue(networkMatch.matchId, out HashSet<NetworkMatch> objects))
+                return;
+
+            // Add everything in the hashset for this object's current match
+            foreach (NetworkMatch netMatch in objects)
+                if (netMatch.netIdentity != null && netMatch.netIdentity.connectionToClient != null)
+                    newObservers.Add(netMatch.netIdentity.connectionToClient);
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: d09f5c8bf2f4747b7a9284ef5d9ce2a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/Match/MatchInterestManagement.cs
+  uploadId: 736421

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

@@ -0,0 +1,42 @@
+// 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
+    {
+        Guid _matchId;
+
+#pragma warning disable IDE0052 // Suppress warning for unused field...this is for debugging purposes
+        [SerializeField, ReadOnly]
+        [Tooltip("Match ID is shown here on server for debugging purposes.")]
+        string MatchID = string.Empty;
+#pragma warning restore IDE0052
+
+        ///<summary>Set this to the same value on all networked objects that belong to a given match</summary>
+        public Guid matchId
+        {
+            get => _matchId;
+            set
+            {
+                if (!NetworkServer.active)
+                    throw new InvalidOperationException("matchId can only be set at runtime on active server");
+
+                if (_matchId == value)
+                    return;
+
+                Guid oldMatch = _matchId;
+                _matchId = value;
+                MatchID = value.ToString();
+
+                // Only inform the AOI if this netIdentity has been spawned (isServer) and only if using a MatchInterestManagement
+                if (isServer && NetworkServer.aoi is MatchInterestManagement matchInterestManagement)
+                    matchInterestManagement.OnMatchChanged(this, oldMatch);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 5d17e718851449a6879986e45c458fb7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/Match/NetworkMatch.cs
+  uploadId: 736421

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,117 @@
+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>();
+
+        [ServerCallback]
+        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);
+        }
+
+        [ServerCallback]
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            // Don't RebuildSceneObservers here - that will happen in LateUpdate.
+            // Multiple objects could be destroyed in same frame and we don't
+            // want to rebuild for each one...let LateUpdate do it once.
+            // We must add the current scene to dirtyScenes for LateUpdate to rebuild it.
+            if (lastObjectScene.TryGetValue(identity, out Scene currentScene))
+            {
+                lastObjectScene.Remove(identity);
+                if (sceneObjects.TryGetValue(currentScene, out HashSet<NetworkIdentity> objects) && objects.Remove(identity))
+                    dirtyScenes.Add(currentScene);
+            }
+        }
+
+        [ServerCallback]
+        void LateUpdate()
+        {
+            // for each spawned:
+            //   if scene changed:
+            //     add previous to dirty
+            //     add new to dirty
+            foreach (NetworkIdentity identity in NetworkServer.spawned.Values)
+            {
+                if (!lastObjectScene.TryGetValue(identity, out Scene currentScene))
+                    continue;
+
+                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,18 @@
+fileFormatVersion: 2
+guid: b979f26c95d34324ba005bfacfa9c4fc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/Scene/SceneInterestManagement.cs
+  uploadId: 736421

Assets/Mirror/Components/InterestManagement/SceneDistance.meta

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

Assets/Mirror/Components/InterestManagement/SceneDistance/SceneDistanceInterestManagement.cs

@@ -0,0 +1,178 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Scene/Scene Distance Interest Management")]
+    public class SceneDistanceInterestManagement : InterestManagement
+    {
+        [Tooltip("The maximum range that objects will be visible at. Add DistanceInterestManagementCustomRange onto NetworkIdentities for custom ranges.")]
+        public int visRange = 500;
+
+        [Tooltip("Rebuild all every 'rebuildInterval' seconds.")]
+        public float rebuildInterval = 1;
+        double lastRebuildTime;
+
+        // cache custom ranges to avoid runtime TryGetComponent lookups
+        readonly Dictionary<NetworkIdentity, DistanceInterestManagementCustomRange> CustomRanges = new Dictionary<NetworkIdentity, DistanceInterestManagementCustomRange>();
+
+        // helper function to get vis range for a given object, or default.
+        [ServerCallback]
+        int GetVisRange(NetworkIdentity identity)
+        {
+            return CustomRanges.TryGetValue(identity, out DistanceInterestManagementCustomRange custom) ? custom.visRange : visRange;
+        }
+
+        [ServerCallback]
+        public override void ResetState()
+        {
+            lastRebuildTime = 0D;
+            CustomRanges.Clear();
+        }
+
+        // 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>();
+
+        [ServerCallback]
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            if (identity.TryGetComponent(out DistanceInterestManagementCustomRange custom))
+                CustomRanges[identity] = custom;
+
+            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);
+        }
+
+        [ServerCallback]
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            CustomRanges.Remove(identity);
+
+            // Don't RebuildSceneObservers here - that will happen in LateUpdate.
+            // Multiple objects could be destroyed in same frame and we don't
+            // want to rebuild for each one...let LateUpdate do it once.
+            // We must add the current scene to dirtyScenes for LateUpdate to rebuild it.
+            if (lastObjectScene.TryGetValue(identity, out Scene currentScene))
+            {
+                lastObjectScene.Remove(identity);
+                if (sceneObjects.TryGetValue(currentScene, out HashSet<NetworkIdentity> objects) && objects.Remove(identity))
+                    dirtyScenes.Add(currentScene);
+            }
+        }
+
+        [ServerCallback]
+        void LateUpdate()
+        {
+            // for each spawned:
+            //   if scene changed:
+            //     add previous to dirty
+            //     add new to dirty
+            //   else
+            //     if rebuild interval reached:
+            //       rebuild all
+            foreach (NetworkIdentity identity in NetworkServer.spawned.Values)
+            {
+                if (!lastObjectScene.TryGetValue(identity, out Scene currentScene))
+                    continue;
+
+                Scene newScene = identity.gameObject.scene;
+                if (newScene == currentScene)
+                {
+                    if (NetworkTime.localTime >= lastRebuildTime + rebuildInterval)
+                    {
+                        RebuildAll();
+                        lastRebuildTime = NetworkTime.localTime;
+                    }
+
+                    // no scene change, so we're done here
+                    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)
+        {
+            // Check for scene match first, then distance
+            if (identity.gameObject.scene != newObserver.identity.gameObject.scene) return false;
+
+            int range = GetVisRange(identity);
+            return Vector3.Distance(identity.transform.position, newObserver.identity.transform.position) < range;
+        }
+
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            // abort if no entry in sceneObjects yet (created in OnSpawned)
+            if (!sceneObjects.TryGetValue(identity.gameObject.scene, out HashSet<NetworkIdentity> objects))
+                return;
+
+            int range = GetVisRange(identity);
+            Vector3 position = identity.transform.position;
+
+            // Add everything in the hashset for this object's current scene if within range
+            foreach (NetworkIdentity networkIdentity in objects)
+                if (networkIdentity != null && networkIdentity.connectionToClient != null)
+                {
+                    // 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.
+                    NetworkConnectionToClient conn = networkIdentity.connectionToClient;
+                    if (conn != null && conn.isAuthenticated && conn.identity != null)
+                        if (Vector3.Distance(conn.identity.transform.position, position) < range)
+                            newObservers.Add(conn);
+                }
+        }
+    }
+}

Assets/Mirror/Components/InterestManagement/SceneDistance/SceneDistanceInterestManagement.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 6471bc9a8f893944783fd54e9bfb6ed2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SceneDistance/SceneDistanceInterestManagement.cs
+  uploadId: 736421

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,104 @@
+// Grid2D from uMMORPG: get/set values of type T at any point
+// -> not named 'Grid' because Unity already has a Grid type. causes warnings.
+// -> struct to avoid memory indirection. it's accessed a lot.
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    // struct to avoid memory indirection. it's accessed a lot.
+    public struct 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!
+        readonly Dictionary<Vector2Int, HashSet<T>> grid;
+
+        // cache a 9 neighbor grid of vector2 offsets so we can use them more easily
+        readonly Vector2Int[] neighbourOffsets;
+
+        public Grid2D(int initialCapacity)
+        {
+            grid = new Dictionary<Vector2Int, HashSet<T>>(initialCapacity);
+
+            neighbourOffsets = new[] {
+                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))
+            {
+                // each grid entry may hold hundreds of entities.
+                // let's create the HashSet with a large initial capacity
+                // in order to avoid resizing & allocations.
+#if !UNITY_2021_3_OR_NEWER
+                // Unity 2019 doesn't have "new HashSet(capacity)" yet
+                hashSet = new HashSet<T>();
+#else
+                hashSet = new HashSet<T>(128);
+#endif
+                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,18 @@
+fileFormatVersion: 2
+guid: 7c5232a4d2854116a35d52b80ec07752
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SpatialHashing/Grid2D.cs
+  uploadId: 736421

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

@@ -0,0 +1,106 @@
+// Grid3D based on Grid2D
+// -> not named 'Grid' because Unity already has a Grid type. causes warnings.
+// -> struct to avoid memory indirection. it's accessed a lot.
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    // struct to avoid memory indirection. it's accessed a lot.
+    public struct Grid3D<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!
+        readonly Dictionary<Vector3Int, HashSet<T>> grid;
+
+        // cache a 9 x 3 neighbor grid of vector3 offsets so we can use them more easily
+        readonly Vector3Int[] neighbourOffsets;
+
+        public Grid3D(int initialCapacity)
+        {
+            grid = new Dictionary<Vector3Int, HashSet<T>>(initialCapacity);
+
+            neighbourOffsets = new Vector3Int[9 * 3];
+            int i = 0;
+            for (int x = -1; x <= 1; x++)
+            {
+                for (int y = -1; y <= 1; y++)
+                {
+                    for (int z = -1; z <= 1; z++)
+                    {
+                        neighbourOffsets[i] = new Vector3Int(x, y, z);
+                        i += 1;
+                    }
+                }
+            }
+        }
+
+        // helper function so we can add an entry without worrying
+        public void Add(Vector3Int position, T value)
+        {
+            // initialize set in grid if it's not in there yet
+            if (!grid.TryGetValue(position, out HashSet<T> hashSet))
+            {
+                // each grid entry may hold hundreds of entities.
+                // let's create the HashSet with a large initial capacity
+                // in order to avoid resizing & allocations.
+#if !UNITY_2021_3_OR_NEWER
+                // Unity 2019 doesn't have "new HashSet(capacity)" yet
+                hashSet = new HashSet<T>();
+#else
+                hashSet = new HashSet<T>(128);
+#endif
+                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(Vector3Int 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(Vector3Int position, HashSet<T> result)
+        {
+            // clear result first
+            result.Clear();
+
+            // add neighbours
+            foreach (Vector3Int 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/Grid3D.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: b157c08313c64752b0856469b1b70771
+timeCreated: 1713533175
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SpatialHashing/Grid3D.cs
+  uploadId: 736421

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

@@ -0,0 +1,170 @@
+using UnityEngine;
+
+namespace Mirror
+{
+    internal class HexGrid2D
+    {
+        // Radius of each hexagonal cell (half the width)
+        internal float cellRadius;
+
+        // Offset applied to align the grid with the world origin
+        Vector2 originOffset;
+
+        // Precomputed constants for hexagon math to improve performance
+        readonly float sqrt3Div3; // sqrt(3) / 3, used in coordinate conversions
+        readonly float oneDiv3;   // 1 / 3, used in coordinate conversions
+        readonly float twoDiv3;   // 2 / 3, used in coordinate conversions
+        readonly float sqrt3;     // sqrt(3), used in world coordinate calculations
+        readonly float sqrt3Div2; // sqrt(3) / 2, used in world coordinate calculations
+
+        internal HexGrid2D(ushort visRange)
+        {
+            // Set cell radius as half the visibility range
+            cellRadius = visRange / 2f;
+
+            // Offset to center the grid at world origin (2D XZ plane)
+            originOffset = Vector2.zero;
+
+            // Precompute mathematical constants for efficiency
+            sqrt3Div3 = Mathf.Sqrt(3) / 3f;
+            oneDiv3 = 1f / 3f;
+            twoDiv3 = 2f / 3f;
+            sqrt3 = Mathf.Sqrt(3);
+            sqrt3Div2 = Mathf.Sqrt(3) / 2f;
+        }
+
+        // Precomputed array of neighbor offsets as Cell2D structs (center + 6 neighbors)
+        static readonly Cell2D[] neighborCellsBase = new Cell2D[]
+        {
+        new Cell2D(0, 0),         // Center
+        new Cell2D(1, -1),        // Top-right
+        new Cell2D(1, 0),         // Right
+        new Cell2D(0, 1),         // Bottom-right
+        new Cell2D(-1, 1),        // Bottom-left
+        new Cell2D(-1, 0),        // Left
+        new Cell2D(0, -1)         // Top-left
+        };
+
+        // Converts a grid cell (q, r) to a world position (x, z)
+        internal Vector2 CellToWorld(Cell2D cell)
+        {
+            // Calculate X and Z using hexagonal coordinate formulas
+            float x = cellRadius * (sqrt3 * cell.q + sqrt3Div2 * cell.r);
+            float z = cellRadius * (1.5f * cell.r);
+
+            // Subtract the origin offset to align with world space and return the position
+            return new Vector2(x, z) - originOffset;
+        }
+
+        // Converts a world position (x, z) to a grid cell (q, r)
+        internal Cell2D WorldToCell(Vector2 position)
+        {
+            // Apply the origin offset to adjust the position before conversion
+            position += originOffset;
+
+            // Convert world X, Z to axial q, r coordinates using inverse hexagonal formulas
+            float q = (sqrt3Div3 * position.x - oneDiv3 * position.y) / cellRadius;
+            float r = (twoDiv3 * position.y) / cellRadius;
+
+            // Round to the nearest valid cell and return
+            return RoundToCell(q, r);
+        }
+
+        // Rounds floating-point axial coordinates (q, r) to the nearest integer cell coordinates
+        Cell2D RoundToCell(float q, float r)
+        {
+            // Calculate the third hexagonal coordinate (s) for consistency
+            float s = -q - r;
+            int qInt = Mathf.RoundToInt(q); // Round q to nearest integer
+            int rInt = Mathf.RoundToInt(r); // Round r to nearest integer
+            int sInt = Mathf.RoundToInt(s); // Round s to nearest integer
+
+            // Calculate differences to determine which coordinate needs adjustment
+            float qDiff = Mathf.Abs(q - qInt);
+            float rDiff = Mathf.Abs(r - rInt);
+            float sDiff = Mathf.Abs(s - sInt);
+
+            // Adjust q or r based on which has the largest rounding error (ensures q + r + s = 0)
+            if (qDiff > rDiff && qDiff > sDiff)
+                qInt = -rInt - sInt; // Adjust q if it has the largest error
+            else if (rDiff > sDiff)
+                rInt = -qInt - sInt; // Adjust r if it has the largest error
+
+            return new Cell2D(qInt, rInt);
+        }
+
+        // Populates the provided array with neighboring cells around a given center cell
+        internal void GetNeighborCells(Cell2D center, Cell2D[] neighbors)
+        {
+            // Ensure the array has the correct size (7: center + 6 neighbors)
+            if (neighbors.Length != 7)
+                throw new System.ArgumentException("Neighbor array must have exactly 7 elements");
+
+            // Populate the array by adjusting precomputed offsets with the center cell's coordinates
+            for (int i = 0; i < neighborCellsBase.Length; i++)
+            {
+                neighbors[i] = new Cell2D(
+                    center.q + neighborCellsBase[i].q,
+                    center.r + neighborCellsBase[i].r
+                );
+            }
+        }
+
+#if UNITY_EDITOR
+        // Draws a 2D hexagonal gizmo in the Unity Editor for visualization
+        internal void DrawHexGizmo(Vector3 center, float radius, HexSpatialHash2DInterestManagement.CheckMethod checkMethod)
+        {
+            // Hexagon has 6 sides
+            const int segments = 6;
+
+            // Array to store the 6 corner points in 3D
+            Vector3[] corners = new Vector3[segments];
+
+            // Calculate the corner positions based on the plane (XZ or XY)
+            for (int i = 0; i < segments; i++)
+            {
+                // Angle for each corner, offset by 90 degrees
+                float angle = 2 * Mathf.PI / segments * i + Mathf.PI / 2;
+
+                if (checkMethod == HexSpatialHash2DInterestManagement.CheckMethod.XZ_FOR_3D)
+                {
+                    // XZ plane: flat hexagon, Y=0
+                    corners[i] = center + new Vector3(radius * Mathf.Cos(angle), 0, radius * Mathf.Sin(angle));
+                }
+                else // XY_FOR_2D
+                {
+                    // XY plane: vertical hexagon, Z=0
+                    corners[i] = center + new Vector3(radius * Mathf.Cos(angle), radius * Mathf.Sin(angle), 0);
+                }
+            }
+
+            // Draw each side of the hexagon
+            for (int i = 0; i < segments; i++)
+            {
+                Vector3 cornerA = corners[i];
+                Vector3 cornerB = corners[(i + 1) % segments];
+                Gizmos.DrawLine(cornerA, cornerB);
+            }
+        }
+#endif
+    }
+
+    // Struct representing a single cell in the 2D hexagonal grid
+    internal struct Cell2D
+    {
+        internal readonly int q; // Axial q coordinate (horizontal axis)
+        internal readonly int r; // Axial r coordinate (diagonal axis)
+
+        internal Cell2D(int q, int r)
+        {
+            this.q = q;
+            this.r = r;
+        }
+
+        public override bool Equals(object obj) =>
+            obj is Cell2D other && q == other.q && r == other.r;
+
+        // Generate a unique hash code for the cell
+        public override int GetHashCode() => (q << 16) ^ r;
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: e9b8dc0273250624c91b6681065741ff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SpatialHashing/HexGrid2D.cs
+  uploadId: 736421

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

@@ -0,0 +1,243 @@
+using UnityEngine;
+
+namespace Mirror
+{
+    internal class HexGrid3D
+    {
+        // Radius of each hexagonal cell (half the width)
+        internal float cellRadius;
+
+        // Height of each cell along the Y-axis
+        internal float cellHeight;
+
+        // Offset applied to align the grid with the world origin
+        Vector3 originOffset;
+
+        // Precomputed constants for hexagon math to improve performance
+        readonly float sqrt3Div3; // sqrt(3) / 3, used in coordinate conversions
+        readonly float oneDiv3;   // 1 / 3, used in coordinate conversions
+        readonly float twoDiv3;   // 2 / 3, used in coordinate conversions
+        readonly float sqrt3;     // sqrt(3), used in world coordinate calculations
+        readonly float sqrt3Div2; // sqrt(3) / 2, used in world coordinate calculations
+
+        internal HexGrid3D(ushort visRange, ushort height)
+        {
+            // Set cell radius as half the visibility range
+            cellRadius = visRange / 2f;
+
+            // Cell3D height is absolute...don't double it
+            cellHeight = height;
+
+            // Offset to center the grid at world origin
+            // Cell3D height must be divided by 2 for vertical centering
+            originOffset = new Vector3(0, -cellHeight / 2, 0);
+
+            // Precompute mathematical constants for efficiency
+            sqrt3Div3 = Mathf.Sqrt(3) / 3f;
+            oneDiv3 = 1f / 3f;
+            twoDiv3 = 2f / 3f;
+            sqrt3 = Mathf.Sqrt(3);
+            sqrt3Div2 = Mathf.Sqrt(3) / 2f;
+        }
+
+        // Precomputed array of neighbor offsets as Cell3D structs (center + 6 per layer x 3 layers)
+        static readonly Cell3D[] neighborCellsBase = new Cell3D[]
+        {
+        // Center
+        new Cell3D(0, 0, 0),
+        // Upper layer (1) and its 6 neighbors
+        new Cell3D(0, 0, 1),
+        new Cell3D(1, -1, 1), new Cell3D(1, 0, 1), new Cell3D(0, 1, 1),
+        new Cell3D(-1, 1, 1), new Cell3D(-1, 0, 1), new Cell3D(0, -1, 1),
+        // Same layer (0) - 6 neighbors
+        new Cell3D(1, -1, 0), new Cell3D(1, 0, 0), new Cell3D(0, 1, 0),
+        new Cell3D(-1, 1, 0), new Cell3D(-1, 0, 0), new Cell3D(0, -1, 0),
+        // Lower layer (-1) and its 6 neighbors
+        new Cell3D(0, 0, -1),
+        new Cell3D(1, -1, -1), new Cell3D(1, 0, -1), new Cell3D(0, 1, -1),
+        new Cell3D(-1, 1, -1), new Cell3D(-1, 0, -1), new Cell3D(0, -1, -1)
+        };
+
+        // Converts a grid cell (q, r, layer) to a world position (x, y, z)
+        internal Vector3 CellToWorld(Cell3D cell)
+        {
+            // Calculate X and Z using hexagonal coordinate formulas
+            float x = cellRadius * (sqrt3 * cell.q + sqrt3Div2 * cell.r);
+            float z = cellRadius * (1.5f * cell.r);
+
+            // Calculate Y based on layer and cell height
+            float y = cell.layer * cellHeight + cellHeight / 2;
+
+            // Subtract the origin offset to align with world space and return the position
+            return new Vector3(x, y, z) - originOffset;
+        }
+
+        // Converts a world position (x, y, z) to a grid cell (q, r, layer)
+        internal Cell3D WorldToCell(Vector3 position)
+        {
+            // Apply the origin offset to adjust the position before conversion
+            position += originOffset;
+
+            // Calculate the vertical layer based on Y position
+            int layer = Mathf.FloorToInt(position.y / cellHeight);
+
+            // Convert world X, Z to axial q, r coordinates using inverse hexagonal formulas
+            float q = (sqrt3Div3 * position.x - oneDiv3 * position.z) / cellRadius;
+            float r = (twoDiv3 * position.z) / cellRadius;
+
+            // Round to the nearest valid cell and return
+            return RoundToCell(q, r, layer);
+        }
+
+        // Rounds floating-point axial coordinates (q, r) to the nearest integer cell coordinates
+        Cell3D RoundToCell(float q, float r, int layer)
+        {
+            // Calculate the third hexagonal coordinate (s) for consistency
+            float s = -q - r;
+            int qInt = Mathf.RoundToInt(q); // Round q to nearest integer
+            int rInt = Mathf.RoundToInt(r); // Round r to nearest integer
+            int sInt = Mathf.RoundToInt(s); // Round s to nearest integer
+
+            // Calculate differences to determine which coordinate needs adjustment
+            float qDiff = Mathf.Abs(q - qInt);
+            float rDiff = Mathf.Abs(r - rInt);
+            float sDiff = Mathf.Abs(s - sInt);
+
+            // Adjust q or r based on which has the largest rounding error (ensures q + r + s = 0)
+            if (qDiff > rDiff && qDiff > sDiff)
+                qInt = -rInt - sInt; // Adjust q if it has the largest error
+            else if (rDiff > sDiff)
+                rInt = -qInt - sInt; // Adjust r if it has the largest error
+
+            return new Cell3D(qInt, rInt, layer);
+        }
+
+        // Populates the provided array with neighboring cells around a given center cell
+        internal void GetNeighborCells(Cell3D center, Cell3D[] neighbors)
+        {
+            // Ensure the array has the correct size
+            if (neighbors.Length != 21)
+                throw new System.ArgumentException("Neighbor array must have exactly 21 elements");
+
+            // Populate the array by adjusting precomputed offsets with the center cell's coordinates
+            for (int i = 0; i < neighborCellsBase.Length; i++)
+            {
+                neighbors[i] = new Cell3D(
+                    center.q + neighborCellsBase[i].q,
+                    center.r + neighborCellsBase[i].r,
+                    center.layer + neighborCellsBase[i].layer
+                );
+            }
+        }
+
+#if UNITY_EDITOR
+
+        // Draws a hexagonal gizmo in the Unity Editor for visualization
+        internal void DrawHexGizmo(Vector3 center, float radius, float height, int relativeLayer)
+        {
+            // Hexagon has 6 sides
+            const int segments = 6;
+
+            // Array to store the 6 corner points
+            Vector3[] corners = new Vector3[segments];
+
+            // Calculate the corner positions of the hexagon in the XZ plane
+            for (int i = 0; i < segments; i++)
+            {
+                // Angle for each corner, offset by 90 degrees
+                float angle = 2 * Mathf.PI / segments * i + Mathf.PI / 2;
+
+                // Calculate the corner position based on the angle and radius
+                corners[i] = center + new Vector3(radius * Mathf.Cos(angle), 0, radius * Mathf.Sin(angle));
+            }
+
+            // Set gizmo color based on the relative layer for easy identification
+            Color gizmoColor;
+            switch (relativeLayer)
+            {
+                case 1:
+                    gizmoColor = Color.green;   // Upper layer (positive Y)
+                    break;
+                case 0:
+                    gizmoColor = Color.cyan;    // Same layer as the reference point
+                    break;
+                case -1:
+                    gizmoColor = Color.yellow;  // Lower layer (negative Y)
+                    break;
+                default:
+                    gizmoColor = Color.red;     // Fallback for unexpected layers
+                    break;
+            }
+
+            // Store the current Gizmos color to restore later
+            Color previousColor = Gizmos.color;
+
+            // Apply the chosen color
+            Gizmos.color = gizmoColor;
+
+            // Draw each side of the hexagon as a 3D quad (wall)
+            for (int i = 0; i < segments; i++)
+            {
+                // Current corner
+                Vector3 cornerA = corners[i];
+
+                // Next corner (wraps around at 6)
+                Vector3 cornerB = corners[(i + 1) % segments];
+
+                // Calculate top and bottom corners to form a vertical quad
+                Vector3 cornerATop = cornerA + Vector3.up * (height / 2);
+                Vector3 cornerBTop = cornerB + Vector3.up * (height / 2);
+                Vector3 cornerABottom = cornerA - Vector3.up * (height / 2);
+                Vector3 cornerBBottom = cornerB - Vector3.up * (height / 2);
+
+                // Draw the four lines of the quad to visualize the wall
+                Gizmos.DrawLine(cornerATop, cornerBTop);
+                Gizmos.DrawLine(cornerBTop, cornerBBottom);
+                Gizmos.DrawLine(cornerBBottom, cornerABottom);
+                Gizmos.DrawLine(cornerABottom, cornerATop);
+            }
+
+            // Restore the original Gizmos color
+            Gizmos.color = previousColor;
+        }
+
+#endif
+    }
+
+    // Custom struct for neighbor offsets (reduced memory usage)
+    internal struct HexOffset
+    {
+        internal int qOffset;   // Offset in the q (axial) coordinate
+        internal int rOffset;   // Offset in the r (axial) coordinate
+
+        internal HexOffset(int q, int r)
+        {
+            qOffset = q;
+            rOffset = r;
+        }
+    }
+
+    // Struct representing a single cell in the 3D hexagonal grid
+    internal struct Cell3D
+    {
+        internal readonly int q;        // Axial q coordinate (horizontal axis)
+        internal readonly int r;        // Axial r coordinate (diagonal axis)
+        internal readonly int layer;    // Vertical layer index (Y-axis stacking)
+
+        internal Cell3D(int q, int r, int layer)
+        {
+            this.q = q;
+            this.r = r;
+            this.layer = layer;
+        }
+
+        public override bool Equals(object obj) =>
+            obj is Cell3D other
+            && q == other.q
+            && r == other.r
+            && layer == other.layer;
+
+        // Generate a unique hash code for the cell
+        public override int GetHashCode() => (q << 16) ^ (r << 8) ^ layer;
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9c4fe05752c9a85458b8e44611fe832b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SpatialHashing/HexGrid3D.cs
+  uploadId: 736421

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

@@ -0,0 +1,345 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Spatial Hash/Hex Spatial Hash (2D)")]
+    public class HexSpatialHash2DInterestManagement : InterestManagement
+    {
+        [Range(1, 60), Tooltip("Time interval in seconds between observer rebuilds")]
+        public byte rebuildInterval = 1;
+
+        [Range(1, 60), Tooltip("Time interval in seconds between static object rebuilds")]
+        public byte staticRebuildInterval = 10;
+
+        [Range(10, 5000), Tooltip("Radius of super hex.\nSet to 10% larger than camera far clip plane.")]
+        public ushort visRange = 1100;
+
+        [Range(1, 100), Tooltip("Distance an object must move for updating cell positions")]
+        public ushort minMoveDistance = 1;
+
+        [Tooltip("Spatial Hashing supports XZ for 3D games or XY for 2D games.")]
+        public CheckMethod checkMethod = CheckMethod.XZ_FOR_3D;
+
+        double lastRebuildTime;
+
+        // Counter for batching static object updates
+        byte rebuildCounter = 0;
+
+        HexGrid2D grid;
+
+        // Sparse array mapping cell indices to sets of NetworkIdentities
+        readonly List<HashSet<NetworkIdentity>> cells = new List<HashSet<NetworkIdentity>>();
+
+        // Tracks the last known cell position and world position of each NetworkIdentity
+        readonly Dictionary<NetworkIdentity, (Cell2D cell, Vector2 worldPos)> lastIdentityPositions = new Dictionary<NetworkIdentity, (Cell2D, Vector2)>();
+
+        // Tracks the last known cell position and world position of each player's connection (observer)
+        readonly Dictionary<NetworkConnectionToClient, (Cell2D cell, Vector2 worldPos)> lastConnectionPositions = new Dictionary<NetworkConnectionToClient, (Cell2D, Vector2)>();
+
+        // Pre-allocated array for storing neighbor cells (center + 6 neighbors)
+        readonly Cell2D[] neighborCells = new Cell2D[7];
+
+        // Maps each connection to the set of NetworkIdentities it can observe, precomputed for rebuilds
+        readonly Dictionary<NetworkConnectionToClient, HashSet<NetworkIdentity>> connectionObservers = new Dictionary<NetworkConnectionToClient, HashSet<NetworkIdentity>>();
+
+        // Reusable list for safe iteration over NetworkIdentities, avoiding ToList() allocations
+        readonly List<NetworkIdentity> identityKeys = new List<NetworkIdentity>();
+
+        // Pool of reusable HashSet<NetworkIdentity> instances to reduce allocations
+        readonly Stack<HashSet<NetworkIdentity>> cellPool = new Stack<HashSet<NetworkIdentity>>();
+
+        // Set of static NetworkIdentities that don't move, updated less frequently
+        readonly HashSet<NetworkIdentity> staticObjects = new HashSet<NetworkIdentity>();
+
+        // Scene bounds: <20>9 km (18 km total) in each dimension
+        const int MAX_Q = 19; // Covers -9 to 9 (~18 km)
+        const int MAX_R = 23; // Covers -11 to 11 (~18 km)
+        const ushort MAX_AREA = 9000; // Maximum area in meters
+
+        public enum CheckMethod
+        {
+            XZ_FOR_3D,
+            XY_FOR_2D
+        }
+
+        void Awake()
+        {
+            grid = new HexGrid2D(visRange);
+            // Initialize cells list with null entries up to max size (<28>9 km bounds)
+            int maxSize = MAX_Q * MAX_R;
+            for (int i = 0; i < maxSize; i++)
+                cells.Add(null);
+        }
+
+        // Project 3D world position to 2D grid position based on checkMethod
+        Vector2 ProjectToGrid(Vector3 position) =>
+            checkMethod == CheckMethod.XZ_FOR_3D
+            ? new Vector2(position.x, position.z)
+            : new Vector2(position.x, position.y);
+
+        void LateUpdate()
+        {
+            if (NetworkTime.time - lastRebuildTime >= rebuildInterval)
+            {
+                // Update positions of all active connections (players) in the network
+                foreach (NetworkConnectionToClient conn in NetworkServer.connections.Values)
+                    if (conn?.identity != null) // Ensure connection and its identity exist
+                    {
+                        Vector2 position = ProjectToGrid(conn.identity.transform.position);
+                        // Only update if the position has changed significantly
+                        if (!lastConnectionPositions.TryGetValue(conn, out (Cell2D cell, Vector2 worldPos) last) ||
+                            Vector2.Distance(position, last.worldPos) >= minMoveDistance)
+                        {
+                            Cell2D cell = grid.WorldToCell(position); // Convert world position to grid cell
+                            lastConnectionPositions[conn] = (cell, position); // Store the player's cell and position
+                        }
+                    }
+
+                // Populate the reusable list with current keys for safe iteration
+                identityKeys.Clear();
+                identityKeys.AddRange(lastIdentityPositions.Keys);
+
+                // Update dynamic objects every rebuild, static objects every staticRebuildInterval
+                bool updateStatic = rebuildCounter >= staticRebuildInterval;
+                foreach (NetworkIdentity identity in identityKeys)
+                    if (updateStatic || !staticObjects.Contains(identity))
+                        UpdateIdentityPosition(identity); // Refresh cell position for dynamic or scheduled static objects
+
+                if (updateStatic)
+                    rebuildCounter = 0; // Reset the counter after updating static objects
+                else
+                    rebuildCounter++;
+
+                // Precompute observer sets for each connection before rebuilding
+                connectionObservers.Clear();
+                foreach (NetworkConnectionToClient conn in NetworkServer.connections.Values)
+                {
+                    if (conn?.identity == null || !lastConnectionPositions.TryGetValue(conn, out (Cell2D cell, Vector2 worldPos) connPos))
+                        continue;
+
+                    // Get cells visible from the player's position
+                    grid.GetNeighborCells(connPos.cell, neighborCells);
+
+                    // Initialize the observer set for this connection
+                    HashSet<NetworkIdentity> observers = new HashSet<NetworkIdentity>();
+                    connectionObservers[conn] = observers;
+
+                    // Add all identities in visible cells to the observer set
+                    for (int i = 0; i < neighborCells.Length; i++)
+                    {
+                        int index = GetCellIndex(neighborCells[i]);
+                        if (index >= 0 && index < cells.Count && cells[index] != null)
+                        {
+                            foreach (NetworkIdentity identity in cells[index])
+                                observers.Add(identity);
+                        }
+                    }
+                }
+
+                // RebuildAll invokes NetworkServer.RebuildObservers on all spawned objects
+                base.RebuildAll();
+
+                // Update the last rebuild time
+                lastRebuildTime = NetworkTime.time;
+            }
+        }
+
+        // Called when a new networked object is spawned on the server
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            // Register the new object's position in the grid system
+            UpdateIdentityPosition(identity);
+
+            // Check if the object is statically batched (indicating it won't move)
+            Renderer[] renderers = identity.gameObject.GetComponentsInChildren<Renderer>();
+            if (renderers.Any(r => r.isPartOfStaticBatch))
+                staticObjects.Add(identity);
+        }
+
+        // Updates the grid cell position of a NetworkIdentity when it moves or spawns
+        void UpdateIdentityPosition(NetworkIdentity identity)
+        {
+            // Get the current world position of the object
+            Vector2 position = ProjectToGrid(identity.transform.position);
+
+            // Convert position to grid cell coordinates
+            Cell2D newCell = grid.WorldToCell(position);
+
+            // Check if the object is within <20>9 km bounds
+            if (Mathf.Abs(position.x) > MAX_AREA || Mathf.Abs(position.y) > MAX_AREA)
+                return; // Ignore objects outside bounds
+
+            // Check if the object was previously tracked
+            if (lastIdentityPositions.TryGetValue(identity, out (Cell2D cell, Vector2 worldPos) previous))
+            {
+                // Only update if the position has changed significantly or the cell has changed
+                if (Vector2.Distance(position, previous.worldPos) >= minMoveDistance || !newCell.Equals(previous.cell))
+                {
+                    if (!newCell.Equals(previous.cell))
+                    {
+                        // Object moved to a new cell
+                        // Remove it from the old cell's set and add it to the new cell's set
+                        int oldIndex = GetCellIndex(previous.cell);
+                        if (oldIndex >= 0 && oldIndex < cells.Count && cells[oldIndex] != null)
+                            cells[oldIndex].Remove(identity);
+                        AddToCell(newCell, identity);
+                    }
+                    // Update the stored position and cell
+                    lastIdentityPositions[identity] = (newCell, position);
+                }
+            }
+            else
+            {
+                // New object - add it to the grid and track its position
+                AddToCell(newCell, identity);
+                lastIdentityPositions[identity] = (newCell, position);
+            }
+        }
+
+        // Adds a NetworkIdentity to a specific cell's set of objects
+        void AddToCell(Cell2D cell, NetworkIdentity identity)
+        {
+            int index = GetCellIndex(cell);
+            if (index < 0 || index >= cells.Count)
+                return; // Out of bounds, ignore
+
+            // If the cell doesn't exist in the array yet, fetch or create a new set from the pool
+            if (cells[index] == null)
+            {
+                cells[index] = cellPool.Count > 0 ? cellPool.Pop() : new HashSet<NetworkIdentity>();
+            }
+            cells[index].Add(identity);
+        }
+
+        // Determines if a new observer can see a given NetworkIdentity
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            // Check if we have position data for both the object and the observer
+            if (!lastIdentityPositions.TryGetValue(identity, out (Cell2D cell, Vector2 worldPos) identityPos) ||
+                !lastConnectionPositions.TryGetValue(newObserver, out (Cell2D cell, Vector2 worldPos) observerPos))
+                return false; // If not, assume no visibility
+
+            // Populate the pre-allocated array with visible cells from the observer's position
+            grid.GetNeighborCells(observerPos.cell, neighborCells);
+
+            // Check if the object's cell is among the visible ones
+            for (int i = 0; i < neighborCells.Length; i++)
+                if (neighborCells[i].Equals(identityPos.cell))
+                    return true;
+
+            return false;
+        }
+
+        // Rebuilds the set of observers for a specific NetworkIdentity
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            // If the object's position isn't tracked, skip rebuilding
+            if (!lastIdentityPositions.TryGetValue(identity, out (Cell2D cell, Vector2 worldPos) identityPos))
+                return;
+
+            // Use the precomputed observer sets to determine visibility
+            foreach (NetworkConnectionToClient conn in NetworkServer.connections.Values)
+            {
+                // Skip if the connection or its identity is null
+                if (conn?.identity == null)
+                    continue;
+
+                // Check if this connection can observe the identity
+                if (connectionObservers.TryGetValue(conn, out HashSet<NetworkIdentity> observers) && observers.Contains(identity))
+                    newObservers.Add(conn);
+            }
+        }
+
+        public override void ResetState()
+        {
+            lastRebuildTime = 0;
+            // Clear and return all cell sets to the pool
+            for (int i = 0; i < cells.Count; i++)
+            {
+                if (cells[i] != null)
+                {
+                    cells[i].Clear();
+                    cellPool.Push(cells[i]);
+                    cells[i] = null;
+                }
+            }
+            lastIdentityPositions.Clear();
+            lastConnectionPositions.Clear();
+            connectionObservers.Clear();
+            identityKeys.Clear();
+            staticObjects.Clear();
+            rebuildCounter = 0;
+        }
+
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            // If the object was tracked, remove it from its cell and position records
+            if (lastIdentityPositions.TryGetValue(identity, out (Cell2D cell, Vector2 worldPos) pos))
+            {
+                int index = GetCellIndex(pos.cell);
+                if (index >= 0 && index < cells.Count && cells[index] != null)
+                {
+                    cells[index].Remove(identity);           // Remove from the cell's set
+                                                             // If the cell's set is now empty, return it to the pool
+                    if (cells[index].Count == 0)
+                    {
+                        cellPool.Push(cells[index]);
+                        cells[index] = null;
+                    }
+                }
+                lastIdentityPositions.Remove(identity);     // Remove from position tracking
+                staticObjects.Remove(identity);            // Ensure it's removed from static set if present
+            }
+        }
+
+        // Computes a unique index for a cell in the sparse array, supporting <20>9 km bounds
+        int GetCellIndex(Cell2D cell)
+        {
+            int qOffset = cell.q + MAX_Q / 2; // Shift -9 to 9 -> 0 to 18
+            int rOffset = cell.r + MAX_R / 2; // Shift -11 to 11 -> 0 to 22
+            return qOffset + rOffset * MAX_Q;
+        }
+
+#if UNITY_EDITOR
+        // Draws debug gizmos in the Unity Editor to visualize the 2D grid
+        void OnDrawGizmos()
+        {
+            // Initialize the grid if it hasn<73>t been created yet (e.g., before Awake)
+            if (grid == null)
+                grid = new HexGrid2D(visRange);
+
+            // Only draw if there<72>s a local player to base the visualization on
+            if (NetworkClient.localPlayer != null)
+            {
+                Vector3 playerPosition = NetworkClient.localPlayer.transform.position;
+
+                // Convert to grid cell using the full Vector3 for proper plane projection
+                Vector2 projectedPos = ProjectToGrid(playerPosition);
+                Cell2D playerCell = grid.WorldToCell(projectedPos);
+
+                // Get all visible cells around the player into the pre-allocated array
+                grid.GetNeighborCells(playerCell, neighborCells);
+
+                // Set gizmo color for visibility
+                Gizmos.color = Color.cyan;
+
+                // Draw each visible cell as a 2D hexagon, oriented based on checkMethod
+                for (int i = 0; i < neighborCells.Length; i++)
+                {
+                    // Convert cell to world coordinates (2D)
+                    Vector2 worldPos2D = grid.CellToWorld(neighborCells[i]);
+
+                    // Convert to 3D position based on checkMethod
+                    Vector3 worldPos = checkMethod == CheckMethod.XZ_FOR_3D
+                        ? new Vector3(worldPos2D.x, 0, worldPos2D.y)  // XZ plane, flat
+                        : new Vector3(worldPos2D.x, worldPos2D.y, 0);  // XY plane, vertical
+
+                    grid.DrawHexGizmo(worldPos, grid.cellRadius, checkMethod);
+                }
+            }
+        }
+#endif
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9b8b055f11f85ff428da471a0e625dd4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SpatialHashing/HexSpatialHash2DInterestManagement.cs
+  uploadId: 736421

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

@@ -0,0 +1,336 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Spatial Hash/Hex Spatial Hash (3D)")]
+    public class HexSpatialHash3DInterestManagement : InterestManagement
+    {
+        [Range(1, 60), Tooltip("Time interval in seconds between observer rebuilds")]
+        public byte rebuildInterval = 1;
+
+        [Range(1, 60), Tooltip("Time interval in seconds between static object rebuilds")]
+        public byte staticRebuildInterval = 10;
+
+        [Range(10, 5000), Tooltip("Radius of super hex.\nSet to 10% larger than camera far clip plane.")]
+        public ushort visRange = 1100;
+
+        [Range(10, 5000), Tooltip("Cell3D height effects all 3 layers")]
+        public ushort cellHeight = 500;
+
+        [Range(1, 100), Tooltip("Distance an object must move for updating cell positions")]
+        public ushort minMoveDistance = 1;
+
+        double lastRebuildTime;
+
+        // Counter for batching static object updates
+        byte rebuildCounter = 0;
+
+        HexGrid3D grid;
+
+        // Sparse array mapping cell indices to sets of NetworkIdentities
+        readonly List<HashSet<NetworkIdentity>> cells = new List<HashSet<NetworkIdentity>>();
+
+        // Tracks the last known cell position and world position of each NetworkIdentity for efficient updates
+        readonly Dictionary<NetworkIdentity, (Cell3D cell, Vector3 worldPos)> lastIdentityPositions = new Dictionary<NetworkIdentity, (Cell3D, Vector3)>();
+
+        // Tracks the last known cell position and world position of each player's connection (observer)
+        readonly Dictionary<NetworkConnectionToClient, (Cell3D cell, Vector3 worldPos)> lastConnectionPositions = new Dictionary<NetworkConnectionToClient, (Cell3D, Vector3)>();
+
+        // Pre-allocated array for storing neighbor cells (center + 6 neighbors per layer x 3 layers)
+        readonly Cell3D[] neighborCells = new Cell3D[21];
+
+        // Maps each connection to the set of NetworkIdentities it can observe, precomputed for rebuilds
+        readonly Dictionary<NetworkConnectionToClient, HashSet<NetworkIdentity>> connectionObservers = new Dictionary<NetworkConnectionToClient, HashSet<NetworkIdentity>>();
+
+        // Reusable list for safe iteration over NetworkIdentities, avoiding ToList() allocations
+        readonly List<NetworkIdentity> identityKeys = new List<NetworkIdentity>();
+
+        // Pool of reusable HashSet<NetworkIdentity> instances to reduce allocations
+        readonly Stack<HashSet<NetworkIdentity>> cellPool = new Stack<HashSet<NetworkIdentity>>();
+
+        // Set of static NetworkIdentities that don't move, updated less frequently
+        readonly HashSet<NetworkIdentity> staticObjects = new HashSet<NetworkIdentity>();
+
+        // Scene bounds: ±9 km (18 km total) in each dimension
+        const int MAX_Q = 19; // Covers -9 to 9 (~18 km)
+        const int MAX_R = 23; // Covers -11 to 11 (~18 km)
+        const int LAYER_OFFSET = 18; // Offset for -18 to 17 layers
+        const int MAX_LAYERS = 36; // Total layers for ±9 km (18 km)
+        const ushort MAX_AREA = 9000; // Maximum area in meters
+
+        void Awake()
+        {
+            grid = new HexGrid3D(visRange, cellHeight);
+            // Initialize cells list with null entries up to max size (±9 km bounds)
+            int maxSize = MAX_Q * MAX_R * MAX_LAYERS;
+            for (int i = 0; i < maxSize; i++)
+                cells.Add(null);
+        }
+
+        void LateUpdate()
+        {
+            if (NetworkTime.time - lastRebuildTime >= rebuildInterval)
+            {
+                // Update positions of all active connections (players) in the network
+                foreach (NetworkConnectionToClient conn in NetworkServer.connections.Values)
+                    if (conn?.identity != null) // Ensure connection and its identity exist
+                    {
+                        Vector3 position = conn.identity.transform.position;
+                        // Only update if the position has changed significantly
+                        if (!lastConnectionPositions.TryGetValue(conn, out (Cell3D cell, Vector3 worldPos) last) ||
+                            Vector3.Distance(position, last.worldPos) >= minMoveDistance)
+                        {
+                            Cell3D cell = grid.WorldToCell(position); // Convert world position to grid cell
+                            lastConnectionPositions[conn] = (cell, position); // Store the player's cell and position
+                        }
+                    }
+
+                // Populate the reusable list with current keys for safe iteration
+                identityKeys.Clear();
+                identityKeys.AddRange(lastIdentityPositions.Keys);
+
+                // Update dynamic objects every rebuild, static objects every staticRebuildInterval
+                bool updateStatic = rebuildCounter >= staticRebuildInterval;
+                foreach (NetworkIdentity identity in identityKeys)
+                    if (updateStatic || !staticObjects.Contains(identity))
+                        UpdateIdentityPosition(identity); // Refresh cell position for dynamic or scheduled static objects
+
+                if (updateStatic)
+                    rebuildCounter = 0; // Reset the counter after updating static objects
+                else
+                    rebuildCounter++;
+
+                // Precompute observer sets for each connection before rebuilding
+                connectionObservers.Clear();
+                foreach (NetworkConnectionToClient conn in NetworkServer.connections.Values)
+                {
+                    if (conn?.identity == null || !lastConnectionPositions.TryGetValue(conn, out (Cell3D cell, Vector3 worldPos) connPos))
+                        continue;
+
+                    // Get cells visible from the player's position
+                    grid.GetNeighborCells(connPos.cell, neighborCells);
+
+                    // Initialize the observer set for this connection
+                    HashSet<NetworkIdentity> observers = new HashSet<NetworkIdentity>();
+                    connectionObservers[conn] = observers;
+
+                    // Add all identities in visible cells to the observer set
+                    for (int i = 0; i < neighborCells.Length; i++)
+                    {
+                        int index = GetCellIndex(neighborCells[i]);
+                        if (index >= 0 && index < cells.Count && cells[index] != null)
+                        {
+                            foreach (NetworkIdentity identity in cells[index])
+                                observers.Add(identity);
+                        }
+                    }
+                }
+
+                // RebuildAll invokes NetworkServer.RebuildObservers on all spawned objects
+                base.RebuildAll();
+
+                // Update the last rebuild time
+                lastRebuildTime = NetworkTime.time;
+            }
+        }
+
+        // Called when a new networked object is spawned on the server
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            // Register the new object's position in the grid system
+            UpdateIdentityPosition(identity);
+
+            // Check if the object is statically batched (indicating it won't move)
+            Renderer[] renderers = identity.gameObject.GetComponentsInChildren<Renderer>();
+            if (renderers.Any(r => r.isPartOfStaticBatch))
+                staticObjects.Add(identity);
+        }
+
+        // Updates the grid cell position of a NetworkIdentity when it moves or spawns
+        void UpdateIdentityPosition(NetworkIdentity identity)
+        {
+            // Get the current world position of the object
+            Vector3 position = identity.transform.position;
+
+            // Convert player position to grid cell coordinates
+            Cell3D newCell = grid.WorldToCell(position);
+
+            // Check if the object is within ±9 km bounds
+            if (Mathf.Abs(position.x) > MAX_AREA || Mathf.Abs(position.y) > MAX_AREA || Mathf.Abs(position.z) > MAX_AREA)
+                return; // Ignore objects outside bounds
+
+            // Check if the object was previously tracked
+            if (lastIdentityPositions.TryGetValue(identity, out (Cell3D cell, Vector3 worldPos) previous))
+            {
+                // Only update if the position has changed significantly or the cell has changed
+                if (Vector3.Distance(position, previous.worldPos) >= minMoveDistance || !newCell.Equals(previous.cell))
+                {
+                    if (!newCell.Equals(previous.cell))
+                    {
+                        // Object moved to a new cell
+                        // Remove it from the old cell's set and add it to the new cell's set
+                        int oldIndex = GetCellIndex(previous.cell);
+                        if (oldIndex >= 0 && oldIndex < cells.Count && cells[oldIndex] != null)
+                            cells[oldIndex].Remove(identity);
+                        AddToCell(newCell, identity);
+                    }
+                    // Update the stored position and cell
+                    lastIdentityPositions[identity] = (newCell, position);
+                }
+            }
+            else
+            {
+                // New object - add it to the grid and track its position
+                AddToCell(newCell, identity);
+                lastIdentityPositions[identity] = (newCell, position);
+            }
+        }
+
+        // Adds a NetworkIdentity to a specific cell's set of objects
+        void AddToCell(Cell3D cell, NetworkIdentity identity)
+        {
+            int index = GetCellIndex(cell);
+            if (index < 0 || index >= cells.Count)
+                return; // Out of bounds, ignore
+
+            // If the cell doesn't exist in the array yet, fetch or create a new set from the pool
+            if (cells[index] == null)
+            {
+                cells[index] = cellPool.Count > 0 ? cellPool.Pop() : new HashSet<NetworkIdentity>();
+            }
+            cells[index].Add(identity);
+        }
+
+        // Determines if a new observer can see a given NetworkIdentity
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            // Check if we have position data for both the object and the observer
+            if (!lastIdentityPositions.TryGetValue(identity, out (Cell3D cell, Vector3 worldPos) identityPos) ||
+                !lastConnectionPositions.TryGetValue(newObserver, out (Cell3D cell, Vector3 worldPos) observerPos))
+                return false; // If not, assume no visibility
+
+            // Populate the pre-allocated array with visible cells from the observer's position
+            grid.GetNeighborCells(observerPos.cell, neighborCells);
+
+            // Check if the object's cell is among the visible ones
+            for (int i = 0; i < neighborCells.Length; i++)
+                if (neighborCells[i].Equals(identityPos.cell))
+                    return true;
+
+            return false;
+        }
+
+        // Rebuilds the set of observers for a specific NetworkIdentity
+        public override void OnRebuildObservers(NetworkIdentity identity, HashSet<NetworkConnectionToClient> newObservers)
+        {
+            // If the object's position isn't tracked, skip rebuilding
+            if (!lastIdentityPositions.TryGetValue(identity, out (Cell3D cell, Vector3 worldPos) identityPos))
+                return;
+
+            // Use the precomputed observer sets to determine visibility
+            foreach (NetworkConnectionToClient conn in NetworkServer.connections.Values)
+            {
+                // Skip if the connection or its identity is null
+                if (conn?.identity == null)
+                    continue;
+
+                // Check if this connection can observe the identity
+                if (connectionObservers.TryGetValue(conn, out HashSet<NetworkIdentity> observers) && observers.Contains(identity))
+                    newObservers.Add(conn);
+            }
+        }
+
+        public override void ResetState()
+        {
+            lastRebuildTime = 0;
+            // Clear and return all cell sets to the pool
+            for (int i = 0; i < cells.Count; i++)
+            {
+                if (cells[i] != null)
+                {
+                    cells[i].Clear();
+                    cellPool.Push(cells[i]);
+                    cells[i] = null;
+                }
+            }
+            lastIdentityPositions.Clear();
+            lastConnectionPositions.Clear();
+            connectionObservers.Clear();
+            identityKeys.Clear();
+            staticObjects.Clear();
+            rebuildCounter = 0;
+        }
+
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            // If the object was tracked, remove it from its cell and position records
+            if (lastIdentityPositions.TryGetValue(identity, out (Cell3D cell, Vector3 worldPos) pos))
+            {
+                int index = GetCellIndex(pos.cell);
+                if (index >= 0 && index < cells.Count && cells[index] != null)
+                {
+                    cells[index].Remove(identity);           // Remove from the cell's set
+                                                             // If the cell's set is now empty, return it to the pool
+                    if (cells[index].Count == 0)
+                    {
+                        cellPool.Push(cells[index]);
+                        cells[index] = null;
+                    }
+                }
+                lastIdentityPositions.Remove(identity);     // Remove from position tracking
+                staticObjects.Remove(identity);            // Ensure it's removed from static set if present
+            }
+        }
+
+        // Computes a unique index for a cell in the sparse array, supporting ±9 km bounds
+        int GetCellIndex(Cell3D cell)
+        {
+            int qOffset = cell.q + MAX_Q / 2; // Shift -9 to 9 -> 0 to 18
+            int rOffset = cell.r + MAX_R / 2; // Shift -11 to 11 -> 0 to 22
+            int layerOffset = cell.layer + LAYER_OFFSET; // Shift -18 to 17 -> 0 to 35
+            return qOffset + rOffset * MAX_Q + layerOffset * MAX_Q * MAX_R;
+        }
+
+#if UNITY_EDITOR
+
+        // Draws debug gizmos in the Unity Editor to visualize the grid
+        void OnDrawGizmos()
+        {
+            // Initialize the grid if it hasn't been created yet (e.g., before Awake)
+            if (grid == null)
+                grid = new HexGrid3D(visRange, cellHeight);
+
+            // Only draw if there's a local player to base the visualization on
+            if (NetworkClient.localPlayer != null)
+            {
+                Vector3 playerPosition = NetworkClient.localPlayer.transform.position;
+
+                // Convert to grid cell
+                Cell3D playerCell = grid.WorldToCell(playerPosition);
+
+                // Get all visible cells around the player into the pre-allocated array
+                grid.GetNeighborCells(playerCell, neighborCells);
+
+                // Set default gizmo color (though overridden per cell)
+                Gizmos.color = Color.cyan;
+
+                // Draw each visible cell as a hexagonal prism
+                for (int i = 0; i < neighborCells.Length; i++)
+                {
+                    // Convert cell to world coordinates
+                    Vector3 worldPos = grid.CellToWorld(neighborCells[i]);
+
+                    // Determine the layer relative to the player's cell for color coding
+                    int relativeLayer = neighborCells[i].layer - playerCell.layer;
+
+                    // Draw the hexagonal cell with appropriate color based on layer
+                    grid.DrawHexGizmo(worldPos, grid.cellRadius, grid.cellHeight, relativeLayer);
+                }
+            }
+        }
+
+#endif
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 58e492e77a2a1a3488412ceed5c2aa2d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SpatialHashing/HexSpatialHash3DInterestManagement.cs
+  uploadId: 736421

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

@@ -0,0 +1,146 @@
+// extremely fast spatial hashing interest management based on uMMORPG GridChecker.
+// => 30x faster in initial tests
+// => scales way higher
+// checks on three dimensions (XYZ) which includes the vertical axes.
+// this is slower than XY checking for regular spatial hashing.
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Spatial Hash/Spatial Hashing Interest Management")]
+    public class SpatialHashing3DInterestManagement : InterestManagement
+    {
+        [Tooltip("The maximum range that objects will be visible at.")]
+        public int visRange = 30;
+
+        // we use a 9 neighbour grid.
+        // so we always see in a distance of 2 grids.
+        // for example, our own grid and then one on top / below / left / right.
+        //
+        // this means that grid resolution needs to be distance / 2.
+        // so for example, for distance = 30 we see 2 cells = 15 * 2 distance.
+        //
+        // on first sight, it seems we need distance / 3 (we see left/us/right).
+        // but that's not the case.
+        // resolution would be 10, and we only see 1 cell far, so 10+10=20.
+        public int resolution => visRange / 2; // same as XY because if XY is rotated 90 degree for 3D, it's still the same distance
+
+        [Tooltip("Rebuild all every 'rebuildInterval' seconds.")]
+        public float rebuildInterval = 1;
+        double lastRebuildTime;
+
+        [Header("Debug Settings")]
+        public bool showSlider;
+
+        // the grid
+        // begin with a large capacity to avoid resizing & allocations.
+        Grid3D<NetworkConnectionToClient> grid = new Grid3D<NetworkConnectionToClient>(1024);
+
+        // project 3d world position to grid position
+        Vector3Int ProjectToGrid(Vector3 position) =>
+            Vector3Int.RoundToInt(position / resolution);
+
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            // calculate projected positions
+            Vector3Int projected = ProjectToGrid(identity.transform.position);
+            Vector3Int 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; // same as XY because if XY is rotated 90 degree for 3D, it's still the same distance
+        }
+
+        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.
+            Vector3Int current = ProjectToGrid(identity.transform.position);
+            grid.GetWithNeighbours(current, newObservers);
+        }
+
+        [ServerCallback]
+        public override void ResetState()
+        {
+            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
+                    Vector3Int 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/SpatialHashing3DInterestManagement.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 120b4d6121d94e0280cd2ec536b0ea8f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SpatialHashing/SpatialHashing3DInterestManagement.cs
+  uploadId: 736421

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

@@ -0,0 +1,156 @@
+// extremely fast spatial hashing interest management based on uMMORPG GridChecker.
+// => 30x faster in initial tests
+// => scales way higher
+// checks on two dimensions only(!), for example: XZ for 3D games or XY for 2D games.
+// this is faster than XYZ checking but doesn't check vertical distance.
+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;
+
+        // we use a 9 neighbour grid.
+        // so we always see in a distance of 2 grids.
+        // for example, our own grid and then one on top / below / left / right.
+        //
+        // this means that grid resolution needs to be distance / 2.
+        // so for example, for distance = 30 we see 2 cells = 15 * 2 distance.
+        //
+        // on first sight, it seems we need distance / 3 (we see left/us/right).
+        // but that's not the case.
+        // resolution would be 10, and we only see 1 cell far, so 10+10=20.
+        public int resolution => visRange / 2;
+
+        [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;
+
+        [Header("Debug Settings")]
+        public bool showSlider;
+
+        // the grid
+        // begin with a large capacity to avoid resizing & allocations.
+        Grid2D<NetworkConnectionToClient> grid = new Grid2D<NetworkConnectionToClient>(1024);
+
+        // 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 ResetState()
+        {
+            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,18 @@
+fileFormatVersion: 2
+guid: 39adc6e09d5544ed955a50ce8600355a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/SpatialHashing/SpatialHashingInterestManagement.cs
+  uploadId: 736421

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,39 @@
+// simple component that holds team information
+using System;
+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
+    {
+        [SerializeField]
+        [Tooltip("Set teamId on Server at runtime to the same value on all networked objects that belong to a given team")]
+        string _teamId;
+
+        public string teamId
+        {
+            get => _teamId;
+            set
+            {
+                if (Application.IsPlaying(gameObject) && !NetworkServer.active)
+                    throw new InvalidOperationException("teamId can only be set at runtime on active server");
+
+                if (_teamId == value)
+                    return;
+
+                string oldTeam = _teamId;
+                _teamId = value;
+
+                //Only inform the AOI if this netIdentity has been spawned(isServer) and only if using a TeamInterestManagement
+                if (isServer && NetworkServer.aoi is TeamInterestManagement teamInterestManagement)
+                    teamInterestManagement.OnTeamChanged(this, oldTeam);
+            }
+        }
+
+        [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,18 @@
+fileFormatVersion: 2
+guid: 2576730625b1632468cbcbfe5e721f88
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/Team/NetworkTeam.cs
+  uploadId: 736421

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

@@ -0,0 +1,182 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/ Interest Management/ Team/Team Interest Management")]
+    public class TeamInterestManagement : InterestManagement
+    {
+        readonly Dictionary<string, HashSet<NetworkTeam>> teamObjects =
+            new Dictionary<string, HashSet<NetworkTeam>>();
+
+        readonly HashSet<string> dirtyTeams = new HashSet<string>();
+
+        // LateUpdate so that all spawns/despawns/changes are done
+        [ServerCallback]
+        void LateUpdate()
+        {
+            // Rebuild all dirty teams
+            // dirtyTeams will be empty if no teams changed members
+            // by spawning or destroying or changing teamId in this frame.
+            foreach (string dirtyTeam in dirtyTeams)
+            {
+                // rebuild always, even if teamObjects[dirtyTeam] is empty.
+                // Players might have left the team, but they may still be spawned.
+                RebuildTeamObservers(dirtyTeam);
+
+                // clean up empty entries in the dict
+                if (teamObjects[dirtyTeam].Count == 0)
+                    teamObjects.Remove(dirtyTeam);
+            }
+
+            dirtyTeams.Clear();
+        }
+
+        [ServerCallback]
+        void RebuildTeamObservers(string teamId)
+        {
+            foreach (NetworkTeam networkTeam in teamObjects[teamId])
+                if (networkTeam.netIdentity != null)
+                    NetworkServer.RebuildObservers(networkTeam.netIdentity, false);
+        }
+
+        // called by NetworkTeam.teamId setter
+        [ServerCallback]
+        internal void OnTeamChanged(NetworkTeam networkTeam, string oldTeam)
+        {
+            // This object is in a new team so observers in the prior team
+            // and the new team need to rebuild their respective observers lists.
+
+            // Remove this object from the hashset of the team it just left
+            // Null / Empty string is never a valid teamId
+            if (!string.IsNullOrWhiteSpace(oldTeam))
+            {
+                dirtyTeams.Add(oldTeam);
+                teamObjects[oldTeam].Remove(networkTeam);
+            }
+
+            // Null / Empty string is never a valid teamId
+            if (string.IsNullOrWhiteSpace(networkTeam.teamId))
+                return;
+
+            dirtyTeams.Add(networkTeam.teamId);
+
+            // Make sure this new team is in the dictionary
+            if (!teamObjects.ContainsKey(networkTeam.teamId))
+                teamObjects[networkTeam.teamId] = new HashSet<NetworkTeam>();
+
+            // Add this object to the hashset of the new team
+            teamObjects[networkTeam.teamId].Add(networkTeam);
+        }
+
+        [ServerCallback]
+        public override void OnSpawned(NetworkIdentity identity)
+        {
+            if (!identity.TryGetComponent(out NetworkTeam networkTeam))
+                return;
+
+            string networkTeamId = networkTeam.teamId;
+
+            // Null / Empty string is never a valid teamId...do not add to teamObjects collection
+            if (string.IsNullOrWhiteSpace(networkTeamId))
+                return;
+
+            // Debug.Log($"TeamInterestManagement.OnSpawned({identity.name}) currentTeam: {currentTeam}");
+            if (!teamObjects.TryGetValue(networkTeamId, out HashSet<NetworkTeam> objects))
+            {
+                objects = new HashSet<NetworkTeam>();
+                teamObjects.Add(networkTeamId, objects);
+            }
+
+            objects.Add(networkTeam);
+
+            // Team ID could have been set in NetworkBehaviour::OnStartServer on this object.
+            // Since that's after OnCheckObserver is called it would be missed, so force Rebuild here.
+            // Add the current team to dirtyTeames for LateUpdate to rebuild it.
+            dirtyTeams.Add(networkTeamId);
+        }
+
+        [ServerCallback]
+        public override void OnDestroyed(NetworkIdentity identity)
+        {
+            // Don't RebuildSceneObservers here - that will happen in LateUpdate.
+            // Multiple objects could be destroyed in same frame and we don't
+            // want to rebuild for each one...let LateUpdate do it once.
+            // We must add the current team to dirtyTeames for LateUpdate to rebuild it.
+            if (identity.TryGetComponent(out NetworkTeam currentTeam))
+            {
+                if (!string.IsNullOrWhiteSpace(currentTeam.teamId) &&
+                    teamObjects.TryGetValue(currentTeam.teamId, out HashSet<NetworkTeam> objects) &&
+                    objects.Remove(currentTeam))
+                    dirtyTeams.Add(currentTeam.teamId);
+            }
+        }
+
+        public override bool OnCheckObserver(NetworkIdentity identity, NetworkConnectionToClient newObserver)
+        {
+            // Always observed if no NetworkTeam component
+            if (!identity.TryGetComponent(out NetworkTeam identityNetworkTeam))
+                return true;
+
+            if (identityNetworkTeam.forceShown)
+                return true;
+
+            // Null / Empty string is never a valid teamId
+            if (string.IsNullOrWhiteSpace(identityNetworkTeam.teamId))
+                return false;
+
+            // Always observed if no NetworkTeam component
+            if (!newObserver.identity.TryGetComponent(out NetworkTeam newObserverNetworkTeam))
+                return true;
+
+            // Null / Empty string is never a valid teamId
+            if (string.IsNullOrWhiteSpace(newObserverNetworkTeam.teamId))
+                return false;
+
+            //Debug.Log($"TeamInterestManagement.OnCheckObserver {identity.name} {identityNetworkTeam.teamId} | {newObserver.identity.name} {newObserverNetworkTeam.teamId}");
+
+            // Observed only if teamId's team
+            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(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;
+            }
+
+            // Null / Empty string is never a valid teamId
+            if (string.IsNullOrWhiteSpace(networkTeam.teamId))
+                return;
+
+            // Abort if this team hasn't been created yet by OnSpawned or OnTeamChanged
+            if (!teamObjects.TryGetValue(networkTeam.teamId, out HashSet<NetworkTeam> objects))
+                return;
+
+            // Add everything in the hashset for this object's current team
+            foreach (NetworkTeam netTeam in objects)
+                if (netTeam.netIdentity != null && netTeam.netIdentity.connectionToClient != null)
+                    newObservers.Add(netTeam.netIdentity.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,18 @@
+fileFormatVersion: 2
+guid: dceb9a7085758fd4590419ff5b14b636
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/InterestManagement/Team/TeamInterestManagement.cs
+  uploadId: 736421

Assets/Mirror/Components/LagCompensation.meta

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

Assets/Mirror/Components/LagCompensation/HistoryCollider.cs

@@ -0,0 +1,109 @@
+// Applies HistoryBounds to the physics world by projecting to a trigger Collider.
+// This way we can use Physics.Raycast on it.
+using UnityEngine;
+
+namespace Mirror
+{
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/ Lag Compensation/ History Collider")]
+    public class HistoryCollider : MonoBehaviour
+    {
+        [Header("Components")]
+        [Tooltip("The object's actual collider. We need to know where it is, and how large it is.")]
+        public Collider actualCollider;
+
+        [Tooltip("The helper collider that the history bounds are projected onto.\nNeeds to be added to a child GameObject to counter-rotate an axis aligned Bounding Box onto it.\nThis is only used by this component.")]
+        public BoxCollider boundsCollider;
+
+        [Header("History")]
+        [Tooltip("Keep this many past bounds in the buffer. The larger this is, the further we can raycast into the past.\nMaximum time := historyAmount * captureInterval")]
+        public int boundsLimit = 8;
+
+        [Tooltip("Gather N bounds at a time into a bucket for faster encapsulation. A factor of 2 will be twice as fast, etc.")]
+        public int boundsPerBucket = 2;
+
+        [Tooltip("Capture bounds every 'captureInterval' seconds. Larger values will require fewer computations, but may not capture every small move.")]
+        public float captureInterval = 0.100f; // 100 ms
+        double lastCaptureTime = 0;
+
+        [Header("Debug")]
+        public Color historyColor = new Color(1.0f, 0.5f, 0.0f, 1.0f);
+        public Color currentColor = Color.red;
+
+        protected HistoryBounds history = null;
+
+        protected virtual void Awake()
+        {
+            history = new HistoryBounds(boundsLimit, boundsPerBucket);
+
+            // ensure colliders were set.
+            // bounds collider should always be a trigger.
+            if (actualCollider == null)    Debug.LogError("HistoryCollider: actualCollider was not set.");
+            if (boundsCollider == null)    Debug.LogError("HistoryCollider: boundsCollider was not set.");
+            if (boundsCollider.transform.parent != transform) Debug.LogError("HistoryCollider: boundsCollider must be a child of this GameObject.");
+            if (!boundsCollider.isTrigger) Debug.LogError("HistoryCollider: boundsCollider must be a trigger.");
+        }
+
+        // capturing and projecting onto colliders should use physics update
+        protected virtual void FixedUpdate()
+        {
+            // capture current bounds every interval
+            if (NetworkTime.localTime >= lastCaptureTime + captureInterval)
+            {
+                lastCaptureTime = NetworkTime.localTime;
+                CaptureBounds();
+            }
+
+            // project bounds onto helper collider
+            ProjectBounds();
+        }
+
+        protected virtual void CaptureBounds()
+        {
+            // grab current collider bounds
+            // this is in world space coordinates, and axis aligned
+            // TODO double check
+            Bounds bounds = actualCollider.bounds;
+
+            // insert into history
+            history.Insert(bounds);
+        }
+
+        protected virtual void ProjectBounds()
+        {
+            // grab total collider encapsulating all of history
+            Bounds total = history.total;
+
+            // don't assign empty bounds, this will throw a Unity warning
+            if (history.boundsCount == 0) return;
+
+            // scale projection doesn't work yet.
+            // for now, don't allow scale changes.
+            if (transform.lossyScale != Vector3.one)
+            {
+                Debug.LogWarning($"HistoryCollider: {name}'s transform global scale must be (1,1,1).");
+                return;
+            }
+
+            // counter rotate the child collider against the gameobject's rotation.
+            // we need this to always be axis aligned.
+            boundsCollider.transform.localRotation = Quaternion.Inverse(transform.rotation);
+
+            // project world space bounds to collider's local space
+            boundsCollider.center = boundsCollider.transform.InverseTransformPoint(total.center);
+            boundsCollider.size   = total.size; // TODO projection?
+        }
+
+        // TODO runtime drawing for debugging?
+        protected virtual void OnDrawGizmos()
+        {
+            // draw total bounds
+            Gizmos.color = historyColor;
+            Gizmos.DrawWireCube(history.total.center, history.total.size);
+
+            // draw current bounds
+            Gizmos.color = currentColor;
+            Gizmos.DrawWireCube(actualCollider.bounds.center, actualCollider.bounds.size);
+        }
+    }
+}

Assets/Mirror/Components/LagCompensation/HistoryCollider.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: f5f2158d9776d4b569858f793be4da60
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/LagCompensation/HistoryCollider.cs
+  uploadId: 736421

Assets/Mirror/Components/LagCompensation/LagCompensator.cs

@@ -0,0 +1,197 @@
+// Add this component to a Player object with collider.
+// Automatically keeps a history for lag compensation.
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror
+{
+    public struct Capture3D : Capture
+    {
+        public double timestamp { get; set; }
+        public Vector3 position;
+        public Vector3 size;
+
+        public Capture3D(double timestamp, Vector3 position, Vector3 size)
+        {
+            this.timestamp = timestamp;
+            this.position = position;
+            this.size = size;
+        }
+
+        public void DrawGizmo()
+        {
+            Gizmos.DrawWireCube(position, size);
+        }
+
+        public static Capture3D Interpolate(Capture3D from, Capture3D to, double t) =>
+            new Capture3D(
+                0, // interpolated snapshot is applied directly. don't need timestamps.
+                Vector3.LerpUnclamped(from.position, to.position, (float)t),
+                Vector3.LerpUnclamped(from.size, to.size, (float)t)
+            );
+
+        public override string ToString() => $"(time={timestamp} pos={position} size={size})";
+    }
+
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/ Lag Compensation/ Lag Compensator")]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/manual/general/lag-compensation")]
+    public class LagCompensator : NetworkBehaviour
+    {
+        [Header("Components")]
+        [Tooltip("The collider to keep a history of.")]
+        public Collider trackedCollider; // assign this in inspector
+
+        [Header("Settings")]
+        public LagCompensationSettings lagCompensationSettings = new LagCompensationSettings();
+        double lastCaptureTime;
+
+        // lag compensation history of <timestamp, capture>
+        readonly Queue<KeyValuePair<double, Capture3D>> history = new Queue<KeyValuePair<double, Capture3D>>();
+
+        [Header("Debugging")]
+        public Color historyColor = Color.white;
+
+        [ServerCallback]
+        protected virtual void Update()
+        {
+            // capture lag compensation snapshots every interval.
+            // NetworkTime.localTime because Unity 2019 doesn't have 'double' time yet.
+            if (NetworkTime.localTime >= lastCaptureTime + lagCompensationSettings.captureInterval)
+            {
+                lastCaptureTime = NetworkTime.localTime;
+                Capture();
+            }
+        }
+
+        [ServerCallback]
+        protected virtual void Capture()
+        {
+            // capture current state
+            Capture3D capture = new Capture3D(
+                NetworkTime.localTime,
+                trackedCollider.bounds.center,
+                trackedCollider.bounds.size
+            );
+
+            // insert into history
+            LagCompensation.Insert(history, lagCompensationSettings.historyLimit, NetworkTime.localTime, capture);
+        }
+
+        protected virtual void OnDrawGizmos()
+        {
+            // draw history
+            Gizmos.color = historyColor;
+            LagCompensation.DrawGizmos(history);
+        }
+
+        // sampling ////////////////////////////////////////////////////////////
+        // sample the sub-tick (=interpolated) history of this object for a hit test.
+        // 'viewer' needs to be the player who fired!
+        // for example, if A fires at B, then call B.Sample(viewer, point, tolerance).
+        [ServerCallback]
+        public virtual bool Sample(NetworkConnectionToClient viewer, out Capture3D sample)
+        {
+            // never trust the client: estimate client time instead.
+            // https://developer.valvesoftware.com/wiki/Source_Multiplayer_Networking
+            // the estimation is very good. the error is as low as ~6ms for the demo.
+            // note that passing 'rtt' is fine: EstimateTime halves it to latency.
+            double estimatedTime = LagCompensation.EstimateTime(NetworkTime.localTime, viewer.rtt, NetworkClient.bufferTime);
+
+            // sample the history to get the nearest snapshots around 'timestamp'
+            if (LagCompensation.Sample(history, estimatedTime, lagCompensationSettings.captureInterval, out Capture3D resultBefore, out Capture3D resultAfter, out double t))
+            {
+                // interpolate to get a decent estimation at exactly 'timestamp'
+                sample = Capture3D.Interpolate(resultBefore, resultAfter, t);
+                return true;
+            }
+            else Debug.Log($"CmdClicked: history doesn't contain {estimatedTime:F3}");
+
+            sample = default;
+            return false;
+        }
+
+        // convenience tests ///////////////////////////////////////////////////
+        // there are multiple different ways to check a hit against the sample:
+        // - raycasting
+        // - bounds.contains
+        // - increasing bounds by tolerance and checking contains
+        // - threshold to bounds.closestpoint
+        // let's offer a few solutions directly and see which users prefer.
+
+        // bounds check: checks distance to closest point on bounds in history @ -rtt.
+        //   'viewer' needs to be the player who fired!
+        //   for example, if A fires at B, then call B.Sample(viewer, point, tolerance).
+        // this is super simple and fast, but not 100% physically accurate since we don't raycast.
+        [ServerCallback]
+        public virtual bool BoundsCheck(
+            NetworkConnectionToClient viewer,
+            Vector3 hitPoint,
+            float toleranceDistance,
+            out float distance,
+            out Vector3 nearest)
+        {
+            // first, sample the history at -rtt of the viewer.
+            if (Sample(viewer, out Capture3D capture))
+            {
+                // now that we know where the other player was at that time,
+                // we can see if the hit point was within tolerance of it.
+                // TODO consider rotations???
+                // TODO consider original collider shape??
+                Bounds bounds = new Bounds(capture.position, capture.size);
+                nearest = bounds.ClosestPoint(hitPoint);
+                distance = Vector3.Distance(nearest, hitPoint);
+                return distance <= toleranceDistance;
+            }
+            nearest = hitPoint;
+            distance = 0;
+            return false;
+        }
+
+        // raycast check: creates a collider the sampled position and raycasts to hitPoint.
+        //   'viewer' needs to be the player who fired!
+        //   for example, if A fires at B, then call B.Sample(viewer, point, tolerance).
+        // this is physically accurate (checks against walls etc.), with the cost
+        // of a runtime instantiation.
+        //
+        //  originPoint: where the player fired the weapon.
+        //  hitPoint: where the player's local raycast hit.
+        //  tolerance: scale up the sampled collider by % in order to have a bit of a tolerance.
+        //             0 means no extra tolerance, 0.05 means 5% extra tolerance.
+        //  layerMask: the layer mask to use for the raycast.
+        [ServerCallback]
+        public virtual bool RaycastCheck(
+            NetworkConnectionToClient viewer,
+            Vector3 originPoint,
+            Vector3 hitPoint,
+            float tolerancePercent,
+            int layerMask,
+            out RaycastHit hit)
+        {
+            // first, sample the history at -rtt of the viewer.
+            if (Sample(viewer, out Capture3D capture))
+            {
+                // instantiate a real physics collider on demand.
+                // TODO rotation??
+                // TODO different collier types??
+                GameObject temp = new GameObject("LagCompensatorTest");
+                temp.transform.position = capture.position;
+                BoxCollider tempCollider = temp.AddComponent<BoxCollider>();
+                tempCollider.size = capture.size * (1 + tolerancePercent);
+
+                // raycast
+                Vector3 direction = hitPoint - originPoint;
+                float maxDistance = direction.magnitude * 2;
+                bool result = Physics.Raycast(originPoint, direction, out hit, maxDistance, layerMask);
+
+                // cleanup
+                Destroy(temp);
+                return result;
+            }
+
+            hit = default;
+            return false;
+        }
+    }
+}

Assets/Mirror/Components/LagCompensation/LagCompensator.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: a898831dd60c4cdfbfd9a6ea5702ed01
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/LagCompensation/LagCompensator.cs
+  uploadId: 736421

Assets/Mirror/Components/Mirror.Components.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Mirror.Components",
+    "rootNamespace": "",
+    "references": [
+        "GUID:30817c1a0e6d646d99c048fc403f5979"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

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

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 72872094b21c16e48b631b2224833d49
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/Mirror.Components.asmdef
+  uploadId: 736421

Assets/Mirror/Components/NetworkAnimator.cs

@@ -0,0 +1,662 @@
+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>
+    // [RequireComponent(typeof(NetworkIdentity))] disabled to allow child NetworkBehaviours
+    [AddComponentMenu("Network/Network Animator")]
+    [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.
+        /// Default to 1 because Animator.speed defaults to 1.
+        /// </summary>
+        [SyncVar(hook = nameof(OnAnimatorSpeedChanged))]
+        float animatorSpeed = 1f;
+        float previousSpeed = 1f;
+
+        // 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 (isOwned && clientAuthority);
+            }
+        }
+
+        void Initialize()
+        {
+            // 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];
+        }
+
+        // fix https://github.com/MirrorNetworking/Mirror/issues/2810
+        // both Awake and Enable need to initialize arrays.
+        // in case users call SetActive(false) -> SetActive(true).
+        void Awake() => Initialize();
+        void OnEnable() => Initialize();
+
+        public virtual void Reset()
+        {
+            syncDirection = SyncDirection.ClientToServer;
+        }
+
+        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 || (isOwned && 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 (isOwned && 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 (isOwned && 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)
+        {
+            // fix: https://github.com/MirrorNetworking/Mirror/issues/2852
+            // serialize parameterCount to be 100% sure we deserialize correct amount of bytes.
+            // (255 parameters should be enough for everyone, write it as byte)
+            byte parameterCount = (byte)parameters.Length;
+            writer.WriteByte(parameterCount);
+
+            ulong dirtyBits = forceAll ? (~0ul) : NextDirtyBits();
+            writer.WriteULong(dirtyBits);
+
+            // iterate on byte count. if it's >256, it won't break
+            // serialization - just not serialize excess layers.
+            for (int i = 0; i < parameterCount; 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)
+        {
+            // fix: https://github.com/MirrorNetworking/Mirror/issues/2852
+            // serialize parameterCount to be 100% sure we deserialize correct amount of bytes.
+            // mismatch shows error to make this super easy to debug.
+            byte parameterCount = reader.ReadByte();
+            if (parameterCount != parameters.Length)
+            {
+                Debug.LogError($"NetworkAnimator: serialized parameter count={parameterCount} does not match expected parameter count={parameters.Length}. Are you changing animators at runtime?", gameObject);
+                return;
+            }
+
+            bool animatorEnabled = animator.enabled;
+            // need to read values from NetworkReader even if animator is disabled
+            ulong dirtyBits = reader.ReadULong();
+            for (int i = 0; i < parameterCount; 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);
+                }
+            }
+        }
+
+        public override void OnSerialize(NetworkWriter writer, bool initialState)
+        {
+            base.OnSerialize(writer, initialState);
+            if (initialState)
+            {
+                // fix: https://github.com/MirrorNetworking/Mirror/issues/2852
+                // serialize layerCount to be 100% sure we deserialize correct amount of bytes.
+                // (255 layers should be enough for everyone, write it as byte)
+                byte layerCount = (byte)animator.layerCount;
+                writer.WriteByte(layerCount);
+
+                // iterate on byte count. if it's >256, it won't break
+                // serialization - just not serialize excess layers.
+                for (int i = 0; i < layerCount; i++)
+                {
+                    AnimatorStateInfo st = animator.IsInTransition(i)
+                        ? animator.GetNextAnimatorStateInfo(i)
+                        : animator.GetCurrentAnimatorStateInfo(i);
+                    writer.WriteInt(st.fullPathHash);
+                    writer.WriteFloat(st.normalizedTime);
+                    writer.WriteFloat(animator.GetLayerWeight(i));
+                }
+                WriteParameters(writer, true);
+            }
+        }
+
+        public override void OnDeserialize(NetworkReader reader, bool initialState)
+        {
+            base.OnDeserialize(reader, initialState);
+            if (initialState)
+            {
+                // fix: https://github.com/MirrorNetworking/Mirror/issues/2852
+                // serialize layerCount to be 100% sure we deserialize correct amount of bytes.
+                // mismatch shows error to make this super easy to debug.
+                byte layerCount = reader.ReadByte();
+                if (layerCount != animator.layerCount)
+                {
+                    Debug.LogError($"NetworkAnimator: serialized layer count={layerCount} does not match expected layer count={animator.layerCount}. Are you changing animators at runtime?", gameObject);
+                    return;
+                }
+
+                for (int i = 0; i < layerCount; i++)
+                {
+                    int stateHash = reader.ReadInt();
+                    float normalizedTime = reader.ReadFloat();
+                    float weight = reader.ReadFloat();
+
+                    animator.SetLayerWeight(i, weight);
+                    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", gameObject);
+                    return;
+                }
+
+                if (!isOwned)
+                {
+                    Debug.LogWarning("Only the client with authority can set animations", gameObject);
+                    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", gameObject);
+                    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", gameObject);
+                    return;
+                }
+
+                if (!isOwned)
+                {
+                    Debug.LogWarning("Only the client with authority can reset animations", gameObject);
+                    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", gameObject);
+                    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 && isOwned;
+            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 && isOwned;
+            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(includeOwner = false)]
+        void RpcOnAnimationTriggerClientMessage(int hash)
+        {
+            // already handled on server in SetTrigger
+            // or CmdOnAnimationTriggerServerMessage
+            if (!isServer)
+                HandleAnimTriggerMsg(hash);
+        }
+
+        [ClientRpc(includeOwner = false)]
+        void RpcOnAnimationResetTriggerClientMessage(int hash)
+        {
+            // already handled on server in ResetTrigger
+            // or CmdOnAnimationResetTriggerServerMessage
+            if (!isServer)
+                HandleAnimResetTriggerMsg(hash);
+        }
+
+        #endregion
+    }
+}

Assets/Mirror/Components/NetworkAnimator.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 7f6f3bf89aa97405989c802ba270f815
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkAnimator.cs
+  uploadId: 736421

Assets/Mirror/Components/NetworkDiagnosticsDebugger.cs

@@ -0,0 +1,31 @@
+using UnityEngine;
+
+namespace Mirror
+{
+    [AddComponentMenu("Network/Network Diagnostics Debugger")]
+    public class NetworkDiagnosticsDebugger : MonoBehaviour
+    {
+        public bool logInMessages = true;
+        public bool logOutMessages = true;
+        void OnInMessage(NetworkDiagnostics.MessageInfo msgInfo)
+        {
+            if (logInMessages)
+                Debug.Log(msgInfo);
+        }
+        void OnOutMessage(NetworkDiagnostics.MessageInfo msgInfo)
+        {
+            if (logOutMessages)
+                Debug.Log(msgInfo);
+        }
+        void OnEnable()
+        {
+            NetworkDiagnostics.InMessageEvent += OnInMessage;
+            NetworkDiagnostics.OutMessageEvent += OnOutMessage;
+        }
+        void OnDisable()
+        {
+            NetworkDiagnostics.InMessageEvent -= OnInMessage;
+            NetworkDiagnostics.OutMessageEvent -= OnOutMessage;
+        }
+    }
+}

Assets/Mirror/Components/NetworkDiagnosticsDebugger.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: bc9f0a0fe4124424b8f9d4927795ee01
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkDiagnosticsDebugger.cs
+  uploadId: 736421

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,18 @@
+fileFormatVersion: 2
+guid: a4c96e6dd99826849ab1431f94547141
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkLobbyManager.cs
+  uploadId: 736421

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,18 @@
+fileFormatVersion: 2
+guid: 777a368af85f2e84da7ea5666581921b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkLobbyPlayer.cs
+  uploadId: 736421

Assets/Mirror/Components/NetworkPingDisplay.cs

@@ -0,0 +1,39 @@
+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;
+        public int width = 150;
+        public int height = 25;
+
+        void OnGUI()
+        {
+            // only while client is active
+            if (!NetworkClient.active) return;
+
+            // show stats in bottom right corner, right aligned
+            GUI.color = color;
+            Rect rect = new Rect(Screen.width - width - padding, Screen.height - height - padding, width, height);
+            GUILayout.BeginArea(rect);
+            GUIStyle style = GUI.skin.GetStyle("Label");
+            style.alignment = TextAnchor.MiddleRight;
+            GUILayout.BeginHorizontal(style);
+                GUILayout.Label($"RTT: {Math.Round(NetworkTime.rtt * 1000)}ms");
+                GUI.color = NetworkClient.connectionQuality.ColorCode();
+                GUILayout.Label($"Q: {new string('-', (int)NetworkClient.connectionQuality)}");
+            GUILayout.EndHorizontal();
+            GUILayout.EndArea();
+            GUI.color = Color.white;
+        }
+    }
+}

Assets/Mirror/Components/NetworkPingDisplay.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: bc654f29862fc2643b948f772ebb9e68
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkPingDisplay.cs
+  uploadId: 736421

Assets/Mirror/Components/NetworkRigidbody.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 80106690aef541a5b8e2f8fb3d5949ad
+timeCreated: 1686733778

Assets/Mirror/Components/NetworkRigidbody/NetworkRigidbodyReliable.cs

@@ -0,0 +1,115 @@
+using UnityEngine;
+
+namespace Mirror
+{
+    // [RequireComponent(typeof(Rigidbody))] <- OnValidate ensures this is on .target
+    [AddComponentMenu("Network/Network Rigidbody (Reliable)")]
+    public class NetworkRigidbodyReliable : NetworkTransformReliable
+    {
+        bool clientAuthority => syncDirection == SyncDirection.ClientToServer;
+
+        Rigidbody rb;
+        bool wasKinematic;
+
+        protected override void OnValidate()
+        {
+            // Skip if Editor is in Play mode
+            if (Application.isPlaying) return;
+
+            base.OnValidate();
+
+            // we can't overwrite .target to be a Rigidbody.
+            // but we can ensure that .target has a Rigidbody, and use it.
+            if (target.GetComponent<Rigidbody>() == null)
+            {
+                Debug.LogWarning($"{name}'s NetworkRigidbody.target {target.name} is missing a Rigidbody", this);
+            }
+        }
+
+        // cach Rigidbody and original isKinematic setting
+        protected override void Awake()
+        {
+            // we can't overwrite .target to be a Rigidbody.
+            // but we can use its Rigidbody component.
+            rb = target.GetComponent<Rigidbody>();
+            if (rb == null)
+            {
+                Debug.LogError($"{name}'s NetworkRigidbody.target {target.name} is missing a Rigidbody", this);
+                return;
+            }
+            wasKinematic = rb.isKinematic;
+            base.Awake();
+        }
+
+        // reset forced isKinematic flag to original.
+        // otherwise the overwritten value would remain between sessions forever.
+        // for example, a game may run as client, set rigidbody.iskinematic=true,
+        // then run as server, where .iskinematic isn't touched and remains at
+        // the overwritten=true, even though the user set it to false originally.
+        public override void OnStopServer() => rb.isKinematic = wasKinematic;
+        public override void OnStopClient() => rb.isKinematic = wasKinematic;
+
+        // overwriting Construct() and Apply() to set Rigidbody.MovePosition
+        // would give more jittery movement.
+
+        // FixedUpdate for physics
+        void FixedUpdate()
+        {
+            // who ever has authority moves the Rigidbody with physics.
+            // everyone else simply sets it to kinematic.
+            // so that only the Transform component is synced.
+
+            // host mode
+            if (isServer && isClient)
+            {
+                // in host mode, we own it it if:
+                // clientAuthority is disabled (hence server / we own it)
+                // clientAuthority is enabled and we have authority over this object.
+                bool owned = !clientAuthority || IsClientWithAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+                if (!owned) rb.isKinematic = true;
+            }
+            // client only
+            else if (isClient)
+            {
+                // on the client, we own it only if clientAuthority is enabled,
+                // and we have authority over this object.
+                bool owned = IsClientWithAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+                if (!owned) rb.isKinematic = true;
+            }
+            // server only
+            else if (isServer)
+            {
+                // on the server, we always own it if clientAuthority is disabled.
+                bool owned = !clientAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+                if (!owned) rb.isKinematic = true;
+            }
+        }
+
+        protected override void OnTeleport(Vector3 destination)
+        {
+            base.OnTeleport(destination);
+
+            rb.position = transform.position;
+        }
+
+        protected override void OnTeleport(Vector3 destination, Quaternion rotation)
+        {
+            base.OnTeleport(destination, rotation);
+
+            rb.position = transform.position;
+            rb.rotation = transform.rotation;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: cb803efbe62c34d7baece46c9ffebad9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkRigidbody/NetworkRigidbodyReliable.cs
+  uploadId: 736421

Assets/Mirror/Components/NetworkRigidbody/NetworkRigidbodyReliable2D.cs

@@ -0,0 +1,135 @@
+using UnityEngine;
+
+namespace Mirror
+{
+    // [RequireComponent(typeof(Rigidbody))] <- OnValidate ensures this is on .target
+    [AddComponentMenu("Network/Network Rigidbody 2D (Reliable)")]
+    public class NetworkRigidbodyReliable2D : NetworkTransformReliable
+    {
+        bool clientAuthority => syncDirection == SyncDirection.ClientToServer;
+
+        Rigidbody2D rb;
+        bool wasKinematic;
+
+        protected override void OnValidate()
+        {
+            if (Application.isPlaying) return;
+
+            base.OnValidate();
+
+            // we can't overwrite .target to be a Rigidbody.
+            // but we can ensure that .target has a Rigidbody, and use it.
+            if (target.GetComponent<Rigidbody2D>() == null)
+            {
+                Debug.LogWarning($"{name}'s NetworkRigidbody2D.target {target.name} is missing a Rigidbody2D", this);
+            }
+        }
+
+        // cach Rigidbody and original isKinematic setting
+        protected override void Awake()
+        {
+            // we can't overwrite .target to be a Rigidbody.
+            // but we can use its Rigidbody component.
+            rb = target.GetComponent<Rigidbody2D>();
+            if (rb == null)
+            {
+                Debug.LogError($"{name}'s NetworkRigidbody2D.target {target.name} is missing a Rigidbody2D", this);
+                return;
+            }
+#if UNITY_6000_0_OR_NEWER
+            wasKinematic = rb.bodyType.HasFlag(RigidbodyType2D.Kinematic);
+#else
+            wasKinematic = rb.isKinematic;
+#endif
+            base.Awake();
+        }
+
+        // reset forced isKinematic flag to original.
+        // otherwise the overwritten value would remain between sessions forever.
+        // for example, a game may run as client, set rigidbody.iskinematic=true,
+        // then run as server, where .iskinematic isn't touched and remains at
+        // the overwritten=true, even though the user set it to false originally.
+#if UNITY_6000_0_OR_NEWER
+        public override void OnStopServer() => rb.bodyType = wasKinematic ? RigidbodyType2D.Kinematic : RigidbodyType2D.Dynamic;
+        public override void OnStopClient() => rb.bodyType = wasKinematic ? RigidbodyType2D.Kinematic : RigidbodyType2D.Dynamic;
+#else
+        public override void OnStopServer() => rb.isKinematic = wasKinematic;
+        public override void OnStopClient() => rb.isKinematic = wasKinematic;
+#endif
+
+        // overwriting Construct() and Apply() to set Rigidbody.MovePosition
+        // would give more jittery movement.
+
+        // FixedUpdate for physics
+        void FixedUpdate()
+        {
+            // who ever has authority moves the Rigidbody with physics.
+            // everyone else simply sets it to kinematic.
+            // so that only the Transform component is synced.
+
+            // host mode
+            if (isServer && isClient)
+            {
+                // in host mode, we own it it if:
+                // clientAuthority is disabled (hence server / we own it)
+                // clientAuthority is enabled and we have authority over this object.
+                bool owned = !clientAuthority || IsClientWithAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+#if UNITY_6000_0_OR_NEWER
+                if (!owned) rb.bodyType = RigidbodyType2D.Kinematic;
+#else
+                if (!owned) rb.isKinematic = true;
+#endif
+            }
+            // client only
+            else if (isClient)
+            {
+                // on the client, we own it only if clientAuthority is enabled,
+                // and we have authority over this object.
+                bool owned = IsClientWithAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+#if UNITY_6000_0_OR_NEWER
+                if (!owned) rb.bodyType = RigidbodyType2D.Kinematic;
+#else
+                if (!owned) rb.isKinematic = true;
+#endif
+            }
+            // server only
+            else if (isServer)
+            {
+                // on the server, we always own it if clientAuthority is disabled.
+                bool owned = !clientAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+#if UNITY_6000_0_OR_NEWER
+                if (!owned) rb.bodyType = RigidbodyType2D.Kinematic;
+#else
+                if (!owned) rb.isKinematic = true;
+#endif
+            }
+        }
+
+        protected override void OnTeleport(Vector3 destination)
+        {
+            base.OnTeleport(destination);
+
+            rb.position = transform.position;
+        }
+
+        protected override void OnTeleport(Vector3 destination, Quaternion rotation)
+        {
+            base.OnTeleport(destination, rotation);
+
+            rb.position = transform.position;
+            rb.rotation = transform.rotation.eulerAngles.z;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 7ec4f7556ca1e4b55a3381fc6a02b1bc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkRigidbody/NetworkRigidbodyReliable2D.cs
+  uploadId: 736421

Assets/Mirror/Components/NetworkRigidbody/NetworkRigidbodyUnreliable.cs

@@ -0,0 +1,115 @@
+using UnityEngine;
+
+namespace Mirror
+{
+    // [RequireComponent(typeof(Rigidbody))] <- OnValidate ensures this is on .target
+    [AddComponentMenu("Network/Network Rigidbody (Unreliable)")]
+    public class NetworkRigidbodyUnreliable : NetworkTransformUnreliable
+    {
+        bool clientAuthority => syncDirection == SyncDirection.ClientToServer;
+
+        Rigidbody rb;
+        bool wasKinematic;
+
+        protected override void OnValidate()
+        {
+            // Skip if Editor is in Play mode
+            if (Application.isPlaying) return;
+
+            base.OnValidate();
+
+            // we can't overwrite .target to be a Rigidbody.
+            // but we can ensure that .target has a Rigidbody, and use it.
+            if (target.GetComponent<Rigidbody>() == null)
+            {
+                Debug.LogWarning($"{name}'s NetworkRigidbody.target {target.name} is missing a Rigidbody", this);
+            }
+        }
+
+        // cach Rigidbody and original isKinematic setting
+        protected override void Awake()
+        {
+            // we can't overwrite .target to be a Rigidbody.
+            // but we can use its Rigidbody component.
+            rb = target.GetComponent<Rigidbody>();
+            if (rb == null)
+            {
+                Debug.LogError($"{name}'s NetworkRigidbody.target {target.name} is missing a Rigidbody", this);
+                return;
+            }
+            wasKinematic = rb.isKinematic;
+            base.Awake();
+        }
+
+        // reset forced isKinematic flag to original.
+        // otherwise the overwritten value would remain between sessions forever.
+        // for example, a game may run as client, set rigidbody.iskinematic=true,
+        // then run as server, where .iskinematic isn't touched and remains at
+        // the overwritten=true, even though the user set it to false originally.
+        public override void OnStopServer() => rb.isKinematic = wasKinematic;
+        public override void OnStopClient() => rb.isKinematic = wasKinematic;
+
+        // overwriting Construct() and Apply() to set Rigidbody.MovePosition
+        // would give more jittery movement.
+
+        // FixedUpdate for physics
+        void FixedUpdate()
+        {
+            // who ever has authority moves the Rigidbody with physics.
+            // everyone else simply sets it to kinematic.
+            // so that only the Transform component is synced.
+
+            // host mode
+            if (isServer && isClient)
+            {
+                // in host mode, we own it it if:
+                // clientAuthority is disabled (hence server / we own it)
+                // clientAuthority is enabled and we have authority over this object.
+                bool owned = !clientAuthority || IsClientWithAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+                if (!owned) rb.isKinematic = true;
+            }
+            // client only
+            else if (isClient)
+            {
+                // on the client, we own it only if clientAuthority is enabled,
+                // and we have authority over this object.
+                bool owned = IsClientWithAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+                if (!owned) rb.isKinematic = true;
+            }
+            // server only
+            else if (isServer)
+            {
+                // on the server, we always own it if clientAuthority is disabled.
+                bool owned = !clientAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+                if (!owned) rb.isKinematic = true;
+            }
+        }
+
+        protected override void OnTeleport(Vector3 destination)
+        {
+            base.OnTeleport(destination);
+
+            rb.position = transform.position;
+        }
+
+        protected override void OnTeleport(Vector3 destination, Quaternion rotation)
+        {
+            base.OnTeleport(destination, rotation);
+
+            rb.position = transform.position;
+            rb.rotation = transform.rotation;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 3b20dc110904e47f8a154cdcf6433eae
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkRigidbody/NetworkRigidbodyUnreliable.cs
+  uploadId: 736421

Assets/Mirror/Components/NetworkRigidbody/NetworkRigidbodyUnreliable2D.cs

@@ -0,0 +1,136 @@
+using UnityEngine;
+
+namespace Mirror
+{
+    // [RequireComponent(typeof(Rigidbody))] <- OnValidate ensures this is on .target
+    [AddComponentMenu("Network/Network Rigidbody 2D (Unreliable)")]
+    public class NetworkRigidbodyUnreliable2D : NetworkTransformUnreliable
+    {
+        bool clientAuthority => syncDirection == SyncDirection.ClientToServer;
+
+        Rigidbody2D rb;
+        bool wasKinematic;
+
+        protected override void OnValidate()
+        {
+            // Skip if Editor is in Play mode
+            if (Application.isPlaying) return;
+
+            base.OnValidate();
+
+            // we can't overwrite .target to be a Rigidbody.
+            // but we can ensure that .target has a Rigidbody, and use it.
+            if (target.GetComponent<Rigidbody2D>() == null)
+            {
+                Debug.LogWarning($"{name}'s NetworkRigidbody2D.target {target.name} is missing a Rigidbody2D", this);
+            }
+        }
+
+        // cach Rigidbody and original isKinematic setting
+        protected override void Awake()
+        {
+            // we can't overwrite .target to be a Rigidbody.
+            // but we can use its Rigidbody component.
+            rb = target.GetComponent<Rigidbody2D>();
+            if (rb == null)
+            {
+                Debug.LogError($"{name}'s NetworkRigidbody2D.target {target.name} is missing a Rigidbody2D", this);
+                return;
+            }
+
+#if UNITY_6000_0_OR_NEWER
+            wasKinematic = rb.bodyType.HasFlag(RigidbodyType2D.Kinematic);
+#else
+            wasKinematic = rb.isKinematic;
+#endif
+            base.Awake();
+        }
+
+        // reset forced isKinematic flag to original.
+        // otherwise the overwritten value would remain between sessions forever.
+        // for example, a game may run as client, set rigidbody.iskinematic=true,
+        // then run as server, where .iskinematic isn't touched and remains at
+        // the overwritten=true, even though the user set it to false originally.
+#if UNITY_6000_0_OR_NEWER
+        public override void OnStopServer() => rb.bodyType = wasKinematic ? RigidbodyType2D.Kinematic : RigidbodyType2D.Dynamic;
+        public override void OnStopClient() => rb.bodyType = wasKinematic ? RigidbodyType2D.Kinematic : RigidbodyType2D.Dynamic;
+#else
+        public override void OnStopServer() => rb.isKinematic = wasKinematic;
+        public override void OnStopClient() => rb.isKinematic = wasKinematic;
+#endif
+        // overwriting Construct() and Apply() to set Rigidbody.MovePosition
+        // would give more jittery movement.
+
+        // FixedUpdate for physics
+        void FixedUpdate()
+        {
+            // who ever has authority moves the Rigidbody with physics.
+            // everyone else simply sets it to kinematic.
+            // so that only the Transform component is synced.
+
+            // host mode
+            if (isServer && isClient)
+            {
+                // in host mode, we own it it if:
+                // clientAuthority is disabled (hence server / we own it)
+                // clientAuthority is enabled and we have authority over this object.
+                bool owned = !clientAuthority || IsClientWithAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+#if UNITY_6000_0_OR_NEWER
+                if (!owned) rb.bodyType = RigidbodyType2D.Kinematic;
+#else
+                if (!owned) rb.isKinematic = true;
+#endif
+            }
+            // client only
+            else if (isClient)
+            {
+                // on the client, we own it only if clientAuthority is enabled,
+                // and we have authority over this object.
+                bool owned = IsClientWithAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+#if UNITY_6000_0_OR_NEWER
+                if (!owned) rb.bodyType = RigidbodyType2D.Kinematic;
+#else
+                if (!owned) rb.isKinematic = true;
+#endif
+            }
+            // server only
+            else if (isServer)
+            {
+                // on the server, we always own it if clientAuthority is disabled.
+                bool owned = !clientAuthority;
+
+                // only set to kinematic if we don't own it
+                // otherwise don't touch isKinematic.
+                // the authority owner might use it either way.
+#if UNITY_6000_0_OR_NEWER
+                if (!owned) rb.bodyType = RigidbodyType2D.Kinematic;
+#else
+                if (!owned) rb.isKinematic = true;
+#endif
+            }
+        }
+
+        protected override void OnTeleport(Vector3 destination)
+        {
+            base.OnTeleport(destination);
+
+            rb.position = transform.position;
+        }
+
+        protected override void OnTeleport(Vector3 destination, Quaternion rotation)
+        {
+            base.OnTeleport(destination, rotation);
+
+            rb.position = transform.position;
+            rb.rotation = transform.rotation.eulerAngles.z;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 1c7e12ad9b9ae443c9fdf37e9f5ecd36
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkRigidbody/NetworkRigidbodyUnreliable2D.cs
+  uploadId: 736421

Assets/Mirror/Components/NetworkRoomManager.cs

@@ -0,0 +1,683 @@
+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 HashSet<PendingPlayer> pendingPlayers = new HashSet<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")]
+        [ReadOnly, 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>
+        [ReadOnly, Tooltip("List of Room Player objects")]
+        public HashSet<NetworkRoomPlayer> roomSlots = new HashSet<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()
+        {
+            base.OnValidate();
+
+            // 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.");
+                }
+            }
+        }
+
+        void SceneLoadedForPlayer(NetworkConnectionToClient conn, GameObject roomPlayer)
+        {
+            //Debug.Log($"NetworkRoom SceneLoadedForPlayer scene: {SceneManager.GetActiveScene().path} {conn}");
+
+            if (Utils.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, ReplacePlayerOptions.KeepAuthority);
+        }
+
+        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();
+                }
+        }
+
+        /// <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 (!Utils.IsSceneActive(RoomScene))
+                return;
+
+            int numberOfReadyPlayers = NetworkServer.connections.Count(conn =>
+                conn.Value != null &&
+                conn.Value.identity != null &&
+                conn.Value.identity.TryGetComponent(out NetworkRoomPlayer nrp) &&
+                nrp.readyToBegin);
+
+            bool enoughReadyPlayers = minPlayers <= 0 || numberOfReadyPlayers >= minPlayers;
+            if (enoughReadyPlayers)
+            {
+                pendingPlayers.Clear();
+                allPlayersReady = true;
+            }
+            else
+                allPlayersReady = false;
+        }
+
+        #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)
+        {
+            // cannot join game in progress
+            if (!Utils.IsSceneActive(RoomScene))
+            {
+                Debug.Log($"Not in Room scene...disconnecting {conn}");
+                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.owned)
+                {
+                    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 (Utils.IsSceneActive(RoomScene))
+                RecalculateRoomPlayerIndices();
+
+            OnRoomServerDisconnect(conn);
+            base.OnServerDisconnect(conn);
+
+            // Restart the server if we're headless and no players are connected.
+            // This will send server to offline scene, where auto-start will run.
+            if (Utils.IsHeadless() && numPlayers < 1)
+                StopServer();
+        }
+
+        // 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 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);
+            }
+        }
+
+        /// <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 (Utils.IsSceneActive(RoomScene))
+            {
+                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
+            {
+                // Late joiners not supported...should've been kicked by OnServerDisconnect
+                Debug.Log($"Not in Room scene...disconnecting {conn}");
+                conn.Disconnect();
+            }
+        }
+
+        [Server]
+        public void RecalculateRoomPlayerIndices()
+        {
+            if (roomSlots.Count > 0)
+            {
+                int i = 0;
+                foreach (NetworkRoomPlayer player in roomSlots)
+                    player.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, ReplacePlayerOptions.KeepAuthority);
+                    }
+                }
+
+                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()
+        {
+            OnRoomClientConnect();
+            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()
+        {
+            OnRoomClientDisconnect();
+            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 (Utils.IsSceneActive(RoomScene))
+            {
+                if (NetworkClient.isConnected)
+                    CallOnClientEnterRoom();
+            }
+            else
+                CallOnClientExitRoom();
+
+            base.OnClientSceneChanged();
+            OnRoomClientSceneChanged();
+        }
+
+        #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 server from NetworkRoomPlayer.CmdChangeReadyState when client indicates change in Ready status.
+        /// </summary>
+        public virtual 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>
+        /// 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() {}
+
+        /// <summary>
+        /// This is called on the client when disconnected from a server.
+        /// </summary>
+        public virtual void 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() {}
+
+        #endregion
+
+        #region optional UI
+
+        /// <summary>
+        /// virtual so inheriting classes can roll their own
+        /// </summary>
+        public virtual void OnGUI()
+        {
+            if (!showRoomGUI)
+                return;
+
+            if (NetworkServer.active && Utils.IsSceneActive(GameplayScene))
+            {
+                GUILayout.BeginArea(new Rect(Screen.width - 150f, 10f, 140f, 30f));
+                if (GUILayout.Button("Return to Room"))
+                    ServerChangeScene(RoomScene);
+                GUILayout.EndArea();
+            }
+
+            if (Utils.IsSceneActive(RoomScene))
+                GUI.Box(new Rect(10f, 180f, 520f, 150f), "PLAYERS");
+        }
+
+        #endregion
+    }
+}

Assets/Mirror/Components/NetworkRoomManager.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 615e6c6589cf9e54cad646b5a11e0529
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkRoomManager.cs
+  uploadId: 736421

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>
+        [ReadOnly, 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>
+        [ReadOnly, 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 virtual 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 (!Utils.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,18 @@
+fileFormatVersion: 2
+guid: 79874ac94d5b1314788ecf0e86bd23fd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7453abfe9e8b2c04a8a47eb536fe21eb, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 129321
+  packageName: Mirror
+  packageVersion: 96.0.1
+  assetPath: Assets/Mirror/Components/NetworkRoomPlayer.cs
+  uploadId: 736421

Assets/Mirror/Components/NetworkStatistics.cs

@@ -0,0 +1,194 @@
+using System;
+using UnityEngine;
+
+namespace Mirror
+{
+    /// <summary>
+    /// Shows Network messages and bytes sent and received per second.
+    /// </summary>
+    /// <remarks>
+    /// <para>Add this component to the same object as Network Manager.</para>
+    /// </remarks>
+    [AddComponentMenu("Network/Network Statistics")]
+    [DisallowMultipleComponent]
+    [HelpURL("https://mirror-networking.gitbook.io/docs/components/network-statistics")]
+    public class NetworkStatistics : MonoBehaviour
+    {
+        // update interval
+        double intervalStartTime;
+
+        // ---------------------------------------------------------------------
+
+        // CLIENT (public fields for other components to grab statistics)
+        // long bytes to support >2GB
+        [HideInInspector] public int  clientIntervalReceivedPackets;
+        [HideInInspector] public long clientIntervalReceivedBytes;
+        [HideInInspector] public int  clientIntervalSentPackets;
+        [HideInInspector] public long clientIntervalSentBytes;
+
+        // results from last interval
+        // long bytes to support >2GB
+        [HideInInspector] public int  clientReceivedPacketsPerSecond;
+        [HideInInspector] public long clientReceivedBytesPerSecond;
+        [HideInInspector] public int  clientSentPacketsPerSecond;
+        [HideInInspector] public long clientSentBytesPerSecond;
+
+        // ---------------------------------------------------------------------
+
+        // SERVER (public fields for other components to grab statistics)
+        // capture interval
+        // long bytes to support >2GB
+        [HideInInspector] public int  serverIntervalReceivedPackets;
+        [HideInInspector] public long serverIntervalReceivedBytes;
+        [HideInInspector] public int  serverIntervalSentPackets;
+        [HideInInspector] public long serverIntervalSentBytes;
+
+        // results from last interval
+        // long bytes to support >2GB
+        [HideInInspector] public int  serverReceivedPacketsPerSecond;
+        [HideInInspector] public long serverReceivedBytesPerSecond;
+        [HideInInspector] public int  serverSentPacketsPerSecond;
+        [HideInInspector] public long serverSentBytesPerSecond;
+
+        // NetworkManager sets Transport.active in Awake().
+        // so let's hook into it in Start().
+        void Start()
+        {
+            // find available transport
+            Transport transport = Transport.active;
+            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.active;
+            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
+                // 120 is below NetworkManager HUD in all cases.
+                GUILayout.BeginArea(new Rect(10, 120, 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();
+        }
+    }
+}