app.hypergames.hypersdk 1.11.0-beta.6 → 1.11.0-beta.7

package/CHANGELOG.md

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

package/Runtime/Internal/Core/HyperRuntime.cs

@@ -123,8 +123,7 @@ namespace Hyper.Internal
         }
 
         /// <summary>
-        /// Restarts replay playback while preserving its downloaded data and original seed.
-        /// Uses the configured custom restart flow when available, otherwise reloads HyperLoader.
+        /// Restarts replay playback through HyperLoader while preserving replay session data.
         /// </summary>
         internal static void RestartReplaySession()
         {
@@ -146,17 +145,9 @@ namespace Hyper.Internal
             _isSoftRestarting = true;
             Time.timeScale = 1f;
 
-            if (_settings != null && _settings.useCustomRestartFlow &&
-                _gameManager != null && _eventManager != null)
-            {
-                _replayCustomRestartPending = true;
-                _replayManager?.PrepareForRestart();
-                // Custom cleanup may use random streams. Rewind after cleanup, immediately before OnGameStart.
-                DeferReplayRandomReset();
-                _gameManager.ResetUIStateForCustomRestart();
-                _eventManager.InvokeCustomRestartEvent();
-                return;
-            }
+            _replayCustomRestartPending = false;
+            _replayRandomResetPending = false;
+            _replayManager?.PrepareForRestart();
 
             if (_host != null)
             {
@@ -218,6 +209,7 @@ namespace Hyper.Internal
         {
             yield return UnloadAllScenesCoroutine();
 
+            Clear();
             ClearAllDontDestroyOnLoadObjects();
             SceneManager.LoadScene("HyperLoader");
         }
@@ -451,6 +443,7 @@ namespace Hyper.Internal
             _customLoadingProgress = 0f;
             _replayRandomResetPending = false;
             _replayCustomRestartPending = false;
+            _fixedSimulationTimeSeconds = 0d;
 
             if (_singletonObject != null)
             {

package/Runtime/Internal/Managers/ReplayManager.cs

@@ -74,6 +74,7 @@ namespace Hyper.Internal.Managers
             }
 
             _playback.Begin(ReplaySessionState.ReplayNdjson);
+            ReplaySessionState.SetGameplayStartProgress(_playback.GameplayStartProgress01);
         }
 
         private void HandleGameEnded()

package/Runtime/Internal/Replay/ReplaySessionState.cs

@@ -24,6 +24,7 @@ namespace Hyper.Internal
         public static bool IsSeekRestartPending => IsSeeking && !_seekPlaybackReady;
         public static float SeekTarget01 { get; private set; }
         public static bool HasEnded { get; private set; }
+        public static float GameplayStartProgress01 { get; private set; }
 
         internal static string EditorReplayFilePath =>
             Path.Combine(Application.persistentDataPath, "hyper-replay.ndjson");
@@ -54,6 +55,7 @@ namespace Hyper.Internal
             _seekPlaybackReady = false;
             _watchAgainAutoStartPending = false;
             HasEnded = false;
+            GameplayStartProgress01 = 0f;
         }
 
         public static void SetMetadata(string playerName, string avatarUrl, long originalRandomSeed)
