app.hypergames.hypersdk 1.11.0-beta.2 → 1.11.0-beta.21

package/Runtime/Internal/Managers/TimeManager.cs

@@ -32,6 +32,9 @@ namespace Hyper.Internal.Managers
         private float _battleTimer;
         private bool _isPracticeRunning;
         private bool _isBattleRunning;
+        private bool _resumePracticeAfterPause;
+        private bool _resumeBattleAfterPause;
+        private bool _hasPausedGameplayTimerState;
 
         private float _fiveSecondTimer = 5f;
         private bool _isFiveSecondTimerRunning;
@@ -111,6 +114,7 @@ namespace Hyper.Internal.Managers
         public void Reset()
         {
             _practiceTimer = 0;
+            ClearPausedGameplayTimerState();
             _lastUnscaledTime = Time.unscaledTime;
         }
 
@@ -120,6 +124,7 @@ namespace Hyper.Internal.Managers
             _battleTimer = _gameManager != null ? _gameManager.Config.TimeLimit : 0f;
             _isPracticeRunning = false;
             _isBattleRunning = false;
+            ClearPausedGameplayTimerState();
             _timeUpTriggered = false;
             _timeUpPending = false;
             _hasGameEnded = false;
@@ -129,18 +134,17 @@ namespace Hyper.Internal.Managers
 
         public void ResumeGameTimersAfterPause()
         {
-            if (_gameManager.IsBattleMode)
-            {
-                StartBattle();
-            }
-            else
-            {
-                StartPractice();
-            }
+            if (!_hasPausedGameplayTimerState) return;
+
+            _isPracticeRunning = _resumePracticeAfterPause;
+            _isBattleRunning = _resumeBattleAfterPause;
+            ClearPausedGameplayTimerState();
         }
 
         public void StartActiveGameTimer()
         {
+            ClearPausedGameplayTimerState();
+
             if (_gameManager.IsBattleMode)
             {
                 StartSessionTimer();
@@ -158,6 +162,7 @@ namespace Hyper.Internal.Managers
         {
             _hasGameEnded = true;
             _timeUpPending = false;
+            ClearPausedGameplayTimerState();
             StopBattle();
             StopPractice();
         }
@@ -168,6 +173,11 @@ namespace Hyper.Internal.Managers
         /// </summary>
         public void PauseGameplayTimers()
         {
+            if (_hasPausedGameplayTimerState) return;
+
+            _resumePracticeAfterPause = _isPracticeRunning;
+            _resumeBattleAfterPause = _isBattleRunning;
+            _hasPausedGameplayTimerState = true;
             StopBattle();
             StopPractice();
         }
@@ -208,6 +218,13 @@ namespace Hyper.Internal.Managers
         internal void StartBattle() => _isBattleRunning = true;
         internal void StopBattle() => _isBattleRunning = false;
 
+        private void ClearPausedGameplayTimerState()
+        {
+            _resumePracticeAfterPause = false;
+            _resumeBattleAfterPause = false;
+            _hasPausedGameplayTimerState = false;
+        }
+
         internal bool TrySetSessionDurationFromBackendRemainingTime(float remainingTimeSeconds)
         {
             if (_hasBackendSessionDuration)

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");
@@ -31,6 +32,9 @@ namespace Hyper.Internal
         public static event Action<float> SeekCompleted;
 
         private static bool _seekPlaybackReady;
+        private static bool _watchAgainAutoStartPending;
+        private static bool _isSeekAudioMuted;
+        private static float _volumeBeforeSeek;
 
         public static void Configure(
             string playerName,
@@ -38,6 +42,7 @@ namespace Hyper.Internal
             long originalRandomSeed,
             string entryId = null)
         {
+            RestoreAudioAfterSeek();
             IsActive = true;
             PlayerName = playerName ?? string.Empty;
             AvatarUrl = avatarUrl ?? string.Empty;
@@ -51,7 +56,9 @@ namespace Hyper.Internal
             IsSeeking = false;
             SeekTarget01 = 0f;
             _seekPlaybackReady = false;
+            _watchAgainAutoStartPending = false;
             HasEnded = false;
+            GameplayStartProgress01 = 0f;
         }
 
         public static void SetMetadata(string playerName, string avatarUrl, long originalRandomSeed)
@@ -76,19 +83,28 @@ namespace Hyper.Internal
             AvatarTexture = texture;
         }
 
-        public static void SetProgress(float progress)
+        public static bool SetProgress(float progress)
         {
-            if (!IsActive) return;
-            if (IsSeeking && !_seekPlaybackReady) return;
-            Progress01 = Math.Max(0f, Math.Min(1f, progress));
-
-            if (IsSeeking && Progress01 >= SeekTarget01)
+            if (!IsActive) return false;
+            if (IsSeeking && !_seekPlaybackReady) return false;
+            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);
+                return true;
             }
+
+            return false;
         }
 
         public static void SetPlaybackSpeed(float speed)
