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

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [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/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.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",