@@ -82,9 +84,14 @@ namespace Hyper.Internal
         {
             if (!IsActive) return;
             if (IsSeeking && !_seekPlaybackReady) return;
-            Progress01 = Math.Max(0f, Math.Min(1f, progress));
-
-            if (IsSeeking && Progress01 >= SeekTarget01)
+            float rawProgress = Math.Max(0f, Math.Min(1f, progress));
+            Progress01 = GameplayStartProgress01 >= 1f
+                ? 0f
+                : Math.Max(0f, Math.Min(1f,
+                    (rawProgress - GameplayStartProgress01) / (1f - GameplayStartProgress01)));
+
+            bool hasReachedGameplayStart = rawProgress + 0.000001f >= GameplayStartProgress01;
+            if (IsSeeking && hasReachedGameplayStart && Progress01 >= SeekTarget01)
             {
                 IsSeeking = false;
                 _seekPlaybackReady = false;
@@ -149,6 +156,12 @@ namespace Hyper.Internal
             HasEnded = false;
         }
 
+        public static void SetGameplayStartProgress(float progress)
+        {
+            if (!IsActive) return;
+            GameplayStartProgress01 = Math.Max(0f, Math.Min(1f, progress));
+        }
+
         public static bool ConsumeWatchAgainAutoStart()
         {
             bool pending = _watchAgainAutoStartPending;
@@ -173,6 +186,7 @@ namespace Hyper.Internal
             _seekPlaybackReady = false;
             _watchAgainAutoStartPending = false;
             HasEnded = false;
+            GameplayStartProgress01 = 0f;
             SeekCompleted = null;
         }
 

package/Runtime/Public/Core/HyperSDK.cs

@@ -486,10 +486,15 @@ namespace Hyper
         /// <summary>Fired when all replay activities have been dispatched.</summary>
         event Action OnEnded;
 
+        /// <summary>Fired at the recorded boundary where game-specific playable gameplay began.</summary>
+        event Action OnGameplayReady;
+
         bool IsPlaying { get; }
         double DurationSeconds { get; }
         double ElapsedSeconds { get; }
         float Progress01 { get; }
+        bool IsSeeking { get; }
+        bool HasGameplayReadyMarker { get; }
 
         /// <summary>
         /// Optional visual lead time. Gameplay actions still fire at their recorded time.
@@ -685,11 +690,14 @@ namespace Hyper
         public event Action<float, string> OnValueAction { add => _playback.OnValueAction += value; remove => _playback.OnValueAction -= value; }
         public event Action<string> OnActionPreparing { add => _playback.OnActionPreparing += value; remove => _playback.OnActionPreparing -= value; }
         public event Action OnEnded { add => _playback.OnGameEnded += value; remove => _playback.OnGameEnded -= value; }
+        public event Action OnGameplayReady { add => _playback.OnGameplayReady += value; remove => _playback.OnGameplayReady -= value; }
 
         public bool IsPlaying => _playback.IsPlaying;
         public double DurationSeconds => _playback.DurationSeconds;
         public double ElapsedSeconds => _playback.ElapsedSeconds;
         public float Progress01 => _playback.Progress01;
+        public bool IsSeeking => ReplaySessionState.IsSeeking;
+        public bool HasGameplayReadyMarker => _playback.HasGameplayReadyMarker;
         public double ActionPreparationLeadSeconds
         {
             get => _playback.ActionPreparationLeadSeconds;

package/Runtime/Public/Replay/ReplayPlaybackEngine.cs

@@ -11,6 +11,7 @@ namespace Hyper
     internal sealed class ReplayPlaybackEngine : IReplayPlaybackEngine
     {
         private const string GameStarted = "GS";
+        private const string GameplayReady = "GPR";
         private const string GamePaused = "GP";
         private const string GameResumed = "GR";
         private const string GameEnded = "GE";
@@ -45,6 +46,7 @@ namespace Hyper
         /// </summary>
         public event Action<string> OnActionPreparing;
         public event Action OnGameStarted;
+        public event Action OnGameplayReady;
         public event Action OnGameEnded;
 
         public bool IsPlaying { get; private set; }
@@ -55,6 +57,8 @@ namespace Hyper
         /// The action itself is still dispatched at its recorded timestamp.
         /// </summary>
         public double ActionPreparationLeadSeconds { get; set; }
+        public bool HasGameplayReadyMarker { get; private set; }
+        public float GameplayStartProgress01 { get; private set; }
         public float Progress01 => DurationSeconds <= 0d
             ? (IsPlaying ? 0f : 1f)
             : Mathf.Clamp01((float)(ElapsedSeconds / DurationSeconds));
@@ -73,6 +77,11 @@ namespace Hyper
             _completionPending = false;
             _nextActionPrepared = false;
             DurationSeconds = CalculateDuration(_ndjson);
+            double gameplayStartSeconds = CalculateGameplayStart(_ndjson, out bool hasGameplayReadyMarker);
+            HasGameplayReadyMarker = hasGameplayReadyMarker;
+            GameplayStartProgress01 = hasGameplayReadyMarker && DurationSeconds > 0d
+                ? Mathf.Clamp01((float)(gameplayStartSeconds / DurationSeconds))
+                : 0f;
             _hasNext = TryReadNext(out _next);
 
             if (!_hasNext)
@@ -214,6 +223,9 @@ namespace Hyper
                 case GameStarted:
                     OnGameStarted?.Invoke();
                     break;
+                case GameplayReady:
+                    OnGameplayReady?.Invoke();
+                    break;
                 case GamePaused:
                     SkipRecordedPause(activity.Time);
                     break;
@@ -246,7 +258,50 @@ namespace Hyper
         private static bool IsLifecycleAction(string action)
         {
             return action == GameStarted || action == GamePaused ||
-                   action == GameResumed || action == GameEnded;
+                   action == GameResumed || action == GameEnded || action == GameplayReady;
+        }
+
+        private static double CalculateGameplayStart(string ndjson, out bool found)
+        {
+            found = false;
+            if (string.IsNullOrWhiteSpace(ndjson)) return 0d;
+
+            int cursor = 0;
+            bool hasFirst = false;
+            double firstTime = 0d;
+            double removedPauses = 0d;
+            double? pauseStartedAt = null;
+
+            while (TryReadLine(ndjson, ref cursor, out string line))
+            {
+                if (!TryParse(line, out ReplayActivity activity)) continue;
+                if (!hasFirst)
+                {
+                    hasFirst = true;
+                    firstTime = activity.Time;
+                }
+
+                if (activity.Kind != ReplayActivityKind.Action) continue;
+                if (activity.Action == GamePaused)
+                {
+                    pauseStartedAt ??= activity.Time;
+                    continue;
+                }
+
+                if (activity.Action == GameResumed && pauseStartedAt.HasValue)
+                {
+                    removedPauses += Math.Max(0d, activity.Time - pauseStartedAt.Value);
+                    pauseStartedAt = null;
+                    continue;
+                }
+
+                if (activity.Action != GameplayReady) continue;
+
+                found = true;
+                return Math.Max(0d, activity.Time - firstTime - removedPauses);
+            }
+
+            return 0d;
         }
 
         private void SkipRecordedPause(double pauseStartedAt)

package/Runtime/Shared/Replay/IReplayPlaybackEngine.cs

@@ -19,12 +19,15 @@ namespace Hyper.Shared
         event Action<float, string> OnValueAction;
         event Action<string> OnActionPreparing;
         event Action OnGameStarted;
+        event Action OnGameplayReady;
         event Action OnGameEnded;
 
         bool IsPlaying { get; }
         double DurationSeconds { get; }
         double ElapsedSeconds { get; }
         float Progress01 { get; }
+        bool HasGameplayReadyMarker { get; }
+        float GameplayStartProgress01 { get; }
         double ActionPreparationLeadSeconds { get; set; }
 
         void Begin(string ndjson);

package/package.json

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