app.hypergames.hypersdk 1.11.0-beta.20 → 1.11.0-beta.21

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.11.0-beta.21](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.20...v1.11.0-beta.21) (2026-09-03)
+
+
+### Bug Fixes
+
+* **replay:** align gameplay activities to fixed ticks ([1e681b9](https://github.com/mvmhyper/hyper-sdk/commit/1e681b9c7f314a48c417f6e76cb2d4024c890ad3))
+
 # [1.11.0-beta.20](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.19...v1.11.0-beta.20) (2026-09-02)
 
 

package/Runtime/Public/Replay/ReplayPlaybackEngine.cs

@@ -29,6 +29,13 @@ namespace Hyper
         private double _stoppedElapsed;
         private bool _isSuspended;
         private bool _completionPending;
+        private bool _gameplayClockStarted;
+        private double _gameplaySourceStartTime;
+        private double _gameplayElapsedSeconds;
+        private double _gameplayStepSeconds;
+        private double _gameplayPauseDurationAtStart;
+        private long _gameplayTick;
+        private double _currentTickDelta;
 
         public event Action<float, float> OnValues2;
         public event Action<float> OnValue;
@@ -76,6 +83,13 @@ namespace Hyper
             _endedRaised = false;
             _completionPending = false;
             _nextActionPrepared = false;
+            _gameplayClockStarted = false;
+            _gameplaySourceStartTime = 0d;
+            _gameplayElapsedSeconds = 0d;
+            _gameplayStepSeconds = 0d;
+            _gameplayPauseDurationAtStart = 0d;
+            _gameplayTick = 0L;
+            _currentTickDelta = 0d;
             DurationSeconds = CalculateDuration(_ndjson);
             double gameplayStartSeconds = CalculateGameplayStart(_ndjson, out bool hasGameplayReadyMarker);
             HasGameplayReadyMarker = hasGameplayReadyMarker;
@@ -122,13 +136,19 @@ namespace Hyper
                            double.IsInfinity(fixedSimulationDeltaSeconds)
                 ? 0d
                 : Math.Max(0d, fixedSimulationDeltaSeconds);
+            _currentTickDelta = delta;
             _elapsedSeconds += delta;
+            if (_gameplayClockStarted && delta > 0d)
+            {
+                if (_gameplayStepSeconds <= 0d) _gameplayStepSeconds = delta;
+                _gameplayElapsedSeconds += delta;
+                _gameplayTick++;
+            }
 
             int processed = 0;
             while (IsPlaying && !_completionPending && _hasNext && processed++ < MaxActivitiesPerTick)
             {
-                double elapsed = GetElapsedSeconds();
-                double dueTime = _next.Time - _sourceStartTime - _removedPauseDuration;
+                GetSchedulingTime(_next, out double elapsed, out double dueTime);
                 PrepareNextActionIfDue(elapsed, dueTime);
                 if (elapsed + 0.000001d < dueTime) return;
 
@@ -154,6 +174,13 @@ namespace Hyper
             _isSuspended = false;
             _completionPending = false;
             _nextActionPrepared = false;
+            _gameplayClockStarted = false;
+            _gameplaySourceStartTime = 0d;
+            _gameplayElapsedSeconds = 0d;
+            _gameplayStepSeconds = 0d;
+            _gameplayPauseDurationAtStart = 0d;
+            _gameplayTick = 0L;
+            _currentTickDelta = 0d;
         }
 
         public void Suspend()
@@ -224,6 +251,7 @@ namespace Hyper
                     OnGameStarted?.Invoke();
                     break;
                 case GameplayReady:
+                    StartGameplayClock(activity.Time);
                     OnGameplayReady?.Invoke();
                     break;
                 case GamePaused:
@@ -255,6 +283,47 @@ namespace Hyper
             OnActionPreparing?.Invoke(_next.Action);
         }
 
+        private void StartGameplayClock(double sourceTime)
+        {
+            _gameplayClockStarted = true;
+            _gameplaySourceStartTime = sourceTime;
+            _gameplayElapsedSeconds = 0d;
+            _gameplayStepSeconds = _currentTickDelta;
+            _gameplayPauseDurationAtStart = _removedPauseDuration;
+            _gameplayTick = 0L;
+        }
+
+        private void GetSchedulingTime(ReplayActivity activity, out double elapsed, out double dueTime)
+        {
+            if (!_gameplayClockStarted)
+            {
+                elapsed = GetElapsedSeconds();
+                dueTime = activity.Time - _sourceStartTime - _removedPauseDuration;
+                return;
+            }
+
+            double removedGameplayPauses = Math.Max(0d,
+                _removedPauseDuration - _gameplayPauseDurationAtStart);
+            double rawDueTime = Math.Max(0d,
+                activity.Time - _gameplaySourceStartTime - removedGameplayPauses);
+
+            if (_gameplayStepSeconds <= 0d)
+            {
+                elapsed = _gameplayElapsedSeconds;
+                dueTime = rawDueTime;
+                return;
+            }
+
+            // Gameplay can only consume an activity on a fixed step. Mapping the
+            // timestamp to its nearest GPR-relative tick prevents sub-step JSON
+            // precision noise from moving an input to the following physics step.
+            long dueTick = Math.Max(0L, (long)Math.Round(
+                rawDueTime / _gameplayStepSeconds,
+                MidpointRounding.AwayFromZero));
+            elapsed = _gameplayTick * _gameplayStepSeconds;
+            dueTime = dueTick * _gameplayStepSeconds;
+        }
+
         private static bool IsLifecycleAction(string action)
         {
             return action == GameStarted || action == GamePaused ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "app.hypergames.hypersdk",
-  "version": "1.11.0-beta.20",
+  "version": "1.11.0-beta.21",
   "displayName": "HyperSDK",
   "description": "Official Unity SDK for Hyper: multiplayer battles, leaderboards, deterministic RNG, session management, tutorials, and WebGL optimizations for production-ready games.",
   "unity": "6000.0",