@@ -105,6 +121,7 @@ namespace Hyper.Internal
             Progress01 = 1f;
             if (IsSeeking) PlaybackSpeed = UserPlaybackSpeed;
             IsSeeking = false;
+            RestoreAudioAfterSeek();
             HasEnded = true;
         }
 
@@ -117,6 +134,7 @@ namespace Hyper.Internal
             PlaybackSpeed = SanitizeSpeed(seekSpeed);
             IsSeeking = true;
             _seekPlaybackReady = false;
+            MuteAudioForSeek();
         }
 
         public static void ResetForSeekRestart()
@@ -124,6 +142,7 @@ namespace Hyper.Internal
             if (!IsActive || !IsSeeking) return;
             Progress01 = 0f;
             _seekPlaybackReady = false;
+            _watchAgainAutoStartPending = false;
             HasEnded = false;
         }
 
@@ -133,20 +152,42 @@ 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;
             IsSeeking = false;
             SeekTarget01 = 0f;
             _seekPlaybackReady = false;
+            _watchAgainAutoStartPending = true;
             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;
+            _watchAgainAutoStartPending = false;
+            return pending;
+        }
+
         public static void Clear()
         {
+            RestoreAudioAfterSeek();
             IsActive = false;
             PlayerName = string.Empty;
             AvatarUrl = string.Empty;
@@ -160,7 +201,9 @@ namespace Hyper.Internal
             IsSeeking = false;
             SeekTarget01 = 0f;
             _seekPlaybackReady = false;
+            _watchAgainAutoStartPending = false;
             HasEnded = false;
+            GameplayStartProgress01 = 0f;
             SeekCompleted = null;
         }
 
@@ -169,6 +212,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/Internal/ScriptableObjects/HyperSDKSettings.cs

@@ -76,6 +76,10 @@ namespace Hyper.Internal
                  "instead of using default restart. Listen to HyperSDK.Event.OnCustomRestart in your game manager.")]
         public bool useCustomRestartFlow = false;
 
+        [Tooltip("Use the game-owned custom restart flow for replay Watch Again and seeking. " +
+                 "Leave disabled to rebuild the game through HyperLoader for deterministic replay state.")]
+        public bool useCustomReplayRestartFlow = false;
+
         #endregion
 
         #region Editor Testing

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

@@ -15,12 +15,15 @@ namespace Hyper.Internal
         [SerializeField] private Slider progressSlider;
         [SerializeField] private TextMeshProUGUI replayLabel;
         [SerializeField] private RawImage playerAvatar;
-        [SerializeField] private Button exitButton;
+        [SerializeField] private Button pauseButton;
         [SerializeField] private Button playbackSpeedButton;
         [SerializeField] private TextMeshProUGUI playbackSpeedLabel;
         [SerializeField] private float[] playbackSpeeds = { 1.5f, 2f, 3f, 4f, 5f, 1f };
