app.hypergames.hypersdk 1.11.0-beta.1 → 1.11.0-beta.2

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+# [1.11.0-beta.2](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.1...v1.11.0-beta.2) (2026-08-27)
+
+
+### Bug Fixes
+
+* **replay:** respect custom restart flows ([7470a17](https://github.com/mvmhyper/hyper-sdk/commit/7470a17c60534465500a202c24b0e360f61850fc))
+* **replay:** shorten automatic replay start ([d05dc92](https://github.com/mvmhyper/hyper-sdk/commit/d05dc9267fbf05d392135eac3bb7c4f69b786eff))
+* **timer:** align game time with fixed simulation ([b690d86](https://github.com/mvmhyper/hyper-sdk/commit/b690d861e178f05b21f1a7fbd87e255d97008a8b))
+
 # [1.11.0-beta.1](https://github.com/mvmhyper/hyper-sdk/compare/v1.10.0...v1.11.0-beta.1) (2026-08-26)
 
 

package/Runtime/Internal/Core/HyperRuntime.cs

@@ -118,13 +118,13 @@ namespace Hyper.Internal
         }
 
         /// <summary>
-        /// Restarts a replay from HyperLoader even when custom restart is enabled.
-        /// Replay metadata, including the original seed value, remains available to the loader.
+        /// Restarts replay playback while preserving its downloaded data and original seed.
+        /// Uses the configured custom restart flow when available, otherwise reloads HyperLoader.
         /// </summary>
         internal static void RestartReplaySession()
         {
             ReplaySessionState.ResetForWatchAgain();
-            RestartReplayFromLoader();
+            RestartReplay();
         }
 
         internal static void SeekReplaySession(float targetProgress, float resumeSpeed, float seekSpeed)
@@ -133,14 +133,25 @@ namespace Hyper.Internal
 
             ReplaySessionState.RequestSeek(targetProgress, resumeSpeed, seekSpeed);
             ReplaySessionState.ResetForSeekRestart();
-            RestartReplayFromLoader();
+            RestartReplay();
         }
 
-        private static void RestartReplayFromLoader()
+        private static void RestartReplay()
         {
             _isSoftRestarting = true;
             Time.timeScale = 1f;
 
+            if (_settings != null && _settings.useCustomRestartFlow &&
+                _gameManager != null && _eventManager != null)
+            {
+                _replayManager?.PrepareForRestart();
+                ResetReplayRandomState();
+                _gameManager.ResetUIStateForCustomRestart();
+                _eventManager.InvokeCustomRestartEvent();
+                _isSoftRestarting = false;
+                return;
+            }
+
             if (_host != null)
             {
                 _host.StartCoroutine(RestartSessionCoroutine());
@@ -152,6 +163,19 @@ namespace Hyper.Internal
             }
         }
 
+        internal static void ResetReplayRandomState()
+        {
+            int originalSeed = unchecked((int)ReplaySessionState.OriginalRandomSeed);
+            if (HyperRandom.CurrentSeed == originalSeed)
+            {
+                // Preserve references held by game code while rewinding every stream.
+                HyperRandom.ResetAll();
+                return;
+            }
+
+            HyperRandom.Init(ReplaySessionState.OriginalRandomSeed);
+        }
+
         /// <summary>
         /// Coroutine-based restart that properly unloads all scenes before reloading.
         /// Handles async scene operations and ensures clean state before restart.

package/Runtime/Internal/Managers/GameManager.cs

@@ -1068,20 +1068,33 @@ namespace Hyper.Internal.Managers
         {
             HideGameOverModal();
             HidePauseModals();
+            if (_replayOverModal != null) _replayOverModal.SetActive(false);
 
             // Reset game state flags
             _hasGameStarted = false;
             _gameStartRequested = false;
             _hasGameEnded = false;
+            _replayEndHandled = false;
+            _replayFocusSuspended = false;
             _isPaused = false;
             _isFrozenBeforePause = false;
 
-            HyperRuntime.Timer.Reset();
+            HyperRuntime.Timer.ResetForGameRestart();
             HyperRuntime.DataManager.UpdateScore(0);
             HyperRuntime.DataManager.RestoreAudioAfterGameSessionEnd();
 
             ShowControlBarElements();
-            ShowStartingInstructionModal();
+            _replayControllerComponent?.ResetForReplayRestart();
+
+            if (IsReplayMode && ReplaySessionState.IsSeeking)
+            {
+                HideStartingInstructionModal();
+                StartCoroutine(StartSeekingReplayWhenReady());
+            }
+            else
+            {
+                ShowStartingInstructionModal();
+            }
         }
 
         #endregion

package/Runtime/Internal/Managers/ReplayManager.cs

@@ -39,6 +39,12 @@ namespace Hyper.Internal.Managers
             ReplaySessionState.SetProgress(_playback.Progress01);
         }
 
+        internal void PrepareForRestart()
+        {
+            _endingGame = false;
+            _playback?.Stop();
+        }
+
         internal void Cleanup()
         {
             if (_eventManager != null)

package/Runtime/Internal/Managers/TimeManager.cs

@@ -43,7 +43,7 @@ namespace Hyper.Internal.Managers
         private bool _isSessionRunning;
         private bool _sessionWarningTriggered;
         private bool _timeUpTriggered;
-        private bool _replayTimeUpPending;
+        private bool _timeUpPending;
 
         private float _lastUnscaledTime;
         private bool _hasGameEnded;
@@ -65,7 +65,7 @@ namespace Hyper.Internal.Managers
             _hasBackendSessionDuration = false;
             _lastUnscaledTime = Time.unscaledTime;
             _timeUpTriggered = false;
-            _replayTimeUpPending = false;
+            _timeUpPending = false;
         }
 
         #endregion
@@ -91,27 +91,21 @@ namespace Hyper.Internal.Managers
             float unscaledDelta = Time.unscaledTime - _lastUnscaledTime;
             _lastUnscaledTime = Time.unscaledTime;
 
-            if (!_gameManager.IsReplayMode)
-            {
-                float gameTimerDelta = Mathf.Approximately(Time.timeScale, 0f)
-                    ? 0f
-                    : unscaledDelta;
-
-                UpdatePracticeTimer(gameTimerDelta);
-                UpdateBattleTimer(gameTimerDelta);
-            }
-
             UpdateSessionTimer(unscaledDelta);
-            DispatchPendingReplayTimeUp();
+            DispatchPendingTimeUp();
         }
 
         internal void FixedTick()
         {
-            if (!_gameManager.IsReplayMode || Mathf.Approximately(Time.timeScale, 0f))
+            if (Mathf.Approximately(Time.timeScale, 0f))
                 return;
 
-            UpdatePracticeTimer(Time.fixedDeltaTime);
-            UpdateBattleTimer(Time.fixedDeltaTime, true);
+            float gameTimerDelta = _gameManager != null && _gameManager.IsReplayMode
+                ? Time.fixedDeltaTime
+                : Time.fixedUnscaledDeltaTime;
+
+            UpdatePracticeTimer(gameTimerDelta);
+            UpdateBattleTimer(gameTimerDelta);
         }
 
         public void Reset()
@@ -120,6 +114,19 @@ namespace Hyper.Internal.Managers
             _lastUnscaledTime = Time.unscaledTime;
         }
 
+        internal void ResetForGameRestart()
+        {
+            _practiceTimer = 0f;
+            _battleTimer = _gameManager != null ? _gameManager.Config.TimeLimit : 0f;
+            _isPracticeRunning = false;
+            _isBattleRunning = false;
+            _timeUpTriggered = false;
+            _timeUpPending = false;
+            _hasGameEnded = false;
+            _hasGameStarted = false;
+            _lastUnscaledTime = Time.unscaledTime;
+        }
+
         public void ResumeGameTimersAfterPause()
         {
             if (_gameManager.IsBattleMode)
@@ -150,7 +157,7 @@ namespace Hyper.Internal.Managers
         public void StopAllTimers()
         {
             _hasGameEnded = true;
-            _replayTimeUpPending = false;
+            _timeUpPending = false;
             StopBattle();
             StopPractice();
         }
@@ -262,7 +269,7 @@ namespace Hyper.Internal.Managers
             }
         }
 
