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

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 = 2f;
         private GameManager _gameManager;
         private StartCTA _currentCTA;
         private SwipeDirection _swipeDirection;

package/Runtime/Public/Replay/ReplayPlaybackEngine.cs

@@ -29,6 +29,13 @@ namespace Hyper
         private double _stoppedElapsed;
         private bool _isSuspended;
         private bool _completionPending;
+        private bool _gameplayClockStarted;
+        private double _gameplaySourceStartTime;
+        private double _gameplayElapsedSeconds;
+        private double _gameplayStepSeconds;
+        private double _gameplayPauseDurationAtStart;
+        private long _gameplayTick;
+        private double _currentTickDelta;
 
         public event Action<float, float> OnValues2;
         public event Action<float> OnValue;
@@ -76,6 +83,13 @@ namespace Hyper
             _endedRaised = false;
             _completionPending = false;
             _nextActionPrepared = false;
+            _gameplayClockStarted = false;
+            _gameplaySourceStartTime = 0d;
+            _gameplayElapsedSeconds = 0d;
+            _gameplayStepSeconds = 0d;
+            _gameplayPauseDurationAtStart = 0d;
+            _gameplayTick = 0L;
+            _currentTickDelta = 0d;
             DurationSeconds = CalculateDuration(_ndjson);
             double gameplayStartSeconds = CalculateGameplayStart(_ndjson, out bool hasGameplayReadyMarker);
             HasGameplayReadyMarker = hasGameplayReadyMarker;
@@ -122,13 +136,19 @@ namespace Hyper
                            double.IsInfinity(fixedSimulationDeltaSeconds)
                 ? 0d
                 : Math.Max(0d, fixedSimulationDeltaSeconds);
+            _currentTickDelta = delta;
             _elapsedSeconds += delta;
+            if (_gameplayClockStarted && delta > 0d)
+            {
+                if (_gameplayStepSeconds <= 0d) _gameplayStepSeconds = delta;
+                _gameplayElapsedSeconds += delta;
+                _gameplayTick++;
+            }
 
             int processed = 0;
             while (IsPlaying && !_completionPending && _hasNext && processed++ < MaxActivitiesPerTick)
             {
-                double elapsed = GetElapsedSeconds();
-                double dueTime = _next.Time - _sourceStartTime - _removedPauseDuration;
+                GetSchedulingTime(_next, out double elapsed, out double dueTime);
                 PrepareNextActionIfDue(elapsed, dueTime);
                 if (elapsed + 0.000001d < dueTime) return;
 
@@ -154,6 +174,13 @@ namespace Hyper
             _isSuspended = false;
             _completionPending = false;
             _nextActionPrepared = false;
+            _gameplayClockStarted = false;
+            _gameplaySourceStartTime = 0d;
+            _gameplayElapsedSeconds = 0d;
+            _gameplayStepSeconds = 0d;
+            _gameplayPauseDurationAtStart = 0d;
+            _gameplayTick = 0L;
+            _currentTickDelta = 0d;
         }
 
         public void Suspend()
@@ -224,6 +251,7 @@ namespace Hyper
                     OnGameStarted?.Invoke();
                     break;
                 case GameplayReady:
+                    StartGameplayClock(activity.Time);
                     OnGameplayReady?.Invoke();
                     break;
                 case GamePaused:
@@ -255,6 +283,47 @@ namespace Hyper
             OnActionPreparing?.Invoke(_next.Action);
         }
 
+        private void StartGameplayClock(double sourceTime)
+        {
+            _gameplayClockStarted = true;
+            _gameplaySourceStartTime = sourceTime;
+            _gameplayElapsedSeconds = 0d;
+            _gameplayStepSeconds = _currentTickDelta;
+            _gameplayPauseDurationAtStart = _removedPauseDuration;
+            _gameplayTick = 0L;
+        }
+
+        private void GetSchedulingTime(ReplayActivity activity, out double elapsed, out double dueTime)
+        {
+            if (!_gameplayClockStarted)
+            {
+                elapsed = GetElapsedSeconds();
+                dueTime = activity.Time - _sourceStartTime - _removedPauseDuration;
+                return;
+            }
+
+            double removedGameplayPauses = Math.Max(0d,
+                _removedPauseDuration - _gameplayPauseDurationAtStart);
+            double rawDueTime = Math.Max(0d,
+                activity.Time - _gameplaySourceStartTime - removedGameplayPauses);
+
+            if (_gameplayStepSeconds <= 0d)
+            {
+                elapsed = _gameplayElapsedSeconds;
+                dueTime = rawDueTime;
+                return;
+            }
+
+            // Gameplay can only consume an activity on a fixed step. Mapping the
+            // timestamp to its nearest GPR-relative tick prevents sub-step JSON
+            // precision noise from moving an input to the following physics step.
+            long dueTick = Math.Max(0L, (long)Math.Round(
+                rawDueTime / _gameplayStepSeconds,
+                MidpointRounding.AwayFromZero));
+            elapsed = _gameplayTick * _gameplayStepSeconds;
+            dueTime = dueTick * _gameplayStepSeconds;
+        }
+
         private static bool IsLifecycleAction(string action)
         {
             return action == GameStarted || action == GamePaused ||