app.hypergames.hypersdk 1.11.0-beta.16 → 1.11.0-beta.18

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.11.0-beta.18](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.17...v1.11.0-beta.18) (2026-09-01)
+
+
+### Features
+
+* **replay:** support custom replay restarts ([bf722ab](https://github.com/mvmhyper/hyper-sdk/commit/bf722abe48add18c356922c60231cb2017e28443))
+
+# [1.11.0-beta.17](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.16...v1.11.0-beta.17) (2026-09-01)
+
+
+### Features
+
+* **replay:** refine seek loading progress ([3d01f94](https://github.com/mvmhyper/hyper-sdk/commit/3d01f94d7e6ce360a61dd3d257149cf7f3237bcb))
+
 # [1.11.0-beta.16](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.15...v1.11.0-beta.16) (2026-08-31)
 
 

package/Runtime/Internal/Core/HyperRuntime.cs

@@ -15,6 +15,8 @@ namespace Hyper.Internal
     /// </summary>
     internal static class HyperRuntime
     {
+        private const float ReplayCustomRestartTimeoutSeconds = 10f;
+
         private static HyperRuntimeHost _host;
         private static GameObject _singletonObject;
 
@@ -22,6 +24,7 @@ namespace Hyper.Internal
         private static bool _isSoftRestarting;
         private static bool _replayRandomResetPending;
         private static bool _replayCustomRestartPending;
+        private static int _replayCustomRestartVersion;
         private static bool _customLoadingComplete;
         private static bool _customLoadingActive;
         private static float _customLoadingProgress;
@@ -123,7 +126,8 @@ namespace Hyper.Internal
         }
 
         /// <summary>
-        /// Restarts replay playback through HyperLoader while preserving replay session data.
+        /// Restarts replay playback while preserving replay session data. Uses the configured
+        /// game-owned custom restart flow when available and falls back to HyperLoader.
         /// </summary>
         internal static void RestartReplaySession()
         {
@@ -147,8 +151,64 @@ namespace Hyper.Internal
 
             _replayCustomRestartPending = false;
             _replayRandomResetPending = false;
+            int restartVersion = ++_replayCustomRestartVersion;
             _replayManager?.PrepareForRestart();
 
+            if (_settings != null && _settings.useCustomRestartFlow &&
+                _host != null && _gameManager != null && _eventManager != null)
+            {
+                _replayCustomRestartPending = true;
+                _replayRandomResetPending = true;
+                _gameManager.ResetUIStateForCustomRestart();
+
+                try
+                {
+                    if (!_eventManager.InvokeCustomRestartEvent())
+                    {
+                        HyperDebug.LogWarning(
+                            "[Replay] Custom restart has no handler; falling back to HyperLoader.");
+                        BeginReplaySceneRestart(restartVersion);
+                        return;
+                    }
+
+                    _host.StartCoroutine(WaitForReplayCustomRestart(restartVersion));
+                    return;
+                }
+                catch (Exception exception)
+                {
+                    HyperDebug.LogWarning(
+                        $"[Replay] Custom restart failed; falling back to HyperLoader: {exception.Message}");
+                    BeginReplaySceneRestart(restartVersion);
+                    return;
+                }
+            }
+
+            BeginReplaySceneRestart(restartVersion);
+        }
+
+        private static IEnumerator WaitForReplayCustomRestart(int restartVersion)
+        {
+            float timeoutAt = Time.realtimeSinceStartup + ReplayCustomRestartTimeoutSeconds;
+            while (_replayCustomRestartPending && restartVersion == _replayCustomRestartVersion &&
+                   Time.realtimeSinceStartup < timeoutAt)
+            {
+                yield return null;
+            }
+
+            if (!_replayCustomRestartPending || restartVersion != _replayCustomRestartVersion) yield break;
+
+            HyperDebug.LogWarning(
+                $"[Replay] Custom restart did not complete within {ReplayCustomRestartTimeoutSeconds:0} seconds; " +
+                "falling back to HyperLoader.");
+            BeginReplaySceneRestart(restartVersion);
+        }
+
+        private static void BeginReplaySceneRestart(int restartVersion)
+        {
+            if (restartVersion != _replayCustomRestartVersion) return;
+
+            _replayCustomRestartPending = false;
+            _replayRandomResetPending = false;
             if (_host != null)
             {
                 _host.StartCoroutine(RestartSessionCoroutine());
@@ -443,6 +503,7 @@ namespace Hyper.Internal
             _customLoadingProgress = 0f;
             _replayRandomResetPending = false;
             _replayCustomRestartPending = false;
+            _replayCustomRestartVersion++;
             _fixedSimulationTimeSeconds = 0d;
 
             if (_singletonObject != null)
@@ -504,6 +565,7 @@ namespace Hyper.Internal
             _customLoadingProgress = 0f;
             _replayRandomResetPending = false;
             _replayCustomRestartPending = false;
+            _replayCustomRestartVersion++;
             _fixedSimulationTimeSeconds = 0d;
         }
     }

package/Runtime/Internal/Managers/EventManager.cs

@@ -79,7 +79,13 @@ namespace Hyper.Internal.Managers
         internal void InvokeGameEndedEvent() => OnGameEnded?.Invoke();
         internal void InvokeLivesExhaustedEvent() => OnLivesExhausted?.Invoke();
         internal void InvokeHealthExhaustedEvent() => OnHealthExhausted?.Invoke();
-        internal void InvokeCustomRestartEvent() => OnCustomRestart?.Invoke();
+        internal bool InvokeCustomRestartEvent()
+        {
+            Action handler = OnCustomRestart;
+            if (handler == null) return false;
+            handler.Invoke();
+            return true;
+        }
         internal void InvokeConnectionLostEvent() => OnInternetConnectionLost?.Invoke();
         internal void InvokeConnectionFoundEvent() => OnInternetConnectionFound?.Invoke();
         internal void InvokeBackendSocketManuallyClosedEvent() => OnBackendSocketManuallyClosed?.Invoke();

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

@@ -22,7 +22,8 @@ namespace Hyper.Internal
         [SerializeField, Min(1f)] private float seekPlaybackSpeed = 10f;
         [SerializeField, Range(0.25f, 1f)] private float seekSnapshotScale = 0.55f;
         [SerializeField, Range(0f, 0.5f)] private float seekPreparationProgress = 0.2f;
-        [SerializeField, Min(0.1f)] private float seekPreparationDuration = 1f;
+        [SerializeField, Range(0f, 0.15f)] private float seekPreparationProgressVariation = 0.05f;
+        [SerializeField, Min(0.1f)] private float seekPreparationDuration = 3f;
         [SerializeField] private GameObject seekLoadingOverlay;
         [SerializeField] private RawImage seekSnapshotImage;
 
@@ -35,7 +36,11 @@ namespace Hyper.Internal
         private Image seekOverlayBackground;
         private Color seekOverlayBackgroundColor;
         private ReplaySeekOverlay seekOverlay;
+        private static readonly System.Random SeekProgressRandom = new System.Random();
         private static float displayedSeekProgress;
+        private static float firstSeekPreparationTarget;
+        private static float secondSeekPreparationTarget;
+        private static float seekPreparationCeiling;
 
         private void Awake()
         {
@@ -198,7 +203,7 @@ namespace Hyper.Internal
 
             float resumeSpeed = SanitizePlaybackSpeed(ReplaySessionState.UserPlaybackSpeed);
             float fastForwardSpeed = SanitizePlaybackSpeed(seekPlaybackSpeed);
-            displayedSeekProgress = 0f;
+            InitializeSeekProgressPresentation();
             StartCoroutine(CaptureAndSeek(targetProgress, resumeSpeed, fastForwardSpeed));
         }
 
@@ -431,30 +436,98 @@ namespace Hyper.Internal
             }
             else if (isCapturingSeek || ReplaySessionState.IsSeekRestartPending)
             {
-                float duration = Mathf.Max(0.1f, seekPreparationDuration);
-                displayedSeekProgress = Mathf.MoveTowards(
-                    displayedSeekProgress,
-                    seekPreparationProgress,
-                    seekPreparationProgress * Time.unscaledDeltaTime / duration);
+                AdvanceSeekPreparationProgress();
                 progress = displayedSeekProgress;
             }
             else
             {
+                EnsureSeekProgressPresentation();
                 float target = ReplaySessionState.SeekTarget01;
                 float reconstructionProgress = target <= Mathf.Epsilon
                     ? 1f
                     : ReplaySessionState.Progress01 / target;
                 float realProgress = Mathf.Lerp(
-                    seekPreparationProgress,
+                    seekPreparationCeiling,
                     1f,
                     Mathf.Clamp01(reconstructionProgress));
-                displayedSeekProgress = Mathf.Max(displayedSeekProgress, realProgress);
+                AdvanceSeekReconstructionProgress(realProgress);
                 progress = displayedSeekProgress;
             }
 
             seekOverlay.SetProgress(progress);
         }
 
+        private void AdvanceSeekPreparationProgress()
+        {
+            EnsureSeekProgressPresentation();
+            float duration = Mathf.Max(0.1f, seekPreparationDuration);
+            float deltaTime = Mathf.Min(Time.unscaledDeltaTime, 0.1f);
+
+            if (displayedSeekProgress < firstSeekPreparationTarget)
+            {
+                float speed = firstSeekPreparationTarget / (duration * 0.35f);
+                displayedSeekProgress = Mathf.MoveTowards(
+                    displayedSeekProgress,
+                    firstSeekPreparationTarget,
+                    speed * deltaTime);
+                return;
+            }
+
+            if (displayedSeekProgress < secondSeekPreparationTarget)
+            {
+                float speed = (secondSeekPreparationTarget - firstSeekPreparationTarget) / (duration * 0.2f);
+                displayedSeekProgress = Mathf.MoveTowards(
+                    displayedSeekProgress,
+                    secondSeekPreparationTarget,
+                    speed * deltaTime);
+                return;
+            }
+
+            float crawlResponse = 1f - Mathf.Exp(-deltaTime / (duration * 0.65f));
+            displayedSeekProgress = Mathf.Lerp(displayedSeekProgress, seekPreparationCeiling, crawlResponse);
+        }
+
+        private void InitializeSeekProgressPresentation()
+        {
+            float center = Mathf.Clamp01(seekPreparationProgress);
+            float variation = Mathf.Max(0f, seekPreparationProgressVariation);
+            float minimum = Mathf.Clamp01(center - variation);
+            float maximum = Mathf.Clamp01(center + variation);
+
+            displayedSeekProgress = 0f;
+            seekPreparationCeiling = RandomRange(minimum, maximum);
+            firstSeekPreparationTarget = seekPreparationCeiling * RandomRange(0.25f, 0.35f);
+            secondSeekPreparationTarget = seekPreparationCeiling * RandomRange(0.62f, 0.76f);
+        }
+
+        private void EnsureSeekProgressPresentation()
+        {
+            if (seekPreparationCeiling > 0f) return;
+            InitializeSeekProgressPresentation();
+        }
+
+        private static float RandomRange(float minimum, float maximum)
+        {
+            if (maximum <= minimum) return minimum;
+            return minimum + ((float)SeekProgressRandom.NextDouble() * (maximum - minimum));
+        }
+
+        private void AdvanceSeekReconstructionProgress(float realProgress)
+        {
+            float target = Mathf.Max(displayedSeekProgress, realProgress);
+            if (target >= 0.999f)
+            {
+                displayedSeekProgress = 1f;
+                return;
+            }
+
+            float deltaTime = Mathf.Min(Time.unscaledDeltaTime, 0.1f);
+            float gap = target - displayedSeekProgress;
+            float responseSpeed = Mathf.Lerp(5f, 14f, Mathf.Clamp01(gap * 4f));
+            float response = 1f - Mathf.Exp(-responseSpeed * deltaTime);
+            displayedSeekProgress = Mathf.Lerp(displayedSeekProgress, target, response);
+        }
+
         private void ConfigureSeekSnapshot()
         {
             if (seekSnapshotImage == null)

package/Runtime/Resources/UIPrefabs/ReplayController.prefab

@@ -320,7 +320,8 @@ MonoBehaviour:
   seekPlaybackSpeed: 10
   seekSnapshotScale: 0.725
   seekPreparationProgress: 0.2
-  seekPreparationDuration: 1
+  seekPreparationProgressVariation: 0.05
+  seekPreparationDuration: 3
   seekLoadingOverlay: {fileID: 0}
   seekSnapshotImage: {fileID: 0}
 --- !u!1 &1862654115017658012

package/Runtime/Resources/UIPrefabs/ReplaySeekOverlay.prefab

@@ -288,7 +288,7 @@ MonoBehaviour:
   m_Name:
   m_EditorClassIdentifier:
   m_Material: {fileID: 0}
-  m_Color: {r: 1, g: 1, b: 1, a: 0.10980392}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.1764706}
   m_RaycastTarget: 1
   m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
   m_Maskable: 1

package/package.json

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