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

package/CHANGELOG.md

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

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/DataManager.cs

@@ -219,6 +219,7 @@ namespace Hyper.Internal.Managers
         internal void ConfigurePlayerSoundSetting()
         {
             SetSound(GetSound());
+            ReplaySessionState.EnsureAudioMutedDuringSeek();
             if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
         }
 

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");
@@ -32,6 +33,8 @@ namespace Hyper.Internal
 
         private static bool _seekPlaybackReady;
         private static bool _watchAgainAutoStartPending;
+        private static bool _isSeekAudioMuted;
+        private static float _volumeBeforeSeek;
 
         public static void Configure(
             string playerName,
@@ -39,6 +42,7 @@ namespace Hyper.Internal
             long originalRandomSeed,
             string entryId = null)
         {
+            RestoreAudioAfterSeek();
             IsActive = true;
             PlayerName = playerName ?? string.Empty;
             AvatarUrl = avatarUrl ?? string.Empty;
@@ -54,6 +58,7 @@ namespace Hyper.Internal
             _seekPlaybackReady = false;
             _watchAgainAutoStartPending = false;
             HasEnded = false;
+            GameplayStartProgress01 = 0f;
         }
 
         public static void SetMetadata(string playerName, string avatarUrl, long originalRandomSeed)
@@ -82,13 +87,19 @@ 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;
                 PlaybackSpeed = UserPlaybackSpeed;
+                RestoreAudioAfterSeek();
                 SeekCompleted?.Invoke(PlaybackSpeed);
             }
         }
@@ -107,6 +118,7 @@ namespace Hyper.Internal
             Progress01 = 1f;
             if (IsSeeking) PlaybackSpeed = UserPlaybackSpeed;
             IsSeeking = false;
+            RestoreAudioAfterSeek();
             HasEnded = true;
         }
 
@@ -119,6 +131,7 @@ namespace Hyper.Internal
             PlaybackSpeed = SanitizeSpeed(seekSpeed);
             IsSeeking = true;
             _seekPlaybackReady = false;
+            MuteAudioForSeek();
         }
 
         public static void ResetForSeekRestart()
@@ -136,9 +149,16 @@ namespace Hyper.Internal
             _seekPlaybackReady = true;
         }
 
+        internal static void EnsureAudioMutedDuringSeek()
+        {
+            if (_isSeekAudioMuted)
+                AudioListener.volume = 0f;
+        }
+
         public static void ResetForWatchAgain()
         {
             if (!IsActive) return;
+            RestoreAudioAfterSeek();
             Progress01 = 0f;
             PlaybackSpeed = 1f;
             UserPlaybackSpeed = 1f;
@@ -149,6 +169,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;
@@ -158,6 +184,7 @@ namespace Hyper.Internal
 
         public static void Clear()
         {
+            RestoreAudioAfterSeek();
             IsActive = false;
             PlayerName = string.Empty;
             AvatarUrl = string.Empty;
@@ -173,6 +200,7 @@ namespace Hyper.Internal
             _seekPlaybackReady = false;
             _watchAgainAutoStartPending = false;
             HasEnded = false;
+            GameplayStartProgress01 = 0f;
             SeekCompleted = null;
         }
 
@@ -181,6 +209,23 @@ namespace Hyper.Internal
             return float.IsNaN(speed) || float.IsInfinity(speed) || speed <= 0f ? 1f : speed;
         }
 
+        private static void MuteAudioForSeek()
+        {
+            if (_isSeekAudioMuted) return;
+
+            _volumeBeforeSeek = AudioListener.volume;
+            _isSeekAudioMuted = true;
+            AudioListener.volume = 0f;
+        }
+
+        private static void RestoreAudioAfterSeek()
+        {
+            if (!_isSeekAudioMuted) return;
+
+            AudioListener.volume = _volumeBeforeSeek;
+            _isSeekAudioMuted = false;
+        }
+
         private static void ReleaseAvatarTexture()
         {
             if (AvatarTexture != 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.8",
   "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",