app.hypergames.hypersdk 1.11.0-beta.9 → 1.11.1

package/Runtime/Internal/Managers/TimeManager.cs

@@ -103,14 +103,28 @@ namespace Hyper.Internal.Managers
             if (Mathf.Approximately(Time.timeScale, 0f))
                 return;
 
-            float gameTimerDelta = _gameManager != null && _gameManager.IsReplayMode
-                ? Time.fixedDeltaTime
-                : Time.fixedUnscaledDeltaTime;
+            float gameTimerDelta = GetGameTimerDelta(
+                _gameManager != null && _gameManager.IsReplayMode,
+                Time.fixedDeltaTime,
+                Time.timeScale);
 
             UpdatePracticeTimer(gameTimerDelta);
             UpdateBattleTimer(gameTimerDelta);
         }
 
+        internal static float GetGameTimerDelta(
+            bool isReplayMode,
+            float fixedDeltaTime,
+            float timeScale)
+        {
+            if (timeScale <= 0f) return 0f;
+
+            // The first FixedUpdate after a pause can report the whole paused
+            // interval in fixedUnscaledDeltaTime. Derive one live simulation
+            // step instead, keeping real-time duration at custom time scales.
+            return isReplayMode ? fixedDeltaTime : fixedDeltaTime / timeScale;
+        }
+
         public void Reset()
         {
             _practiceTimer = 0;
@@ -299,9 +313,9 @@ namespace Hyper.Internal.Managers
                 }
 
                 _battleTimer -= delta;
