app.hypergames.hypersdk 1.11.0-beta.15 → 1.11.0-beta.17

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [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)
+
+
+### Bug Fixes
+
+* **replay:** show seek preparation progress ([60213f7](https://github.com/mvmhyper/hyper-sdk/commit/60213f784c5bff39da4634590545fe4d0e4c0911))
+
 # [1.11.0-beta.15](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.14...v1.11.0-beta.15) (2026-08-31)
 
 

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

@@ -21,6 +21,9 @@ namespace Hyper.Internal
         [SerializeField] private float[] playbackSpeeds = { 1.5f, 2f, 3f, 4f, 5f, 1f };
         [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, 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;
 
@@ -33,6 +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()
         {
@@ -195,6 +203,7 @@ namespace Hyper.Internal
 
             float resumeSpeed = SanitizePlaybackSpeed(ReplaySessionState.UserPlaybackSpeed);
             float fastForwardSpeed = SanitizePlaybackSpeed(seekPlaybackSpeed);
+            InitializeSeekProgressPresentation();
             StartCoroutine(CaptureAndSeek(targetProgress, resumeSpeed, fastForwardSpeed));
         }
 
@@ -420,22 +429,105 @@ namespace Hyper.Internal
         {
             if (seekOverlay == null) return;
 
-            float progress = 0f;
+            float progress;
             if (!isSeeking)
             {
                 progress = 1f;
             }
-            else if (!isCapturingSeek && !ReplaySessionState.IsSeekRestartPending)
+            else if (isCapturingSeek || ReplaySessionState.IsSeekRestartPending)
             {
+                AdvanceSeekPreparationProgress();
+                progress = displayedSeekProgress;
+            }
+            else
+            {
+                EnsureSeekProgressPresentation();
                 float target = ReplaySessionState.SeekTarget01;
-                progress = target <= Mathf.Epsilon
+                float reconstructionProgress = target <= Mathf.Epsilon
                     ? 1f
                     : ReplaySessionState.Progress01 / target;
+                float realProgress = Mathf.Lerp(
+                    seekPreparationCeiling,
+                    1f,
+                    Mathf.Clamp01(reconstructionProgress));
+                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

@@ -319,6 +319,9 @@ MonoBehaviour:
   - 0.5
   seekPlaybackSpeed: 10
   seekSnapshotScale: 0.725
+  seekPreparationProgress: 0.2
+  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.15",
+  "version": "1.11.0-beta.17",
   "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",