-        private void UpdateBattleTimer(float delta, bool deferTimeUp = false)
+        private void UpdateBattleTimer(float delta)
         {
             if (_isBattleRunning)
             {
@@ -280,7 +287,7 @@ namespace Hyper.Internal.Managers
                     _battleTimer = 0;
                     if (!_timeUpTriggered)
                     {
-                        TriggerTimeUp(deferTimeUp);
+                        QueueTimeUp();
                     }
                 }
             }
@@ -292,30 +299,23 @@ namespace Hyper.Internal.Managers
 
                     if (_battleTimer <= 0 && !_timeUpTriggered)
                     {
-                        TriggerTimeUp(deferTimeUp);
+                        QueueTimeUp();
                     }
                 }
             }
         }
 
-        private void TriggerTimeUp(bool defer)
+        private void QueueTimeUp()
         {
-            if (defer)
-            {
-                _replayTimeUpPending = true;
-                return;
-            }
-
-            _timeUpTriggered = true;
-            _eventManager?.InvokeTimeUpEvent();
+            _timeUpPending = true;
         }
 
-        private void DispatchPendingReplayTimeUp()
+        private void DispatchPendingTimeUp()
         {
-            if (!_replayTimeUpPending)
+            if (!_timeUpPending)
                 return;
 
-            _replayTimeUpPending = false;
+            _timeUpPending = false;
             if (_hasGameEnded || _timeUpTriggered)
                 return;
 

package/Runtime/Internal/UI/Components/ReplayController.cs

@@ -132,6 +132,32 @@ namespace Hyper.Internal
             if (progressSlider != null) progressSlider.SetValueWithoutNotify(1f);
         }
 
