From 637bed194f099aeb908cdf80140cc384db414c0f Mon Sep 17 00:00:00 2001 From: MrGadget <9826063+MrGadget1024@users.noreply.github.com> Date: Sat, 20 Jun 2026 03:37:42 -0400 Subject: [PATCH 1/7] feat: Configurable Intervals --- Assets/Mirror/Core/NetworkClient.cs | 25 ++++++++--- .../Mirror/Core/NetworkConnectionToClient.cs | 2 +- Assets/Mirror/Core/NetworkManager.cs | 41 +++++++++++++++---- Assets/Mirror/Core/NetworkServer.cs | 29 +++++++------ Assets/Mirror/Core/NetworkTime.cs | 2 +- .../NetworkConnectionToClientTests.cs | 9 +++- 6 files changed, 78 insertions(+), 30 deletions(-) diff --git a/Assets/Mirror/Core/NetworkClient.cs b/Assets/Mirror/Core/NetworkClient.cs index fc77d7941ad..8b0284a6d8e 100644 --- a/Assets/Mirror/Core/NetworkClient.cs +++ b/Assets/Mirror/Core/NetworkClient.cs @@ -29,10 +29,23 @@ public static partial class NetworkClient // otherwise it's too easy to accidentally cause interpolation issues if // a component sends with client.interval but interpolates with // server.interval, etc. - public static int sendRate => NetworkServer.sendRate; - public static float sendInterval => sendRate < int.MaxValue ? 1f / sendRate : 0; // for 30 Hz, that's 33ms + public static int sendRate = 30; + public static float sendInterval => sendRate > 0 ? 1f / sendRate : 0f; // 0 = disabled static double lastSendTime; + /// Client Update frequency, per second. Use around 60Hz for fast paced games like Counter-Strike to minimize latency. Use around 30Hz for games like WoW to minimize computations. Use around 1-10Hz for slow paced games like EVE. + // overwritten by NetworkManager (if any) + public static int tickRate = 30; + + // tick rate is in Hz. + // convert to interval in seconds for convenience where needed. + // + // tick interval is 1 / tickRate. + // but for tests we need a way to set it to exactly 0. + // 1 / int.max would not be exactly 0, so handel that manually. + public static float tickInterval => tickRate > 0 ? 1f / tickRate : 0f; // 0 = disabled + static double lastTickTime; + // ocassionally send a full reliable state for unreliable components to delta compress against. // this only applies to Components with SyncMethod=Unreliable. public static int unreliableBaselineRate => NetworkServer.unreliableBaselineRate; @@ -1726,8 +1739,8 @@ internal static void NetworkLateUpdate() // snapshots _but_ not every single tick. // // Unity 2019 doesn't have Time.timeAsDouble yet - bool sendIntervalElapsed = AccurateInterval.Elapsed(NetworkTime.localTime, sendInterval, ref lastSendTime); - bool unreliableBaselineElapsed = AccurateInterval.Elapsed(NetworkTime.localTime, unreliableBaselineInterval, ref lastUnreliableBaselineTime); + bool sendIntervalElapsed = sendInterval > 0 && AccurateInterval.Elapsed(NetworkTime.localTime, sendInterval, ref lastSendTime); + bool unreliableBaselineElapsed = unreliableBaselineInterval > 0 && AccurateInterval.Elapsed(NetworkTime.localTime, unreliableBaselineInterval, ref lastUnreliableBaselineTime); if (!Application.isPlaying || sendIntervalElapsed) { Broadcast(unreliableBaselineElapsed); @@ -1805,7 +1818,9 @@ static void Broadcast(bool unreliableBaselineElapsed) if (NetworkServer.active) return; // send time snapshot every sendInterval. - Send(new TimeSnapshotMessage(), Channels.Unreliable); + bool tickIntervalElapsed = tickInterval > 0 && AccurateInterval.Elapsed(NetworkTime.localTime, tickInterval, ref lastTickTime); + if (tickIntervalElapsed) + Send(new TimeSnapshotMessage(), Channels.Unreliable); // broadcast client state to server BroadcastToServer(unreliableBaselineElapsed); diff --git a/Assets/Mirror/Core/NetworkConnectionToClient.cs b/Assets/Mirror/Core/NetworkConnectionToClient.cs index df82ef91100..6c24bf37197 100644 --- a/Assets/Mirror/Core/NetworkConnectionToClient.cs +++ b/Assets/Mirror/Core/NetworkConnectionToClient.cs @@ -134,7 +134,7 @@ protected override void SendToTransport(ArraySegment segment, int channelI protected virtual void UpdatePing() { // localTime (double) instead of Time.time for accuracy over days - if (NetworkTime.localTime >= lastPingTime + NetworkTime.PingInterval) + if (NetworkTime.PingInterval > 0 && NetworkTime.localTime >= lastPingTime + NetworkTime.PingInterval) { // TODO it would be safer for the server to store the last N // messages' timestamp and only send a message number. diff --git a/Assets/Mirror/Core/NetworkManager.cs b/Assets/Mirror/Core/NetworkManager.cs index 80c588bab5c..d87f3ed34cf 100644 --- a/Assets/Mirror/Core/NetworkManager.cs +++ b/Assets/Mirror/Core/NetworkManager.cs @@ -38,10 +38,21 @@ public class NetworkManager : MonoBehaviour public bool editorAutoStart; [Header("Sync Settings")] - /// Server Update frequency, per second. Use around 60Hz for fast paced games like Counter-Strike to minimize latency. Use around 30Hz for games like WoW to minimize computations. Use around 1-10Hz for slow paced games like EVE. - [Tooltip("Server / Client send rate per second.\nUse 60-100Hz for fast paced games like Counter-Strike to minimize latency.\nUse around 30Hz for games like WoW to minimize computations.\nUse around 1-10Hz for slow paced games like EVE.")] + /// Send frequency in Hz for network snapshots/messages. + [Tooltip("Send rate in Hz for server/client snapshots and messages.")] + [Range(1, 60)] + public int sendRate = 30; + + /// Server simulation frequency in Hz. [FormerlySerializedAs("serverTickRate")] - public int sendRate = 60; + [Tooltip("Tick rate in Hz for server simulation.\nSet this to match Send Rate, or set to 0 if not using NetworkTransform.")] + [Range (0, 60)] + public int tickRate = 30; + + /// Ping/Pong frequency in Hz for RTT/prediction updates. + [Tooltip("Ping rate in Hz for RTT/prediction updates.\nSet to 0 to disable ping.\nCan be lower than Send Rate for games not using NetworkTransform.")] + [Range(1, 60)] + public int pingRate = 10; /// [Tooltip("Ocassionally send a full reliable state for unreliable components to delta compress against. This only applies to Components with SyncMethod=Unreliable.")] @@ -176,10 +187,16 @@ public class NetworkManager : MonoBehaviour // virtual so that inheriting classes' OnValidate() can call base.OnValidate() too public virtual void OnValidate() { - // unreliable full send rate needs to be >= 0. - // we need to have something to delta compress against. - // it should also be <= sendRate otherwise there's no point. - unreliableBaselineRate = Mathf.Clamp(unreliableBaselineRate, 1, sendRate); + sendRate = Mathf.Max(sendRate, 0); + tickRate = Mathf.Max(tickRate, 0); + pingRate = Mathf.Max(pingRate, 0); + + // tick rate should either match send rate or be disabled. + if (tickRate > 0) tickRate = sendRate; + + // unreliable baseline depends on send rate. + // if send is disabled, baseline must be disabled too. + unreliableBaselineRate = sendRate == 0 ? 0 : Mathf.Clamp(unreliableBaselineRate, 1, sendRate); // always >= 0 maxConnections = Mathf.Max(maxConnections, 0); @@ -289,9 +306,15 @@ bool IsServerOnlineSceneChangeNeeded() => // => all exposed settings should be applied at all times if NM exists. void ApplyConfiguration() { - NetworkServer.tickRate = sendRate; + NetworkServer.tickRate = tickRate; + NetworkServer.sendRate = sendRate; + NetworkClient.sendRate = sendRate; + NetworkServer.unreliableBaselineRate = unreliableBaselineRate; NetworkServer.unreliableRedundancy = unreliableRedundancy; + + NetworkTime.PingInterval = pingRate > 0 ? 1f / pingRate : 0f; + NetworkClient.snapshotSettings = snapshotSettings; NetworkClient.connectionQualityInterval = evaluationInterval; NetworkClient.connectionQualityMethod = evaluationMethod; @@ -686,7 +709,7 @@ public virtual void ConfigureHeadlessFrameRate() { if (Utils.IsHeadless()) { - Application.targetFrameRate = sendRate; + Application.targetFrameRate = sendRate > 0 ? sendRate : -1; // Debug.Log($"Server Tick Rate set to {Application.targetFrameRate} Hz."); } } diff --git a/Assets/Mirror/Core/NetworkServer.cs b/Assets/Mirror/Core/NetworkServer.cs index e35dca6431b..47f49ae72af 100644 --- a/Assets/Mirror/Core/NetworkServer.cs +++ b/Assets/Mirror/Core/NetworkServer.cs @@ -36,28 +36,29 @@ public static partial class NetworkServer /// Server Update frequency, per second. Use around 60Hz for fast paced games like Counter-Strike to minimize latency. Use around 30Hz for games like WoW to minimize computations. Use around 1-10Hz for slow paced games like EVE. // overwritten by NetworkManager (if any) - public static int tickRate = 60; + public static int tickRate = 30; // tick rate is in Hz. // convert to interval in seconds for convenience where needed. // - // send interval is 1 / sendRate. + // tick interval is 1 / tickRate. // but for tests we need a way to set it to exactly 0. // 1 / int.max would not be exactly 0, so handel that manually. - public static float tickInterval => tickRate < int.MaxValue ? 1f / tickRate : 0; // for 30 Hz, that's 33ms + public static float tickInterval => tickRate > 0 ? 1f / tickRate : 0f; // 0 = disabled + static double lastTickTime; // time & value snapshot interpolation are separate. // -> time is interpolated globally on NetworkClient / NetworkConnection // -> value is interpolated per-component, i.e. NetworkTransform. // however, both need to be on the same send interval. - public static int sendRate => tickRate; - public static float sendInterval => sendRate < int.MaxValue ? 1f / sendRate : 0; // for 30 Hz, that's 33ms + public static int sendRate = 30; + public static float sendInterval => sendRate > 0 ? 1f / sendRate : 0f; // 0 = disabled static double lastSendTime; // ocassionally send a full reliable state for unreliable components to delta compress against. // this only applies to Components with SyncMethod=Unreliable. public static int unreliableBaselineRate = 1; - public static float unreliableBaselineInterval => unreliableBaselineRate < int.MaxValue ? 1f / unreliableBaselineRate : 0; // for 1 Hz, that's 1000ms + public static float unreliableBaselineInterval => unreliableBaselineRate > 0 ? 1f / unreliableBaselineRate : 0f; static double lastUnreliableBaselineTime; // quake sends unreliable messages twice to make up for message drops. @@ -216,9 +217,10 @@ static void Initialize() initialized = true; // profiling - earlyUpdateDuration = new TimeSample(sendRate); - lateUpdateDuration = new TimeSample(sendRate); - fullUpdateDuration = new TimeSample(sendRate); + int profilingSampleSize = Mathf.Max(1, sendRate); + earlyUpdateDuration = new TimeSample(profilingSampleSize); + lateUpdateDuration = new TimeSample(profilingSampleSize); + fullUpdateDuration = new TimeSample(profilingSampleSize); } static void AddTransportHandlers() @@ -2272,6 +2274,8 @@ static void Broadcast(bool unreliableBaselineElapsed) connectionsCopy.Clear(); connections.Values.CopyTo(connectionsCopy); + bool tickIntervalElapsed = tickInterval > 0 && AccurateInterval.Elapsed(NetworkTime.localTime, tickInterval, ref lastTickTime); + // go through all connections foreach (NetworkConnectionToClient connection in connectionsCopy) { @@ -2293,7 +2297,8 @@ static void Broadcast(bool unreliableBaselineElapsed) // make sure Broadcast() is only called every sendInterval, // even if targetFrameRate isn't set in host mode (!) // (done via AccurateInterval) - connection.Send(new TimeSnapshotMessage(), Channels.Unreliable); + if (tickIntervalElapsed) + connection.Send(new TimeSnapshotMessage(), Channels.Unreliable); // broadcast world state to this connection BroadcastToConnection(connection, unreliableBaselineElapsed); @@ -2349,8 +2354,8 @@ internal static void NetworkLateUpdate() // NetworkTransform, so they can sync on same interval as time // snapshots _but_ not every single tick. // Unity 2019 doesn't have Time.timeAsDouble yet - bool sendIntervalElapsed = AccurateInterval.Elapsed(NetworkTime.localTime, sendInterval, ref lastSendTime); - bool unreliableBaselineElapsed = AccurateInterval.Elapsed(NetworkTime.localTime, unreliableBaselineInterval, ref lastUnreliableBaselineTime); + bool sendIntervalElapsed = sendInterval > 0 && AccurateInterval.Elapsed(NetworkTime.localTime, sendInterval, ref lastSendTime); + bool unreliableBaselineElapsed = unreliableBaselineInterval > 0 && AccurateInterval.Elapsed(NetworkTime.localTime, unreliableBaselineInterval, ref lastUnreliableBaselineTime); if (!Application.isPlaying || sendIntervalElapsed) Broadcast(unreliableBaselineElapsed); } diff --git a/Assets/Mirror/Core/NetworkTime.cs b/Assets/Mirror/Core/NetworkTime.cs index 6319970c45b..42afeeea60d 100644 --- a/Assets/Mirror/Core/NetworkTime.cs +++ b/Assets/Mirror/Core/NetworkTime.cs @@ -140,7 +140,7 @@ public static void ResetStatics() internal static void UpdateClient() { // localTime (double) instead of Time.time for accuracy over days - if (localTime >= lastPingTime + PingInterval) + if (PingInterval > 0 && localTime >= lastPingTime + PingInterval) SendPing(); } diff --git a/Assets/Mirror/Tests/Editor/NetworkConnection/NetworkConnectionToClientTests.cs b/Assets/Mirror/Tests/Editor/NetworkConnection/NetworkConnectionToClientTests.cs index d20edec5e5b..3ea20e2daee 100644 --- a/Assets/Mirror/Tests/Editor/NetworkConnection/NetworkConnectionToClientTests.cs +++ b/Assets/Mirror/Tests/Editor/NetworkConnection/NetworkConnectionToClientTests.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using NUnit.Framework; using UnityEngine; +using System.Reflection; namespace Mirror.Tests.NetworkConnections { @@ -136,13 +137,17 @@ public void IsAlive_ReturnsFalseWhenTimedOut() [Test] public void UpdatePing_SendsPingWhenIntervalElapsed() { - // PingInterval = -1f ensures localTime >= lastPingTime + (-1) is always true float savedPingInterval = NetworkTime.PingInterval; try { - NetworkTime.PingInterval = -1f; + NetworkTime.PingInterval = 0.1f; NetworkConnectionToClient connection = new NetworkConnectionToClient(1); + // force "interval elapsed" deterministically + FieldInfo lastPingTimeField = typeof(NetworkConnectionToClient) + .GetField("lastPingTime", BindingFlags.Instance | BindingFlags.NonPublic); + lastPingTimeField.SetValue(connection, -1d); + // Update() calls UpdatePing (fires ping) then flushes the unreliable batcher connection.Update(); UpdateTransport(); From 8d33dd12a946a84c97ece8312d64c2632c7d1bfe Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 14 Jul 2026 20:06:45 +0000 Subject: [PATCH 2/7] fix: resolve merge conflicts - add scaledTime to TimeSnapshotMessage sends --- Assets/Mirror/Core/NetworkClient.cs | 6 +----- Assets/Mirror/Core/NetworkServer.cs | 6 +----- 2 files changed, 2 insertions(+), 10 deletions(-) diff --git a/Assets/Mirror/Core/NetworkClient.cs b/Assets/Mirror/Core/NetworkClient.cs index 8e587f4687c..1fb7633abe3 100644 --- a/Assets/Mirror/Core/NetworkClient.cs +++ b/Assets/Mirror/Core/NetworkClient.cs @@ -1819,13 +1819,9 @@ static void Broadcast(bool unreliableBaselineElapsed) if (NetworkServer.active) return; // send time snapshot every sendInterval. -<<<<<<< HEAD bool tickIntervalElapsed = tickInterval > 0 && AccurateInterval.Elapsed(NetworkTime.localTime, tickInterval, ref lastTickTime); if (tickIntervalElapsed) - Send(new TimeSnapshotMessage(), Channels.Unreliable); -======= - Send(new TimeSnapshotMessage { scaledTime = NetworkTime.localScaledTime }, Channels.Unreliable); ->>>>>>> origin/master + Send(new TimeSnapshotMessage { scaledTime = NetworkTime.localScaledTime }, Channels.Unreliable); // broadcast client state to server BroadcastToServer(unreliableBaselineElapsed); diff --git a/Assets/Mirror/Core/NetworkServer.cs b/Assets/Mirror/Core/NetworkServer.cs index c0119649401..164a19f748f 100644 --- a/Assets/Mirror/Core/NetworkServer.cs +++ b/Assets/Mirror/Core/NetworkServer.cs @@ -2294,12 +2294,8 @@ static void Broadcast(bool unreliableBaselineElapsed) // make sure Broadcast() is only called every sendInterval, // even if targetFrameRate isn't set in host mode (!) // (done via AccurateInterval) -<<<<<<< HEAD if (tickIntervalElapsed) - connection.Send(new TimeSnapshotMessage(), Channels.Unreliable); -======= - connection.Send(new TimeSnapshotMessage { scaledTime = NetworkTime.localScaledTime }, Channels.Unreliable); ->>>>>>> origin/master + connection.Send(new TimeSnapshotMessage { scaledTime = NetworkTime.localScaledTime }, Channels.Unreliable); // broadcast world state to this connection BroadcastToConnection(connection, unreliableBaselineElapsed); From c4f5fa63f731fb43e7fa510edb1cfdb3f87e53cd Mon Sep 17 00:00:00 2001 From: MrGadget <9826063+MrGadget1024@users.noreply.github.com> Date: Thu, 6 Aug 2026 09:00:56 -0400 Subject: [PATCH 3/7] NetworkClient tickRate now set in ApplyConfiguration Default lowered to 2Hz --- Assets/Mirror/Core/NetworkManager.cs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Assets/Mirror/Core/NetworkManager.cs b/Assets/Mirror/Core/NetworkManager.cs index d87f3ed34cf..dd6a93d9842 100644 --- a/Assets/Mirror/Core/NetworkManager.cs +++ b/Assets/Mirror/Core/NetworkManager.cs @@ -50,9 +50,9 @@ public class NetworkManager : MonoBehaviour public int tickRate = 30; /// Ping/Pong frequency in Hz for RTT/prediction updates. - [Tooltip("Ping rate in Hz for RTT/prediction updates.\nSet to 0 to disable ping.\nCan be lower than Send Rate for games not using NetworkTransform.")] + [Tooltip("Ping rate in Hz for RTT/prediction updates.\nCan be lower than Send Rate for games not using NetworkTransform.")] [Range(1, 60)] - public int pingRate = 10; + public int pingRate = 2; /// [Tooltip("Ocassionally send a full reliable state for unreliable components to delta compress against. This only applies to Components with SyncMethod=Unreliable.")] @@ -308,6 +308,8 @@ void ApplyConfiguration() { NetworkServer.tickRate = tickRate; NetworkServer.sendRate = sendRate; + + NetworkClient.tickRate = tickRate; NetworkClient.sendRate = sendRate; NetworkServer.unreliableBaselineRate = unreliableBaselineRate; From 549bc8583f211b23bd761f4a0e774cb56628ac86 Mon Sep 17 00:00:00 2001 From: MrGadget <9826063+MrGadget1024@users.noreply.github.com> Date: Thu, 6 Aug 2026 09:18:11 -0400 Subject: [PATCH 4/7] More sane range and default for pingRate --- Assets/Mirror/Core/NetworkManager.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Assets/Mirror/Core/NetworkManager.cs b/Assets/Mirror/Core/NetworkManager.cs index dd6a93d9842..c49babbc8be 100644 --- a/Assets/Mirror/Core/NetworkManager.cs +++ b/Assets/Mirror/Core/NetworkManager.cs @@ -50,9 +50,9 @@ public class NetworkManager : MonoBehaviour public int tickRate = 30; /// Ping/Pong frequency in Hz for RTT/prediction updates. - [Tooltip("Ping rate in Hz for RTT/prediction updates.\nCan be lower than Send Rate for games not using NetworkTransform.")] - [Range(1, 60)] - public int pingRate = 2; + [Tooltip("Ping rate in Hz for RTT/prediction updates.\nDefault 0.5 = every 2 seconds")] + [Range(0.01f, 10f)] + public float pingRate = 0.5f; /// [Tooltip("Ocassionally send a full reliable state for unreliable components to delta compress against. This only applies to Components with SyncMethod=Unreliable.")] From 141be0e02f1313e56e5d81f00a51bab79af1f849 Mon Sep 17 00:00:00 2001 From: MrGadget <9826063+MrGadget1024@users.noreply.github.com> Date: Thu, 6 Aug 2026 14:38:28 -0400 Subject: [PATCH 5/7] Updated CI action versions and Semantic --- .github/workflows/RunUnityTests.yml | 4 ++-- .github/workflows/Semantic.yml | 15 +++++---------- 2 files changed, 7 insertions(+), 12 deletions(-) diff --git a/.github/workflows/RunUnityTests.yml b/.github/workflows/RunUnityTests.yml index 659c3515401..5a03b341f1f 100644 --- a/.github/workflows/RunUnityTests.yml +++ b/.github/workflows/RunUnityTests.yml @@ -16,11 +16,11 @@ jobs: - 2021.3.45f2 - 2022.3.62f3 - 2023.2.22f1 - - 6000.5.7f1 + - 6000.5.7f1 steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@v7 # Do Not Enable Caching --- Library needs to be recompiled every time because Weaver # Leaving this here for posterity to ensure we never turn this on. diff --git a/.github/workflows/Semantic.yml b/.github/workflows/Semantic.yml index da8334a9650..d2d582fbe2a 100644 --- a/.github/workflows/Semantic.yml +++ b/.github/workflows/Semantic.yml @@ -13,33 +13,28 @@ jobs: steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@v7 with: fetch-depth: 0 - # - name: Setup .NET - # uses: actions/setup-dotnet@v4 - # with: - # dotnet-version: '8.0.x' - - name: Install dotnet-script run: | dotnet tool install -g dotnet-script dotnet script --version - name: Setup Node.js - uses: actions/setup-node@v4 + uses: actions/setup-node@v7 with: node-version: '*' - name: Install conventional-changelog-conventionalcommits run: npm i -D conventional-changelog-conventionalcommits - - name: Install semantic-release fork - run: npm install --save-dev github:MrGadget1024/semantic-release + # - name: Install semantic-release fork + # run: npm install --save-dev github:MrGadget1024/semantic-release - name: Install Plugins - run: npm i -D @semantic-release/exec --legacy-peer-deps + run: npm i -D @semantic-release/exec - name: Release run: npx semantic-release From d5bda68203dcbc963173a3c51c3994e1110e3761 Mon Sep 17 00:00:00 2001 From: MrGadget <9826063+MrGadget1024@users.noreply.github.com> Date: Thu, 6 Aug 2026 15:09:31 -0400 Subject: [PATCH 6/7] Revert "Updated CI action versions and Semantic" This reverts commit 141be0e02f1313e56e5d81f00a51bab79af1f849. --- .github/workflows/RunUnityTests.yml | 4 ++-- .github/workflows/Semantic.yml | 15 ++++++++++----- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/.github/workflows/RunUnityTests.yml b/.github/workflows/RunUnityTests.yml index 5a03b341f1f..659c3515401 100644 --- a/.github/workflows/RunUnityTests.yml +++ b/.github/workflows/RunUnityTests.yml @@ -16,11 +16,11 @@ jobs: - 2021.3.45f2 - 2022.3.62f3 - 2023.2.22f1 - - 6000.5.7f1 + - 6000.5.7f1 steps: - name: Checkout repository - uses: actions/checkout@v7 + uses: actions/checkout@v4 # Do Not Enable Caching --- Library needs to be recompiled every time because Weaver # Leaving this here for posterity to ensure we never turn this on. diff --git a/.github/workflows/Semantic.yml b/.github/workflows/Semantic.yml index d2d582fbe2a..da8334a9650 100644 --- a/.github/workflows/Semantic.yml +++ b/.github/workflows/Semantic.yml @@ -13,28 +13,33 @@ jobs: steps: - name: Checkout repository - uses: actions/checkout@v7 + uses: actions/checkout@v4 with: fetch-depth: 0 + # - name: Setup .NET + # uses: actions/setup-dotnet@v4 + # with: + # dotnet-version: '8.0.x' + - name: Install dotnet-script run: | dotnet tool install -g dotnet-script dotnet script --version - name: Setup Node.js - uses: actions/setup-node@v7 + uses: actions/setup-node@v4 with: node-version: '*' - name: Install conventional-changelog-conventionalcommits run: npm i -D conventional-changelog-conventionalcommits - # - name: Install semantic-release fork - # run: npm install --save-dev github:MrGadget1024/semantic-release + - name: Install semantic-release fork + run: npm install --save-dev github:MrGadget1024/semantic-release - name: Install Plugins - run: npm i -D @semantic-release/exec + run: npm i -D @semantic-release/exec --legacy-peer-deps - name: Release run: npx semantic-release From 08636dc6d86eb8f58566932d7393cf82f9208641 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 14 Aug 2026 14:29:57 +0000 Subject: [PATCH 7/7] fix: restore original default sendRate=60, tickRate=60, pingRate=10Hz Co-authored-by: miwarnec <16416509+miwarnec@users.noreply.github.com> --- Assets/Mirror/Core/NetworkManager.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Assets/Mirror/Core/NetworkManager.cs b/Assets/Mirror/Core/NetworkManager.cs index c49babbc8be..1f69c050912 100644 --- a/Assets/Mirror/Core/NetworkManager.cs +++ b/Assets/Mirror/Core/NetworkManager.cs @@ -41,18 +41,18 @@ public class NetworkManager : MonoBehaviour /// Send frequency in Hz for network snapshots/messages. [Tooltip("Send rate in Hz for server/client snapshots and messages.")] [Range(1, 60)] - public int sendRate = 30; + public int sendRate = 60; /// Server simulation frequency in Hz. [FormerlySerializedAs("serverTickRate")] [Tooltip("Tick rate in Hz for server simulation.\nSet this to match Send Rate, or set to 0 if not using NetworkTransform.")] [Range (0, 60)] - public int tickRate = 30; + public int tickRate = 60; /// Ping/Pong frequency in Hz for RTT/prediction updates. - [Tooltip("Ping rate in Hz for RTT/prediction updates.\nDefault 0.5 = every 2 seconds")] + [Tooltip("Ping rate in Hz for RTT/prediction updates.\nDefault 10 = every 0.1 seconds")] [Range(0.01f, 10f)] - public float pingRate = 0.5f; + public float pingRate = 10f; /// [Tooltip("Ocassionally send a full reliable state for unreliable components to delta compress against. This only applies to Components with SyncMethod=Unreliable.")]