-        [SerializeField, Min(1f)] private float seekPlaybackSpeed = 30f;
+        [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;
 
@@ -32,6 +35,12 @@ namespace Hyper.Internal
         private Texture2D seekSnapshotTexture;
         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()
         {
@@ -41,7 +50,7 @@ namespace Hyper.Internal
             ConfigureSeekSnapshot();
             ApplyInitialPlaybackSpeed();
             ReplaySessionState.SeekCompleted += RestorePlaybackAfterSeek;
-            if (exitButton != null) exitButton.onClick.AddListener(ExitReplay);
+            if (pauseButton != null) pauseButton.onClick.AddListener(PauseReplay);
             if (playbackSpeedButton != null) playbackSpeedButton.onClick.AddListener(CyclePlaybackSpeed);
         }
 
@@ -79,6 +88,11 @@ namespace Hyper.Internal
                 SetSeekingPresentation(isSeeking);
             }
 
+            if (isSeeking)
+            {
+                UpdateSeekProgress(true);
+            }
+
             if (progressSlider != null && (seekInput == null || !seekInput.IsDragging))
             {
                 float displayedProgress = isCapturingSeek
@@ -94,7 +108,7 @@ namespace Hyper.Internal
 
         private void OnDestroy()
         {
-            if (exitButton != null) exitButton.onClick.RemoveListener(ExitReplay);
+            if (pauseButton != null) pauseButton.onClick.RemoveListener(PauseReplay);
             if (playbackSpeedButton != null) playbackSpeedButton.onClick.RemoveListener(CyclePlaybackSpeed);
             ReplaySessionState.SeekCompleted -= RestorePlaybackAfterSeek;
             seekInput?.Clear();
@@ -124,7 +138,7 @@ namespace Hyper.Internal
 
         internal void SetReplayEnded()
         {
-            if (exitButton != null) exitButton.interactable = false;
+            if (pauseButton != null) pauseButton.interactable = false;
             if (playbackSpeedButton != null) playbackSpeedButton.interactable = false;
             if (progressSlider != null) progressSlider.interactable = false;
             if (seekLoadingOverlay != null) seekLoadingOverlay.SetActive(false);
@@ -158,10 +172,9 @@ namespace Hyper.Internal
             SetSeekingPresentation(ReplaySessionState.IsSeeking);
         }
 
-        private void ExitReplay()
+        private void PauseReplay()
         {
-            if (exitButton != null) exitButton.interactable = false;
-            HyperRuntime.GameManager?.ExitReplayEarly();
+            HyperRuntime.GameManager?.PauseReplay();
         }
 
         private void CyclePlaybackSpeed()
@@ -190,6 +203,7 @@ namespace Hyper.Internal
 
             float resumeSpeed = SanitizePlaybackSpeed(ReplaySessionState.UserPlaybackSpeed);
             float fastForwardSpeed = SanitizePlaybackSpeed(seekPlaybackSpeed);
+            InitializeSeekProgressPresentation();
             StartCoroutine(CaptureAndSeek(targetProgress, resumeSpeed, fastForwardSpeed));
         }
 
@@ -239,7 +253,6 @@ namespace Hyper.Internal
         private void RestorePlaybackAfterSeek(float playbackSpeed)
         {
             float speed = SanitizePlaybackSpeed(playbackSpeed);
-            Time.timeScale = speed;
             AlignPlaybackSpeedIndex(speed);
             UpdatePlaybackSpeedLabel(speed);
             SetSeekingPresentation(false);
@@ -261,6 +274,7 @@ namespace Hyper.Internal
         private void SetSeekingPresentation(bool isSeeking)
         {
             ReplayPresentationCanvas.SetSeekingLayer(isSeeking);
+            UpdateSeekProgress(isSeeking);
             if (seekLoadingOverlay != null) seekLoadingOverlay.SetActive(isSeeking);
             if (progressSlider != null) progressSlider.interactable = !isSeeking && !ReplaySessionState.HasEnded;
             if (playbackSpeedButton != null)
@@ -268,7 +282,7 @@ namespace Hyper.Internal
                 playbackSpeedButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
             }
 
-            if (exitButton != null) exitButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
+            if (pauseButton != null) pauseButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
             if (!isSeeking) ClearSeekSnapshot();
         }
 
@@ -341,7 +355,12 @@ namespace Hyper.Internal
         private void AutoBindReferences()
         {
             if (progressSlider == null) progressSlider = GetComponentInChildren<Slider>(true);
-            if (exitButton == null) exitButton = GetComponentInChildren<Button>(true);
+
+            Button[] buttons = GetComponentsInChildren<Button>(true);
+            for (int i = 0; i < buttons.Length; i++)
+            {
+                if (pauseButton == null && buttons[i].name == "PauseButton") pauseButton = buttons[i];
+            }
 
             TextMeshProUGUI[] labels = GetComponentsInChildren<TextMeshProUGUI>(true);
             for (int i = 0; replayLabel == null && i < labels.Length; i++)
@@ -400,10 +419,114 @@ namespace Hyper.Internal
             seekLoadingOverlay.transform.SetAsFirstSibling();
             seekOverlayBackground = seekLoadingOverlay.GetComponent<Image>();
             if (seekOverlayBackground != null) seekOverlayBackgroundColor = seekOverlayBackground.color;
+            seekOverlay = seekLoadingOverlay.GetComponent<ReplaySeekOverlay>();
             seekLoadingOverlay.SetActive(ReplaySessionState.IsSeeking);
             wasSeeking = ReplaySessionState.IsSeeking;
         }
 
+        private void UpdateSeekProgress(bool isSeeking)
+        {
+            if (seekOverlay == null) return;
+
+            float progress;
+            if (!isSeeking)
+            {
+                progress = 1f;
+            }
+            else if (isCapturingSeek || ReplaySessionState.IsSeekRestartPending)
+            {
+                AdvanceSeekPreparationProgress();
+                progress = displayedSeekProgress;
+            }
+            else
+            {
+                EnsureSeekProgressPresentation();
+                float target = ReplaySessionState.SeekTarget01;
+                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/Internal/UI/Components/ReplaySeekOverlay.cs

@@ -0,0 +1,18 @@
+using TMPro;
+using UnityEngine;
+
+namespace Hyper.Internal
+{
+    internal sealed class ReplaySeekOverlay : MonoBehaviour
+    {
+        [SerializeField] private TextMeshProUGUI progressText;
+
+        internal void SetProgress(float progress01)
+        {
+            if (progressText == null) return;
+
+            int percentage = Mathf.RoundToInt(Mathf.Clamp01(progress01) * 100f);
+            progressText.text = $"{percentage}%";
+        }
+    }
+}

package/Runtime/Internal/UI/Components/ReplaySeekOverlay.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a7d0eb352f3c4d64a687b8c4509e1fa2

package/Runtime/Internal/UI/Modals/ReplayPausedModal.cs

@@ -0,0 +1,145 @@
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    internal sealed class ReplayPausedModal : MonoBehaviour
+    {
+        [SerializeField] private TextMeshProUGUI scoreValue;
+        [SerializeField] private TextMeshProUGUI scoreOwnerName;
+        [SerializeField] private TextMeshProUGUI soundText;
+        [SerializeField] private Sprite soundIconOn;
+        [SerializeField] private Sprite soundIconOff;
+        [SerializeField] private Image soundIcon;
+        [SerializeField] private GameObject restartButton;
+        [SerializeField] private Button resumeButton;
+        [SerializeField] private Button exitButton;
+        [SerializeField] private Button soundButton;
+        [SerializeField] private Button restartActionButton;
+        [SerializeField] private GameObject exitLoadingCircle;
+
+        private bool handled;
+
+        private void Awake()
+        {
+            AutoBindButtons();
+            resumeButton?.onClick.AddListener(ResumeReplay);
+            exitButton?.onClick.AddListener(ExitReplay);
+            soundButton?.onClick.AddListener(ToggleSound);
+            restartActionButton?.onClick.AddListener(RestartReplay);
+        }
+
+        private void OnEnable()
+        {
+            handled = false;
+            SetButtonsInteractable(true);
+            exitLoadingCircle?.SetActive(false);
+
+            if (scoreValue != null)
+            {
+                scoreValue.text = (HyperRuntime.DataManager?.CurrentScore ?? 0).ToString("N0");
+            }
+
+            if (scoreOwnerName != null)
+            {
+                scoreOwnerName.text = FormatScoreOwner(ReplaySessionState.PlayerName);
+            }
+
+            UpdateSoundPresentation();
+        }
+
+        private void OnDestroy()
+        {
+            resumeButton?.onClick.RemoveListener(ResumeReplay);
+            exitButton?.onClick.RemoveListener(ExitReplay);
+            soundButton?.onClick.RemoveListener(ToggleSound);
+            restartActionButton?.onClick.RemoveListener(RestartReplay);
+        }
+
+        public void ResumeReplay()
+        {
+            if (handled) return;
+            handled = true;
+            SetButtonsInteractable(false);
+            HyperRuntime.GameManager?.ResumeReplay();
+        }
+
+        public void ExitReplay()
+        {
+            if (handled) return;
+            handled = true;
+            SetButtonsInteractable(false);
+            exitLoadingCircle?.SetActive(true);
+            HyperRuntime.GameManager?.ExitReplayEarly();
+        }
+
+        public void ToggleSound()
+        {
+            if (handled || HyperRuntime.DataManager == null) return;
+
+            int sound = HyperRuntime.DataManager.GetSound() == 1 ? 0 : 1;
+            HyperRuntime.DataManager.SetSound(sound);
+            UpdateSoundPresentation();
+        }
+
+        public void RestartReplay()
+        {
+            if (handled) return;
+            handled = true;
+            SetButtonsInteractable(false);
+            HyperRuntime.RestartReplaySession();
+        }
+
+        internal static string FormatScoreOwner(string playerName)
+        {
+            string normalizedName = (playerName ?? string.Empty).Trim().TrimStart('@');
+            return string.IsNullOrEmpty(normalizedName)
+                ? "PLAYER'S SCORE"
+                : $"@{normalizedName.ToUpperInvariant()}'S SCORE";
+        }
+
+        private void UpdateSoundPresentation()
+        {
+            bool isSoundOn = HyperRuntime.DataManager == null || HyperRuntime.DataManager.GetSound() == 1;
+            if (soundText != null) soundText.text = isSoundOn ? "Sound On" : "Sound Off";
+            if (soundIcon != null) soundIcon.sprite = isSoundOn ? soundIconOn : soundIconOff;
+        }
+
+        private void AutoBindButtons()
+        {
+            Button[] buttons = GetComponentsInChildren<Button>(true);
+            for (int i = 0; i < buttons.Length; i++)
+            {
+                switch (buttons[i].name)
+                {
+                    case "Resume":
+                        if (resumeButton == null) resumeButton = buttons[i];
+                        break;
+                    case "Exit":
+                        if (exitButton == null) exitButton = buttons[i];
+                        break;
+                    case "SoundButton":
+                        if (soundButton == null) soundButton = buttons[i];
+                        break;
+                    case "RestartButton":
+                        if (restartActionButton == null) restartActionButton = buttons[i];
+                        break;
+                }
+            }
+
+            if (restartButton == null && restartActionButton != null)
+            {
+                restartButton = restartActionButton.gameObject;
+            }
+        }
+
+        private void SetButtonsInteractable(bool interactable)
+        {
+            if (resumeButton != null) resumeButton.interactable = interactable;
+            if (exitButton != null) exitButton.interactable = interactable;
+            if (soundButton != null) soundButton.interactable = interactable;
+            if (restartActionButton != null) restartActionButton.interactable = interactable;
+        }
+    }
+}

package/Runtime/Internal/UI/Modals/ReplayPausedModal.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b26c59e3565391f4daa22e917b6156b4

package/Runtime/Internal/UI/Modals/StartingInstructionModal.cs

@@ -59,6 +59,7 @@ namespace Hyper.Internal
         {
             float elapsed = 0f;
             float delay = Mathf.Max(0f, replayAutoStartDelay);
+            if (ReplaySessionState.ConsumeWatchAgainAutoStart()) delay *= 0.5f;
             while (elapsed < delay)
             {
                 if (Application.isFocused) elapsed += Time.unscaledDeltaTime;