+        internal void ResetForReplayRestart()
+        {
+            float playbackSpeed = ReplaySessionState.UserPlaybackSpeed;
+            if (!ReplaySessionState.IsSeeking && playbackSpeeds != null && playbackSpeeds.Length > 0)
+            {
+                playbackSpeed = SanitizePlaybackSpeed(playbackSpeeds[0]);
+                ReplaySessionState.SetPlaybackSpeed(playbackSpeed);
+                Time.timeScale = playbackSpeed;
+            }
+
+            isCapturingSeek = false;
+            pendingSeekTarget = ReplaySessionState.IsSeeking
+                ? ReplaySessionState.SeekTarget01
+                : 0f;
+            wasSeeking = ReplaySessionState.IsSeeking;
+
+            if (progressSlider != null)
+            {
+                progressSlider.SetValueWithoutNotify(pendingSeekTarget);
+            }
+
+            UpdatePlaybackSpeedLabel(playbackSpeed);
+            AlignPlaybackSpeedIndex(playbackSpeed);
+            SetSeekingPresentation(ReplaySessionState.IsSeeking);
+        }
+
         private void ExitReplay()
         {
             if (exitButton != null) exitButton.interactable = false;

package/Runtime/Internal/UI/Modals/ReplayOverModal.cs

@@ -23,6 +23,13 @@ namespace Hyper.Internal
             if (exitButton != null) exitButton.onClick.AddListener(Exit);
         }
 
+        private void OnEnable()
+        {
+            _handled = false;
+            if (watchAgainButton != null) watchAgainButton.interactable = true;
+            if (exitButton != null) exitButton.interactable = true;
+        }
+
         private void OnDestroy()
         {
             if (watchAgainButton != null) watchAgainButton.onClick.RemoveListener(WatchAgain);

package/Runtime/Internal/UI/Modals/StartingInstructionModal.cs

@@ -14,7 +14,7 @@ namespace Hyper.Internal
         [SerializeField] private BlinkingText blinkingText;
         [SerializeField] private RectTransform swipeGif;
         [SerializeField] private RectTransform handSpriteInGif;
-        [SerializeField] private float replayAutoStartDelay = 2f;
+        [SerializeField] private float replayAutoStartDelay = 1f;
         private GameManager _gameManager;
         private StartCTA _currentCTA;
         private SwipeDirection _swipeDirection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "app.hypergames.hypersdk",
-  "version": "1.11.0-beta.1",
+  "version": "1.11.0-beta.2",
   "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",