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

package/CHANGELOG.md

@@ -1,3 +1,75 @@
+# [1.11.0-beta.10](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.9...v1.11.0-beta.10) (2026-08-30)
+
+
+### Bug Fixes
+
+* **replay:** reduce default seek speed ([f70551a](https://github.com/mvmhyper/hyper-sdk/commit/f70551aea942274ace1cb952ddae4e9edb0c1c12))
+
+# [1.11.0-beta.9](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.8...v1.11.0-beta.9) (2026-08-30)
+
+
+### Bug Fixes
+
+* **replay:** show loader while exiting paused replay ([4a2e7a6](https://github.com/mvmhyper/hyper-sdk/commit/4a2e7a6045017ea8ed3ae3525271440dbf013e6c))
+
+# [1.11.0-beta.8](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.7...v1.11.0-beta.8) (2026-08-30)
+
+
+### Bug Fixes
+
+* **replay:** mute audio while seeking ([5ab8cd1](https://github.com/mvmhyper/hyper-sdk/commit/5ab8cd1411493cb5add07b51dc190c85251f99d2))
+
+# [1.11.0-beta.7](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.6...v1.11.0-beta.7) (2026-08-30)
+
+
+### Bug Fixes
+
+* **replay:** stabilize scene reload seeking ([dd9ac63](https://github.com/mvmhyper/hyper-sdk/commit/dd9ac632d08349d9578f64ae0b2dc2ab905a26af))
+
+# [1.11.0-beta.6](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.5...v1.11.0-beta.6) (2026-08-29)
+
+
+### Bug Fixes
+
+* **timer:** restore gameplay timers after pause ([ca82d57](https://github.com/mvmhyper/hyper-sdk/commit/ca82d57df87618807cbae611c0a9d6acc14f8470))
+
+# [1.11.0-beta.5](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.4...v1.11.0-beta.5) (2026-08-28)
+
+
+### Bug Fixes
+
+* **replay:** wait for custom restart readiness ([43f1aeb](https://github.com/mvmhyper/hyper-sdk/commit/43f1aeb6a127c8c12dbb8379e7230d64ef5e0763))
+
+
+### Features
+
+* **replay:** add replay pause controls ([b9fb470](https://github.com/mvmhyper/hyper-sdk/commit/b9fb470e65c69e66a8a9611b0caa7e5417b1e4bf))
+* **replay:** update replay control bar assets ([79ce8c0](https://github.com/mvmhyper/hyper-sdk/commit/79ce8c0f1b68129ae5b8bcf18a302117cf11c885))
+
+# [1.11.0-beta.4](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.3...v1.11.0-beta.4) (2026-08-28)
+
+
+### Bug Fixes
+
+* **replay:** align recording with fixed simulation ([ae2b322](https://github.com/mvmhyper/hyper-sdk/commit/ae2b32216a0a9ea125572d788eee3bfd846414b0))
+
+# [1.11.0-beta.3](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.2...v1.11.0-beta.3) (2026-08-28)
+
+
+### Bug Fixes
+
+* **replay:** reset random state before playback restart ([526a4d9](https://github.com/mvmhyper/hyper-sdk/commit/526a4d98c9b22241e3c52bb6837145bad999fb2b))
+* **sample:** support lane runner custom restart ([49da385](https://github.com/mvmhyper/hyper-sdk/commit/49da385aaa917de438672a8630d4fe7927741b2a))
+
+# [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

@@ -20,6 +20,8 @@ namespace Hyper.Internal
 
         private static bool _isInitialized;
         private static bool _isSoftRestarting;
+        private static bool _replayRandomResetPending;
+        private static bool _replayCustomRestartPending;
         private static bool _customLoadingComplete;
         private static bool _customLoadingActive;
         private static float _customLoadingProgress;
@@ -32,6 +34,7 @@ namespace Hyper.Internal
         private static EventManager _eventManager;
         private static TimerManager _timerManager;
         private static ReplayManager _replayManager;
+        private static double _fixedSimulationTimeSeconds;
 
         internal static bool IsInitialized => _isInitialized;
         internal static bool IsSoftRestarting
@@ -39,6 +42,7 @@ namespace Hyper.Internal
             get => _isSoftRestarting;
             set => _isSoftRestarting = value;
         }
+        internal static bool IsReplayCustomRestartPending => _replayCustomRestartPending;
         internal static bool CustomLoadingComplete
         {
             get => _customLoadingComplete;
@@ -58,6 +62,7 @@ namespace Hyper.Internal
         internal static EventManager EventManager => _eventManager;
         internal static TimerManager Timer => _timerManager;
         internal static ReplayManager ReplayManager => _replayManager;
+        internal static double FixedSimulationTimeSeconds => _fixedSimulationTimeSeconds;
 
         internal static event Action CustomLoadingStarted
         {
@@ -118,13 +123,12 @@ 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 through HyperLoader while preserving replay session data.
         /// </summary>
         internal static void RestartReplaySession()
         {
             ReplaySessionState.ResetForWatchAgain();
-            RestartReplayFromLoader();
+            RestartReplay();
         }
 
         internal static void SeekReplaySession(float targetProgress, float resumeSpeed, float seekSpeed)
@@ -133,14 +137,18 @@ 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;
 
+            _replayCustomRestartPending = false;
+            _replayRandomResetPending = false;
+            _replayManager?.PrepareForRestart();
+
             if (_host != null)
             {
                 _host.StartCoroutine(RestartSessionCoroutine());
@@ -152,6 +160,47 @@ 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);
+        }
+
+        internal static void ApplyPendingReplayRandomReset()
+        {
+            if (!_replayRandomResetPending) return;
+
+            _replayRandomResetPending = false;
+            ResetReplayRandomState();
+        }
+
+        internal static void DeferReplayRandomReset()
+        {
+            _replayRandomResetPending = true;
+        }
+
+        internal static void CompleteCustomRestart()
+        {
+            if (!_replayCustomRestartPending || _host == null) return;
+
+            _replayCustomRestartPending = false;
+            _host.StartCoroutine(CompleteReplayCustomRestartNextFrame());
+        }
+
+        private static IEnumerator CompleteReplayCustomRestartNextFrame()
+        {
+            yield return null;
+            _gameManager?.CompleteReplayCustomRestart();
+            _isSoftRestarting = false;
+        }
+
         /// <summary>
         /// Coroutine-based restart that properly unloads all scenes before reloading.
         /// Handles async scene operations and ensures clean state before restart.
@@ -160,6 +209,7 @@ namespace Hyper.Internal
         {
             yield return UnloadAllScenesCoroutine();
 
+            Clear();
             ClearAllDontDestroyOnLoadObjects();
             SceneManager.LoadScene("HyperLoader");
         }
@@ -357,6 +407,7 @@ namespace Hyper.Internal
         internal static void FixedTick()
         {
             if (!_isInitialized) return;
+            _fixedSimulationTimeSeconds += Time.fixedDeltaTime;
             _replayManager?.FixedTick();
             _timerManager?.FixedTick();
         }
@@ -390,6 +441,9 @@ namespace Hyper.Internal
             _customLoadingComplete = false;
             _customLoadingActive = false;
             _customLoadingProgress = 0f;
+            _replayRandomResetPending = false;
+            _replayCustomRestartPending = false;
+            _fixedSimulationTimeSeconds = 0d;
 
             if (_singletonObject != null)
             {
@@ -448,6 +502,9 @@ namespace Hyper.Internal
             _customLoadingComplete = false;
             _customLoadingActive = false;
             _customLoadingProgress = 0f;
+            _replayRandomResetPending = false;
+            _replayCustomRestartPending = false;
+            _fixedSimulationTimeSeconds = 0d;
         }
     }
 }

package/Runtime/Internal/Managers/DataManager.cs

@@ -219,6 +219,7 @@ namespace Hyper.Internal.Managers
         internal void ConfigurePlayerSoundSetting()
         {
             SetSound(GetSound());
+            ReplaySessionState.EnsureAudioMutedDuringSeek();
             if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
         }
 
@@ -462,7 +463,7 @@ namespace Hyper.Internal.Managers
 
         private static double GetSimulationTimeSeconds()
         {
-            return Time.fixedTimeAsDouble;
+            return HyperRuntime.FixedSimulationTimeSeconds;
         }
 
         private ScoreData GetPooledScoreData()

package/Runtime/Internal/Managers/GameManager.cs

@@ -191,6 +191,41 @@ namespace Hyper.Internal.Managers
             Resources.UnloadUnusedAssets();
         }
 
+        internal void PauseReplay()
+        {
+            if (!IsReplayMode || !_hasGameStarted || _isPaused || _hasGameEnded)
+            {
+                return;
+            }
+
+            _isPaused = true;
+            _savedReplayTimeScale = Time.timeScale > 0f
+                ? Time.timeScale
+                : ReplaySessionState.PlaybackSpeed;
+            Time.timeScale = 0f;
+            HyperRuntime.Timer.PauseGameplayTimers();
+
+            _previousTimeScale = 0f;
+            _eventManager.InvokeTimeScaleFrozenEvent();
+            ReplayPresentationCanvas.SetSeekingLayer(false);
+            SetBlockerActive(true);
+            ShowReplayPauseModal();
+        }
+
+        internal void ResumeReplay()
+        {
+            if (!IsReplayMode || !_isPaused || _hasGameEnded) return;
+
+            _isPaused = false;
+            HidePauseModals();
+            Time.timeScale = _savedReplayTimeScale > 0f ? _savedReplayTimeScale : 1f;
+            HyperRuntime.Timer.ResumeGameTimersAfterPause();
+
+            _previousTimeScale = Time.timeScale;
+            _eventManager.InvokeTimeScaleResumedEvent();
+            ReplayPresentationCanvas.SetSeekingLayer(ReplaySessionState.IsSeeking);
+        }
+
         internal void ResumeGame()
         {
             _isPaused = false;
@@ -222,51 +257,7 @@ namespace Hyper.Internal.Managers
         private void HandleReplayFocus(bool hasFocus)
         {
             if (!_hasGameStarted || _hasGameEnded) return;
-
-            if (!hasFocus && _replayFocusResumeCoroutine != null)
-            {
-                StopCoroutine(_replayFocusResumeCoroutine);
-                _replayFocusResumeCoroutine = null;
-            }
-
-            if (!hasFocus && !_replayFocusSuspended)
-            {
-                _replayFocusSuspended = true;
-                _savedReplayTimeScale = Time.timeScale;
-                Time.timeScale = 0f;
-                HyperRuntime.Timer.PauseGameplayTimers();
-
-                // WebGL may stop producing frames immediately after focus loss,
-                // so suspend replay timing here instead of waiting for Update.
-                _previousTimeScale = 0f;
-                _eventManager.InvokeTimeScaleFrozenEvent();
-                HyperDebug.Log("Time scale frozen event invoked");
-            }
-            else if (hasFocus && _replayFocusSuspended)
-            {
-                if (_replayFocusResumeCoroutine == null)
-                {
-                    _replayFocusResumeCoroutine = StartCoroutine(ResumeReplayAfterFocus());
-                }
-            }
-        }
-
-        private IEnumerator ResumeReplayAfterFocus()
-        {
-            // WebGL reports focus before Unity refreshes its unscaled clock. Keep
-            // gameplay and replay frozen briefly while session time continues.
-            yield return new WaitForSecondsRealtime(1f);
-
-            _replayFocusResumeCoroutine = null;
-            if (!_replayFocusSuspended || _hasGameEnded) yield break;
-
-            _replayFocusSuspended = false;
-            Time.timeScale = _savedReplayTimeScale > 0f ? _savedReplayTimeScale : 1f;
-            HyperRuntime.Timer.ResumeGameTimersAfterPause();
-
-            _previousTimeScale = Time.timeScale;
-            _eventManager.InvokeTimeScaleResumedEvent();
-            HyperDebug.Log("Time scale resumed event invoked");
+            if (!hasFocus) PauseReplay();
         }
 
         void HandlePauseState(bool shouldPause)
@@ -552,7 +543,7 @@ namespace Hyper.Internal.Managers
 
         internal void ShowStartGameDeadline(int timeLeft)
         {
-            if (_hasGameStarted || !IsInGameScene) return;
+            if (_hasGameStarted || !IsInGameScene || IsReplayMode) return;
 
             EnsureStartGameDeadlineBar();
             _eventManager.OnSessionAboutToExpire += ChangeDeadlineColorToRed;
@@ -728,7 +719,6 @@ namespace Hyper.Internal.Managers
         private bool _isPortrait;
         private float _previousTimeScale = 1f;
         private float _savedTimeScaleBeforePause = 1f;
-        private bool _replayFocusSuspended;
         private float _savedReplayTimeScale = 1f;
 
         #endregion
@@ -1025,6 +1015,8 @@ namespace Hyper.Internal.Managers
             if (_gameStartRequested || _hasGameStarted || _hasGameEnded || !IsInGameScene) return;
             _gameStartRequested = true;
 
+            HyperRuntime.ApplyPendingReplayRandomReset();
+
             HideStartGameDeadlineSnackBar();
             _dataManager.UpdateScore(0);
             HyperRuntime.Timer.StartActiveGameTimer();
@@ -1062,26 +1054,58 @@ namespace Hyper.Internal.Managers
 
         /// <summary>
         /// Resets SDK UI state for custom restart flow.
-        /// Called after OnCustomRestart event is fired to prepare the SDK for the developer's restart logic.
+        /// Called before OnCustomRestart so the developer's cleanup starts from reset SDK state.
         /// </summary>
         internal void ResetUIStateForCustomRestart()
         {
             HideGameOverModal();
             HidePauseModals();
+            if (_replayOverModal != null) _replayOverModal.SetActive(false);
 
             // Reset game state flags
             _hasGameStarted = false;
             _gameStartRequested = false;
             _hasGameEnded = false;
+            _replayEndHandled = false;
             _isPaused = false;
             _isFrozenBeforePause = false;
 
-            HyperRuntime.Timer.Reset();
+            HyperRuntime.Timer.ResetForGameRestart();
             HyperRuntime.DataManager.UpdateScore(0);
             HyperRuntime.DataManager.RestoreAudioAfterGameSessionEnd();
 
             ShowControlBarElements();
-            ShowStartingInstructionModal();
+            _replayControllerComponent?.ResetForReplayRestart();
+
+            if (IsReplayMode && HyperRuntime.IsReplayCustomRestartPending)
+            {
+                HideStartingInstructionModal();
+                return;
+            }
+
+            if (IsReplayMode && ReplaySessionState.IsSeeking)
+            {
+                HideStartingInstructionModal();
+                StartCoroutine(StartSeekingReplayWhenReady());
+            }
+            else
+            {
+                ShowStartingInstructionModal();
+            }
+        }
+
+        internal void CompleteReplayCustomRestart()
+        {
+            if (!IsReplayMode || _gameStartRequested || _hasGameStarted || _hasGameEnded) return;
+
+            if (ReplaySessionState.IsSeeking)
+            {
+                StartCoroutine(StartSeekingReplayWhenReady());
+            }
+            else
+            {
+                ShowStartingInstructionModal();
+            }
         }
 
         #endregion
@@ -1125,7 +1149,6 @@ namespace Hyper.Internal.Managers
 
             _replayEndHandled = true;
             _hasGameEnded = true;
-            _replayFocusSuspended = false;
             Time.timeScale = 1f;
             _eventManager.InvokeGameEndedEvent();
             HyperRuntime.Timer.StopAllTimers();
@@ -1147,10 +1170,12 @@ namespace Hyper.Internal.Managers
                 _eventManager.InvokeGameEndedEvent();
             }
 
+            _isPaused = false;
             Time.timeScale = 1f;
             HyperRuntime.Timer.StopAllTimers();
             _dataManager.StopCapturingScores();
             HyperRuntime.BackendManager.StopSendingScores();
+            HidePauseModals();
             _replayControllerComponent?.SetReplayEnded();
             ReplaySessionState.Clear();
             ReplayPresentationCanvas.DestroyCurrent();
@@ -1261,8 +1286,8 @@ namespace Hyper.Internal.Managers
         private GameObject _replayControllerObject;
         private ReplayController _replayControllerComponent;
         private GameObject _replayOverModal;
+        private GameObject _replayPausedModal;
         private Coroutine _replayConnectionCheckCoroutine;
-        private Coroutine _replayFocusResumeCoroutine;
 
         private GameObject _connectionStatusBar;
         private GameObject _startGameDeadlineStatusBar;
@@ -1492,6 +1517,30 @@ namespace Hyper.Internal.Managers
             _replayOverModal.transform.SetAsLastSibling();
         }
 
+        private void ShowReplayPauseModal()
+        {
+            if (_replayPausedModal == null)
+            {
+                if (_canvas == null) CreateCanvas();
+                GameObject prefab = Resources.Load<GameObject>("UIPrefabs/ReplayPausedModal");
+                if (prefab == null)
+                {
+                    HyperDebug.LogWarning("[GameManager] ReplayPausedModal prefab not found.");
+                    ResumeReplay();
+                    return;
+                }
+
+                _replayPausedModal = InstantiateModal(prefab);
+                if (_replayPausedModal.GetComponent<ReplayPausedModal>() == null)
+                {
+                    _replayPausedModal.AddComponent<ReplayPausedModal>();
+                }
+            }
+
+            _replayPausedModal.SetActive(true);
+            _replayPausedModal.transform.SetAsLastSibling();
+        }
+
         private void EnsureConnectionStatusBar()
         {
             if (_connectionStatusBar != null) return;
@@ -1740,6 +1789,7 @@ namespace Hyper.Internal.Managers
         internal void HidePauseModals()
         {
             SetBlockerActive(false);
+            if (_replayPausedModal != null) _replayPausedModal.SetActive(false);
             if (_battleGamePausedModal != null) _battleGamePausedModal.SetActive(false);
             if (_practicePausedModal != null) _practicePausedModal.SetActive(false);
             if (_battleGamePausedLandscapeModal != null) _battleGamePausedLandscapeModal.SetActive(false);

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)
@@ -68,6 +74,7 @@ namespace Hyper.Internal.Managers
             }
 
             _playback.Begin(ReplaySessionState.ReplayNdjson);
+            ReplaySessionState.SetGameplayStartProgress(_playback.GameplayStartProgress01);
         }
 
         private void HandleGameEnded()