-                if (_battleTimer <= 0)
+                if (_battleTimer <= 0f || Mathf.Approximately(_battleTimer, 0f))
                 {
-                    _battleTimer = 0;
+                    _battleTimer = 0f;
                     if (!_timeUpTriggered)
                     {
                         QueueTimeUp();
@@ -314,7 +328,8 @@ namespace Hyper.Internal.Managers
                 {
                     _battleTimer = _sessionTimer;
 
-                    if (_battleTimer <= 0 && !_timeUpTriggered)
+                    if ((_battleTimer <= 0f || Mathf.Approximately(_battleTimer, 0f)) &&
+                        !_timeUpTriggered)
                     {
                         QueueTimeUp();
                     }
@@ -324,6 +339,14 @@ namespace Hyper.Internal.Managers
 
         private void QueueTimeUp()
         {
+            if (_timeUpPending || _timeUpTriggered || _hasGameEnded) return;
+
+            _battleTimer = 0f;
+            _isBattleRunning = false;
+            ClearPausedGameplayTimerState();
+            // The SDK runs before gameplay FixedUpdate. The expiry step is blocked,
+            // even when several fixed steps run before the next rendered frame.
+            _gameManager.ReachGameplayCutoff();
             _timeUpPending = true;
         }
 
@@ -372,12 +395,7 @@ namespace Hyper.Internal.Managers
 
                 if (_hasGameStarted && _gameManager.IsBattleMode)
                 {
-                    _battleTimer = 0;
-                    if (!_timeUpTriggered)
-                    {
-                        _timeUpTriggered = true;
-                        _eventManager?.InvokeTimeUpEvent();
-                    }
+                    QueueTimeUp();
                 }
                 else
                 {

package/Runtime/Internal/Replay/ReplaySessionState.cs

@@ -14,6 +14,7 @@ namespace Hyper.Internal
         public static string AvatarUrl { get; private set; }
         public static string EntryId { get; private set; }
         public static string ReplayNdjson { get; private set; }
+        public static int? FinalScore { get; private set; }
         public static Texture2D AvatarTexture { get; private set; }
         public static bool HasReplayData => !string.IsNullOrWhiteSpace(ReplayNdjson);
         public static long OriginalRandomSeed { get; private set; }
@@ -48,6 +49,7 @@ namespace Hyper.Internal
             AvatarUrl = avatarUrl ?? string.Empty;
             EntryId = entryId ?? string.Empty;
             ReplayNdjson = string.Empty;
+            FinalScore = null;
             ReleaseAvatarTexture();
             OriginalRandomSeed = originalRandomSeed;
             Progress01 = 0f;
@@ -61,13 +63,18 @@ namespace Hyper.Internal
             GameplayStartProgress01 = 0f;
         }
 
-        public static void SetMetadata(string playerName, string avatarUrl, long originalRandomSeed)
+        public static void SetMetadata(
+            string playerName,
+            string avatarUrl,
+            long originalRandomSeed,
+            int finalScore)
         {
             if (!IsActive) return;
 
             PlayerName = playerName ?? string.Empty;
             AvatarUrl = avatarUrl ?? string.Empty;
             OriginalRandomSeed = originalRandomSeed;
+            FinalScore = finalScore;
         }
 
         public static void SetReplayData(string ndjson)
@@ -83,10 +90,10 @@ namespace Hyper.Internal
             AvatarTexture = texture;
         }
 
-        public static void SetProgress(float progress)
+        public static bool SetProgress(float progress)
         {
-            if (!IsActive) return;
-            if (IsSeeking && !_seekPlaybackReady) return;
+            if (!IsActive) return false;
+            if (IsSeeking && !_seekPlaybackReady) return false;
             float rawProgress = Math.Max(0f, Math.Min(1f, progress));
             Progress01 = GameplayStartProgress01 >= 1f
                 ? 0f
@@ -101,7 +108,10 @@ namespace Hyper.Internal
                 PlaybackSpeed = UserPlaybackSpeed;
                 RestoreAudioAfterSeek();
                 SeekCompleted?.Invoke(PlaybackSpeed);
+                return true;
             }
+
+            return false;
         }
 
         public static void SetPlaybackSpeed(float speed)
@@ -190,6 +200,7 @@ namespace Hyper.Internal
             AvatarUrl = string.Empty;
             EntryId = string.Empty;
             ReplayNdjson = string.Empty;
+            FinalScore = null;
             ReleaseAvatarTexture();
             OriginalRandomSeed = 0;
             Progress01 = 0f;

package/Runtime/Internal/ScriptableObjects/HyperSDKSettings.cs

@@ -76,6 +76,16 @@ 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;
+
+        [Space(20)]
+        [Header("Replay Settings")]
+        [Tooltip("Allow replay viewers to seek from the replay progress bar. " +
+                 "Leave disabled until the game has been validated for accelerated replay reconstruction.")]
+        public bool allowReplaySeeking = false;
+
         #endregion
 
         #region Editor Testing

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

@@ -12,35 +12,59 @@ namespace Hyper.Internal
     {
         internal const int AvatarTextureSize = 128;
 
-        [SerializeField] private Slider progressSlider;
+        [SerializeField] private Slider seekableSlider;
+        [SerializeField] private Slider readOnlySlider;
         [SerializeField] private TextMeshProUGUI replayLabel;
         [SerializeField] private RawImage playerAvatar;
         [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] private float[] playbackSpeeds = { 1f, 1.5f, 2f, 0.5f };
+        [SerializeField, Min(1f)] private float seekPlaybackSpeed = 15f;
+        [SerializeField, Min(0f)] private float readOnlyProgressSmoothTime = 0.08f;
         [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;
 
         private int playbackSpeedIndex;
+        private Slider progressSlider;
         private ReplaySeekInput seekInput;
+        private bool seekingAllowed;
         private bool wasSeeking;
         private bool isCapturingSeek;
         private float pendingSeekTarget;
+        private float displayedReadOnlyProgress;
+        private float readOnlyProgressVelocity;
         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()
         {
+            seekingAllowed = HyperRuntime.Settings != null && HyperRuntime.Settings.allowReplaySeeking;
             AutoBindReferences();
-            ConfigureProgressSlider();
-            ConfigureSeekOverlay();
-            ConfigureSeekSnapshot();
+            ConfigureProgressSliders();
+            if (seekingAllowed)
+            {
+                ConfigureSeekOverlay();
+                ConfigureSeekSnapshot();
+            }
+            else if (seekLoadingOverlay != null)
+            {
+                seekLoadingOverlay.SetActive(false);
+            }
+
             ApplyInitialPlaybackSpeed();
-            ReplaySessionState.SeekCompleted += RestorePlaybackAfterSeek;
+            if (seekingAllowed) ReplaySessionState.SeekCompleted += RestorePlaybackAfterSeek;
             if (pauseButton != null) pauseButton.onClick.AddListener(PauseReplay);
             if (playbackSpeedButton != null) playbackSpeedButton.onClick.AddListener(CyclePlaybackSpeed);
         }
@@ -52,13 +76,13 @@ namespace Hyper.Internal
             if (replayLabel != null) replayLabel.text = $"Replay of @{playerName}";
             if (progressSlider != null)
             {
-                float displayedProgress = ReplaySessionState.IsSeeking
+                float displayedProgress = seekingAllowed && ReplaySessionState.IsSeeking
                     ? ReplaySessionState.SeekTarget01
                     : ReplaySessionState.Progress01;
-                progressSlider.SetValueWithoutNotify(displayedProgress);
+                SetProgressSliderValue(displayedProgress);
             }
             UpdatePlaybackSpeedLabel(ReplaySessionState.UserPlaybackSpeed);
-            SetSeekingPresentation(ReplaySessionState.IsSeeking);
+            SetSeekingPresentation(seekingAllowed && ReplaySessionState.IsSeeking);
 
             if (playerAvatar != null && ReplaySessionState.AvatarTexture != null)
             {
@@ -68,7 +92,7 @@ namespace Hyper.Internal
 
         private void Update()
         {
-            bool isSeeking = ReplaySessionState.IsSeeking;
+            bool isSeeking = seekingAllowed && ReplaySessionState.IsSeeking;
             if (wasSeeking && !isSeeking && !ReplaySessionState.HasEnded)
             {
                 RestorePlaybackAfterSeek(ReplaySessionState.PlaybackSpeed);
@@ -79,6 +103,11 @@ namespace Hyper.Internal
                 SetSeekingPresentation(isSeeking);
             }
 
+            if (isSeeking)
+            {
+                UpdateSeekProgress(true);
+            }
+
             if (progressSlider != null && (seekInput == null || !seekInput.IsDragging))
             {
                 float displayedProgress = isCapturingSeek
@@ -86,7 +115,7 @@ namespace Hyper.Internal
                     : isSeeking
                         ? ReplaySessionState.SeekTarget01
                         : ReplaySessionState.Progress01;
-                progressSlider.SetValueWithoutNotify(displayedProgress);
+                SetProgressSliderValue(displayedProgress, !seekingAllowed);
             }
 
             wasSeeking = isSeeking;
@@ -129,7 +158,7 @@ namespace Hyper.Internal
             if (progressSlider != null) progressSlider.interactable = false;
             if (seekLoadingOverlay != null) seekLoadingOverlay.SetActive(false);
             ClearSeekSnapshot();
-            if (progressSlider != null) progressSlider.SetValueWithoutNotify(1f);
+            SetProgressSliderValue(1f);
         }
 
         internal void ResetForReplayRestart()
@@ -148,10 +177,7 @@ namespace Hyper.Internal
                 : 0f;
             wasSeeking = ReplaySessionState.IsSeeking;
 
-            if (progressSlider != null)
-            {
-                progressSlider.SetValueWithoutNotify(pendingSeekTarget);
-            }
+            SetProgressSliderValue(pendingSeekTarget);
 
             UpdatePlaybackSpeedLabel(playbackSpeed);
             AlignPlaybackSpeedIndex(playbackSpeed);
@@ -181,7 +207,7 @@ namespace Hyper.Internal
 
         private void SeekTo(float targetProgress)
         {
-            if (!ReplaySessionState.IsActive || ReplaySessionState.HasEnded ||
+            if (!seekingAllowed || !ReplaySessionState.IsActive || ReplaySessionState.HasEnded ||
                 ReplaySessionState.IsSeeking || isCapturingSeek)
             {
                 return;
@@ -189,6 +215,7 @@ namespace Hyper.Internal
 
             float resumeSpeed = SanitizePlaybackSpeed(ReplaySessionState.UserPlaybackSpeed);
             float fastForwardSpeed = SanitizePlaybackSpeed(seekPlaybackSpeed);
+            InitializeSeekProgressPresentation();
             StartCoroutine(CaptureAndSeek(targetProgress, resumeSpeed, fastForwardSpeed));
         }
 
@@ -238,7 +265,6 @@ namespace Hyper.Internal
         private void RestorePlaybackAfterSeek(float playbackSpeed)
         {
             float speed = SanitizePlaybackSpeed(playbackSpeed);
-            Time.timeScale = speed;
             AlignPlaybackSpeedIndex(speed);
             UpdatePlaybackSpeedLabel(speed);
             SetSeekingPresentation(false);
@@ -259,9 +285,14 @@ namespace Hyper.Internal
 
         private void SetSeekingPresentation(bool isSeeking)
         {
+            isSeeking &= seekingAllowed;
             ReplayPresentationCanvas.SetSeekingLayer(isSeeking);
+            UpdateSeekProgress(isSeeking);
             if (seekLoadingOverlay != null) seekLoadingOverlay.SetActive(isSeeking);
-            if (progressSlider != null) progressSlider.interactable = !isSeeking && !ReplaySessionState.HasEnded;
+            if (progressSlider != null)
+            {
+                progressSlider.interactable = seekingAllowed && !isSeeking && !ReplaySessionState.HasEnded;
+            }
             if (playbackSpeedButton != null)
             {
                 playbackSpeedButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
@@ -285,7 +316,7 @@ namespace Hyper.Internal
 
             if (playbackSpeedLabel != null)
             {
-                playbackSpeedLabel.text = $"{speed:0.#}x";
+                playbackSpeedLabel.text = $"{speed:0.##}x";
             }
         }
 
@@ -339,8 +370,6 @@ namespace Hyper.Internal
 
         private void AutoBindReferences()
         {
-            if (progressSlider == null) progressSlider = GetComponentInChildren<Slider>(true);
-
             Button[] buttons = GetComponentsInChildren<Button>(true);
             for (int i = 0; i < buttons.Length; i++)
             {
@@ -360,24 +389,69 @@ namespace Hyper.Internal
             }
         }
 
-        private void ConfigureProgressSlider()
+        private void ConfigureProgressSliders()
         {
+            progressSlider = seekingAllowed ? seekableSlider : readOnlySlider;
+
+            if (seekableSlider != null)
+            {
+                seekableSlider.gameObject.SetActive(seekingAllowed);
+            }
+
+            if (readOnlySlider != null)
+            {
+                readOnlySlider.gameObject.SetActive(!seekingAllowed);
+            }
+
             if (progressSlider == null) return;
 
             progressSlider.minValue = 0f;
             progressSlider.maxValue = 1f;
             progressSlider.wholeNumbers = false;
-            progressSlider.interactable = true;
-            float displayedProgress = ReplaySessionState.IsSeeking
+            progressSlider.interactable = seekingAllowed;
+            float displayedProgress = seekingAllowed && ReplaySessionState.IsSeeking
                 ? ReplaySessionState.SeekTarget01
                 : ReplaySessionState.Progress01;
-            progressSlider.SetValueWithoutNotify(displayedProgress);
+            SetProgressSliderValue(displayedProgress);
+
+            if (!seekingAllowed) return;
 
             seekInput = progressSlider.GetComponent<ReplaySeekInput>();
             if (seekInput == null) seekInput = progressSlider.gameObject.AddComponent<ReplaySeekInput>();
             seekInput.Initialize(progressSlider, SeekTo);
         }
 
+        private void SetProgressSliderValue(float targetProgress, bool smoothReadOnly = false)
+        {
+            if (progressSlider == null) return;
+
+            targetProgress = Mathf.Clamp01(targetProgress);
+            if (!smoothReadOnly || readOnlyProgressSmoothTime <= 0f ||
+                targetProgress < displayedReadOnlyProgress)
+            {
+                displayedReadOnlyProgress = targetProgress;
+                readOnlyProgressVelocity = 0f;
+            }
+            else
+            {
+                displayedReadOnlyProgress = Mathf.SmoothDamp(
+                    displayedReadOnlyProgress,
+                    targetProgress,
+                    ref readOnlyProgressVelocity,
+                    readOnlyProgressSmoothTime,
+                    Mathf.Infinity,
+                    Time.unscaledDeltaTime);
+
+                if (Mathf.Abs(targetProgress - displayedReadOnlyProgress) < 0.0001f)
+                {
+                    displayedReadOnlyProgress = targetProgress;
+                    readOnlyProgressVelocity = 0f;
+                }
+            }
+
+            progressSlider.SetValueWithoutNotify(displayedReadOnlyProgress);
+        }
+
         private void ConfigureSeekOverlay()
         {
             if (seekLoadingOverlay == null)
@@ -404,10 +478,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/ReplayPresentationCanvas.cs

@@ -110,7 +110,7 @@ namespace Hyper.Internal
             CanvasScaler scaler = GetComponent<CanvasScaler>();
             scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
             scaler.referenceResolution = new Vector2(1080f, 2160f);
-            scaler.matchWidthOrHeight = isPortrait ? 1f : 0.593f;
+            scaler.matchWidthOrHeight = isPortrait ? 1f : (PlayerDeviceClassification.PlayerDeviceIsPC ? 0.75f : 0.593f);
         }
 
         private void EnsurePresentationObjects()

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.FloorToInt(Mathf.Clamp01(progress01) * 10f) * 10;
+            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

@@ -1,3 +1,4 @@
+using System.Globalization;
 using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
@@ -38,7 +39,7 @@ namespace Hyper.Internal
 
             if (scoreValue != null)
             {
-                scoreValue.text = (HyperRuntime.DataManager?.CurrentScore ?? 0).ToString("N0");
+                scoreValue.text = FormatFinalScore(ReplaySessionState.FinalScore);
             }
 
             if (scoreOwnerName != null)
@@ -99,6 +100,13 @@ namespace Hyper.Internal
                 : $"@{normalizedName.ToUpperInvariant()}'S SCORE";
         }
 
+        internal static string FormatFinalScore(int? finalScore)
+        {
+            return finalScore.HasValue
+                ? finalScore.Value.ToString("N0", CultureInfo.InvariantCulture)
+                : "--";
+        }
+
         private void UpdateSoundPresentation()
         {
             bool isSoundOn = HyperRuntime.DataManager == null || HyperRuntime.DataManager.GetSound() == 1;

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

@@ -14,7 +14,7 @@ namespace Hyper.Internal
         [SerializeField] private BlinkingText blinkingText;
         [SerializeField] private RectTransform swipeGif;
         [SerializeField] private RectTransform handSpriteInGif;
-        [SerializeField] private float replayAutoStartDelay = 1f;
+        [SerializeField] private float replayAutoStartDelay = 1.02f;
         private GameManager _gameManager;
         private StartCTA _currentCTA;
         private SwipeDirection _swipeDirection;

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

@@ -16,13 +16,13 @@ namespace Hyper.Internal
         
         private void OnEnable()
         {
-            // After 3 seconds, call the Game Over modal
+            // Show Game Over after one real-time second.
             StartCoroutine(GameOver());
         }
 
         IEnumerator GameOver()
         {
-            yield return new WaitForSecondsRealtime(2f);
+            yield return new WaitForSecondsRealtime(1f);
             gameObject.SetActive(false);
 
             _gameManager.EndGame("Hyper_Time_Up");