app.hypergames.hypersdk 1.9.1 → 1.11.0-beta.1

package/Runtime/Internal/Managers/GameManager.cs

@@ -82,14 +82,20 @@ namespace Hyper.Internal.Managers
             {
                 Destroy(_hyperCanvasObject);
             }
+
+            if (!ReplaySessionState.IsSeeking)
+            {
+                ReplayPresentationCanvas.DestroyCurrent();
+            }
         }
 
         #endregion
 
         #region Public API Implementation
 
-        public bool IsBattleMode => Config.GameMode == GameMode.Battle;
-        public bool IsPracticeMode => !IsBattleMode;
+        public bool IsBattleMode => Config.IsBattleGameplay;
+        public bool IsPracticeMode => Config.GameMode == GameMode.Practice;
+        public bool IsReplayMode => Config.GameMode == GameMode.Replay;
         public bool IsPaused => _isPaused;
         public bool HasGameStarted => _hasGameStarted;
         public bool HasGameEnded => _hasGameEnded;
@@ -114,6 +120,12 @@ namespace Hyper.Internal.Managers
         {
             if (!IsBattleMode) return;
 
+            if (IsReplayMode)
+            {
+                EndReplayGame();
+                return;
+            }
+
             var timeLeft = HyperRuntime.Timer.CurrentTime;
             if (timeLeft <= 0f) return;
 
@@ -124,6 +136,12 @@ namespace Hyper.Internal.Managers
         {
             if (IsBattleMode) return;
 
+            if (ReplaySessionState.IsActive)
+            {
+                EndReplayGame();
+                return;
+            }
+
             SetGameEnded();
             HyperRuntime.Timer.StopAllTimers();
 
@@ -158,6 +176,7 @@ namespace Hyper.Internal.Managers
 
         internal void PauseGame()
         {
+            if (IsReplayMode) return;
             if (!_hasGameStarted || _isPaused || _hasGameEnded) return;
 
             _isPaused = true;
@@ -190,11 +209,66 @@ namespace Hyper.Internal.Managers
 
         void OnApplicationFocus(bool hasFocus)
         {
+            if (IsReplayMode)
+            {
+                HandleReplayFocus(hasFocus);
+                return;
+            }
 #if !UNITY_EDITOR
             HandlePauseState(!hasFocus);
 #endif
         }
 
+        private void HandleReplayFocus(bool hasFocus)
+        {
+            if (!_hasGameStarted || _hasGameEnded) return;
+
+            if (!hasFocus && _replayFocusResumeCoroutine != null)
+            {
+                StopCoroutine(_replayFocusResumeCoroutine);
+                _replayFocusResumeCoroutine = null;
+            }
+
+            if (!hasFocus && !_replayFocusSuspended)
+            {
+                _replayFocusSuspended = true;
+                _savedReplayTimeScale = Time.timeScale;
+                Time.timeScale = 0f;
+                HyperRuntime.Timer.PauseGameplayTimers();
+
+                // WebGL may stop producing frames immediately after focus loss,
+                // so suspend replay timing here instead of waiting for Update.
+                _previousTimeScale = 0f;
+                _eventManager.InvokeTimeScaleFrozenEvent();
+                HyperDebug.Log("Time scale frozen event invoked");
+            }
+            else if (hasFocus && _replayFocusSuspended)
+            {
+                if (_replayFocusResumeCoroutine == null)
+                {
+                    _replayFocusResumeCoroutine = StartCoroutine(ResumeReplayAfterFocus());
+                }
+            }
+        }
+
+        private IEnumerator ResumeReplayAfterFocus()
+        {
+            // WebGL reports focus before Unity refreshes its unscaled clock. Keep
+            // gameplay and replay frozen briefly while session time continues.
+            yield return new WaitForSecondsRealtime(1f);
+
+            _replayFocusResumeCoroutine = null;
+            if (!_replayFocusSuspended || _hasGameEnded) yield break;
+
+            _replayFocusSuspended = false;
+            Time.timeScale = _savedReplayTimeScale > 0f ? _savedReplayTimeScale : 1f;
+            HyperRuntime.Timer.ResumeGameTimersAfterPause();
+
+            _previousTimeScale = Time.timeScale;
+            _eventManager.InvokeTimeScaleResumedEvent();
+            HyperDebug.Log("Time scale resumed event invoked");
+        }
+
         void HandlePauseState(bool shouldPause)
         {
             if (shouldPause && !_isPaused)
@@ -214,7 +288,7 @@ namespace Hyper.Internal.Managers
                     _eventManager.InvokeTimeScaleFrozenEvent();
                     HyperDebug.Log("Time scale frozen event invoked");
 
-                    if (_backendManager.isSocketConnected)
+                    if (!IsReplayMode && _backendManager.isSocketConnected)
                     {
                         _dataManager.StopCapturingScores();
                         _backendManager.StopSendingScores();
@@ -227,13 +301,13 @@ namespace Hyper.Internal.Managers
 
                     // Always restart capturing when game resumes, even if offline,
                     // so scores accumulate for the offline batch and are flushed on reconnect.
-                    if (!_hasGameEnded && _hasGameStarted)
+                    if (!IsReplayMode && !_hasGameEnded && _hasGameStarted)
                     {
                         _dataManager.StartCapturingScores();
                     }
 
                     // Only resume server session if connected
-                    if (_backendManager.isSocketConnected && !_hasGameEnded && _hasGameStarted)
+                    if (!IsReplayMode && _backendManager.isSocketConnected && !_hasGameEnded && _hasGameStarted)
                     {
                         _backendManager.SendGameResumed();
                     }
@@ -336,6 +410,7 @@ namespace Hyper.Internal.Managers
 
         internal void ShowConnectionLost()
         {
+            if (IsReplayMode) return;
             if (!IsInGameScene) return;
 
             EnsureConnectionStatusBar();
@@ -352,6 +427,7 @@ namespace Hyper.Internal.Managers
 
         internal void ShowConnectionRestored()
         {
+            if (IsReplayMode) return;
             if (!IsInGameScene) return;
 
             EnsureConnectionStatusBar();
@@ -374,7 +450,7 @@ namespace Hyper.Internal.Managers
                 if (!_loadingFailedModal.activeInHierarchy)
                 {
                     _loadingFailedModal.SetActive(true);
-                    SetBlockerActive(true);
+                    SetBlockerActive(true, 0.05f);
                 }
                 _eventManager.InvokeConnectionLostEvent();
             }
@@ -389,6 +465,59 @@ namespace Hyper.Internal.Managers
             }
         }
 
+        internal void RetryReplayLoading()
+        {
+            if (!IsReplayMode) return;
+
+            if (_replayConnectionCheckCoroutine != null)
+            {
+                return;
+            }
+
+            _replayConnectionCheckCoroutine = StartCoroutine(CheckReplayConnection());
+        }
+
+        private IEnumerator CheckReplayConnection()
+        {
+            const float timeoutSeconds = 5f;
+            float startedAt = Time.realtimeSinceStartup;
+            bool checkInProgress = false;
+            bool isConnected = false;
+
+            _loadingFailedModalComponent?.ShowRetryCountdown(Mathf.CeilToInt(timeoutSeconds));
+
+            while (Time.realtimeSinceStartup - startedAt < timeoutSeconds)
+            {
+                if (!isConnected && !checkInProgress)
+                {
+                    checkInProgress = true;
+                    StartCoroutine(HyperRuntime.BackendManager.CheckInternetConnection(connected =>
+                    {
+                        isConnected = connected;
+                        checkInProgress = false;
+                    }));
+                }
+
+                float remaining = timeoutSeconds - (Time.realtimeSinceStartup - startedAt);
+                _loadingFailedModalComponent?.ShowRetryCountdown(Mathf.CeilToInt(remaining));
+                yield return null;
+            }
+
+            _replayConnectionCheckCoroutine = null;
+
+            if (isConnected)
+            {
+                // This emits connection-found, allowing the existing loader to restart
+                // bootstrap and fetch/validate all replay data through its normal path.
+                ShowLoadingFailedModal(false);
+                yield break;
+            }
+
+            // The probe may finish early or reach the five-second deadline. In either
+            // case restore the modal CTA state instead of waiting at 00:00.
+            _loadingFailedModalComponent?.AllAttemptsHaveFailed();
+        }
+
         internal void ShowScoreSubmissionFailedModal()
         {
             if (IsPortrait())
@@ -484,6 +613,12 @@ namespace Hyper.Internal.Managers
 
         internal void ShowGameOverModal()
         {
+            if (IsReplayMode)
+            {
+                ShowReplayOverModal();
+                return;
+            }
+
             HidePauseModals();
 
             if (IsBattleMode)
@@ -585,12 +720,16 @@ namespace Hyper.Internal.Managers
         #region Private State
 
         private bool _hasGameStarted;
+        private bool _gameStartRequested;
         private bool _isPaused;
         private bool _hasGameEnded;
+        private bool _replayEndHandled;
         private bool _isFrozenBeforePause;
         private bool _isPortrait;
         private float _previousTimeScale = 1f;
         private float _savedTimeScaleBeforePause = 1f;
+        private bool _replayFocusSuspended;
+        private float _savedReplayTimeScale = 1f;
 
         #endregion
 
@@ -609,6 +748,9 @@ namespace Hyper.Internal.Managers
 
         [DllImport("__Internal")]
         private static extern void MarkGameLoadedOnHTML();
+
+        [DllImport("__Internal")]
+        private static extern void MarkGameStartedOnHTML();
 #endif
 
         private void HandleQueryParameters()
@@ -618,6 +760,8 @@ namespace Hyper.Internal.Managers
             if (queryParamsPtr == IntPtr.Zero)
             {
                 HyperDebug.LogError("Failed to get query parameters");
+                Config = new URLData { GameMode = GameMode.Practice };
+                SyncReplayContext();
                 return;
             }
 
@@ -637,23 +781,32 @@ namespace Hyper.Internal.Managers
             }
 #else
             Config = HyperRuntime.Settings._settings;
+#if !UNITY_EDITOR
+            if (Config.GameMode == GameMode.Replay)
+            {
+                Config.GameMode = GameMode.Practice;
+            }
+#endif
+            SyncReplayContext();
 #endif
         }
 
         private void ParseQueryParameters()
         {
-            SetGameModeAndPVP();
+            SetGameMode();
             SetBackendGameStatus();
             SetOptionalParameters();
             SetSafeAreaBounds();
+            SyncReplayContext();
         }
 
-        private void SetGameModeAndPVP()
+        private void SetGameMode()
         {
-            bool isPVP = QueryParamsData.TryGetValue("pvp", out string pvpValue) && pvpValue == "true";
-            Config.GameMode = isPVP ? GameMode.Battle : GameMode.Practice;
+            bool isReplay = IsTrueQueryFlag("replay");
+            bool isPVP = IsTrueQueryFlag("pvp");
+            Config.SetModeFromLaunchFlags(isPVP, isReplay);
 
-            if (isPVP && QueryParamsData.TryGetValue("time", out string timeValue))
+            if (Config.IsBattleGameplay && QueryParamsData.TryGetValue("time", out string timeValue))
             {
                 if (float.TryParse(timeValue, out float timeLimit))
                 {
@@ -662,6 +815,35 @@ namespace Hyper.Internal.Managers
             }
         }
 
+        private bool IsTrueQueryFlag(string key)
+        {
+            return QueryParamsData.TryGetValue(key, out string value) &&
+                   string.Equals(value, "true", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private void SyncReplayContext()
+        {
+            if (IsReplayMode)
+            {
+                string entryId = Config.EntryId ?? string.Empty;
+                bool isNewReplay = !ReplaySessionState.IsActive ||
+                    !string.Equals(ReplaySessionState.EntryId, entryId, StringComparison.Ordinal);
+
+                if (isNewReplay)
+                {
+                    ReplaySessionState.Configure(
+                        string.Empty,
+                        string.Empty,
+                        (int)Config.RandomSeed,
+                        entryId);
+                }
+            }
+            else
+            {
+                ReplaySessionState.Clear();
+            }
+        }
+
         private void SetBackendGameStatus()
         {
             string[] requiredFields = { "tournamentId", "gameId", "entryId", "host", "embedUrl" };
@@ -680,6 +862,14 @@ namespace Hyper.Internal.Managers
 
         private void SetOptionalParameters()
         {
+            // Replay launches only require replay=true and entryId, so capture it
+            // independently of the full backend PvP launch contract.
+            if (QueryParamsData.TryGetValue("entryId", out string entryId) &&
+                !string.IsNullOrWhiteSpace(entryId))
+            {
+                Config.EntryId = entryId;
+            }
+
             if (QueryParamsData.TryGetValue("gameSlug", out string gameSlug))
                 Config.GameSlug = gameSlug;
 
@@ -766,6 +956,7 @@ namespace Hyper.Internal.Managers
             {
                 IsInGameScene = false;
                 _hasGameStarted = false;
+                _gameStartRequested = false;
                 _hasGameEnded = false;
                 _isPaused = false;
                 _isFrozenBeforePause = false;
@@ -790,7 +981,9 @@ namespace Hyper.Internal.Managers
             HideGameOverModal();
             IsInGameScene = true;
             _hasGameStarted = false;
+            _gameStartRequested = false;
             _hasGameEnded = false;
+            _replayEndHandled = false;
             _isPaused = false;
             _isFrozenBeforePause = false;
             _previousTimeScale = Time.timeScale; // Sync with actual time scale on scene load
@@ -798,7 +991,7 @@ namespace Hyper.Internal.Managers
 
         private void InitializeSceneUI()
         {
-            if (Config.isPVP)
+            if (IsBattleMode)
             {
                 HyperRuntime.Timer.StartPreSessionTimer();
                 HyperRuntime.Timer.StartFiveSecondCountdown();
@@ -810,7 +1003,44 @@ namespace Hyper.Internal.Managers
 
             ShowControlBarElements();
             AddTutorialModal();
-            ShowTutorialAnnouncementOrStartingInstruction();
+            if (IsReplayMode && ReplaySessionState.IsSeeking)
+            {
+                StartCoroutine(StartSeekingReplayWhenReady());
+            }
+            else
+            {
+                ShowTutorialAnnouncementOrStartingInstruction();
+            }
+        }
+
+        private IEnumerator StartSeekingReplayWhenReady()
+        {
+            // Allow scene scripts to subscribe to OnGameStart without presenting Tap to Start.
+            yield return null;
+            StartGameplay();
+        }
+
+        internal void StartGameplay()
+        {
+            if (_gameStartRequested || _hasGameStarted || _hasGameEnded || !IsInGameScene) return;
+            _gameStartRequested = true;
+
+            HideStartGameDeadlineSnackBar();
+            _dataManager.UpdateScore(0);
+            HyperRuntime.Timer.StartActiveGameTimer();
+            _dataManager.StartCapturingScores();
+            _backendManager.StartSendingScores();
+
+            if (_backendManager.isSocketConnected)
+            {
+                _backendManager.SendGameStarted();
+            }
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+            MarkGameStartedOnHTML();
+#endif
+            _eventManager.InvokeGameStartEvent();
+            HideStartingInstructionModal();
         }
 
         private IEnumerator BootstrapAndStart()
@@ -841,6 +1071,7 @@ namespace Hyper.Internal.Managers
 
             // Reset game state flags
             _hasGameStarted = false;
+            _gameStartRequested = false;
             _hasGameEnded = false;
             _isPaused = false;
             _isFrozenBeforePause = false;
@@ -859,6 +1090,12 @@ namespace Hyper.Internal.Managers
 
         private void EndGameInternal()
         {
+            if (IsReplayMode)
+            {
+                EndReplayGame();
+                return;
+            }
+
             SetGameEnded();
 
             _eventManager.InvokeGameEndedEvent();
@@ -878,6 +1115,57 @@ namespace Hyper.Internal.Managers
             }
         }
 
+        private void EndReplayGame()
+        {
+            if (ReplaySessionState.IsSeekRestartPending) return;
+
+            // Time Up marks _hasGameEnded before its two-second presentation finishes.
+            // Track replay finalization separately so that delayed end still runs once.
+            if (_replayEndHandled) return;
+
+            _replayEndHandled = true;
+            _hasGameEnded = true;
+            _replayFocusSuspended = false;
+            Time.timeScale = 1f;
+            _eventManager.InvokeGameEndedEvent();
+            HyperRuntime.Timer.StopAllTimers();
+            _dataManager.StopCapturingScores();
+            HyperRuntime.BackendManager.StopSendingScores();
+            ReplaySessionState.MarkEnded();
+            _replayControllerComponent?.SetReplayEnded();
+            ShowReplayOverModal();
+        }
+
+        internal void ExitReplayEarly()
+        {
+            if (!IsReplayMode) return;
+
+            if (!_replayEndHandled)
+            {
+                _replayEndHandled = true;
+                _hasGameEnded = true;
+                _eventManager.InvokeGameEndedEvent();
+            }
+
+            Time.timeScale = 1f;
+            HyperRuntime.Timer.StopAllTimers();
+            _dataManager.StopCapturingScores();
+            HyperRuntime.BackendManager.StopSendingScores();
+            _replayControllerComponent?.SetReplayEnded();
+            ReplaySessionState.Clear();
+            ReplayPresentationCanvas.DestroyCurrent();
+            HyperRuntime.BackendManager.LogEvent(ConsoleEventType.PracticeGameEnd);
+        }
+
+        internal void ExitCompletedReplay()
+        {
+            if (!IsReplayMode) return;
+
+            ReplaySessionState.Clear();
+            ReplayPresentationCanvas.DestroyCurrent();
+            HyperRuntime.BackendManager.LogEvent(ConsoleEventType.PracticeGameEnd);
+        }
+
         internal void EndGame(string key)
         {
             if (key == "Hyper_Time_Up")
@@ -969,6 +1257,12 @@ namespace Hyper.Internal.Managers
         private GameObject _blockerUI;
         private Image _blockerUIImage;
         private GameObject _safeArea;
+        private GameObject _replayInputBlocker;
+        private GameObject _replayControllerObject;
+        private ReplayController _replayControllerComponent;
+        private GameObject _replayOverModal;
+        private Coroutine _replayConnectionCheckCoroutine;
+        private Coroutine _replayFocusResumeCoroutine;
 
         private GameObject _connectionStatusBar;
         private GameObject _startGameDeadlineStatusBar;
@@ -1085,7 +1379,7 @@ namespace Hyper.Internal.Managers
 #endif
         }
 
-        private void SetBlockerActive(bool isActive)
+        private void SetBlockerActive(bool isActive, float opacity = 0.55f)
         {
             if (_blockerUI == null) return;
 
@@ -1093,7 +1387,7 @@ namespace Hyper.Internal.Managers
 
             if (isActive)
             {
-                _blockerUIImage.color = new Color(0f, 0f, 0f, 0.55f);
+                _blockerUIImage.color = new Color(0f, 0f, 0f, Mathf.Clamp01(opacity));
                 int lastActiveIndex = GetLastActiveChildIndex();
                 _blockerUI.transform.SetSiblingIndex(lastActiveIndex - 1);
             }
@@ -1121,6 +1415,11 @@ namespace Hyper.Internal.Managers
             if (_controlBarElements == null) CreateControlBarElements();
 
             _controlBarElements.SetActive(true);
+
+            if (IsReplayMode)
+            {
+                EnsureReplayPresentation();
+            }
         }
 
         private void HideTopBarElements()
@@ -1157,6 +1456,42 @@ namespace Hyper.Internal.Managers
             _controlBarModal = _controlBarElements.GetComponent<ControlBar>();
         }
 
+        private void EnsureReplayPresentation()
+        {
+            ReplayPresentationCanvas presentation = ReplayPresentationCanvas.GetOrCreate(_isPortrait);
+            _replayInputBlocker = presentation.InputBlocker;
+            _replayControllerObject = presentation.ControllerObject;
+            _replayControllerComponent = presentation.Controller;
+            EventSystem.current?.SetSelectedGameObject(null);
+        }
+
+        private void ShowReplayOverModal()
+        {
+            HidePauseModals();
+
+            if (_replayOverModal == null)
+            {
+                if (_canvas == null) CreateCanvas();
+                GameObject prefab = Resources.Load<GameObject>("UIPrefabs/ReplayOverModal");
+                if (prefab == null)
+                {
+                    HyperDebug.LogWarning("[GameManager] ReplayOverModal prefab not found.");
+                    return;
+                }
+
+                _replayOverModal = InstantiateModal(prefab);
+                if (_replayOverModal.GetComponent<ReplayOverModal>() == null)
+                {
+                    _replayOverModal.AddComponent<ReplayOverModal>();
+                }
+            }
+
+            _replayOverModal.SetActive(true);
+            _replayOverModal.transform.SetAsLastSibling();
+            SetBlockerActive(true);
+            _replayOverModal.transform.SetAsLastSibling();
+        }
+
         private void EnsureConnectionStatusBar()
         {
             if (_connectionStatusBar != null) return;

package/Runtime/Internal/Managers/ReplayManager.cs

@@ -0,0 +1,111 @@
+using Hyper.Shared;
+
+namespace Hyper.Internal.Managers
+{
+    /// <summary>
+    /// Owns replay playback for the active SDK session. Games only subscribe to
+    /// typed activity callbacks; loading, timing, progress, suspension and ending
+    /// are handled here.
+    /// </summary>
+    internal sealed class ReplayManager
+    {
+        private IReplayPlaybackEngine _playback;
+        private EventManager _eventManager;
+        private bool _endingGame;
+
+        internal void Initialize(EventManager eventManager)
+        {
+            _eventManager = eventManager;
+            _eventManager.OnGameStart += HandleGameStart;
+            _eventManager.OnGameEnded += HandleGameEnded;
+            _eventManager.OnTimeScaleFrozen += HandleTimeScaleFrozen;
+            _eventManager.OnTimeScaleResumed += HandleTimeScaleResumed;
+        }
+
+        internal void AttachPlayback(IReplayPlaybackEngine playback)
+        {
+            if (ReferenceEquals(_playback, playback)) return;
+            DetachPlayback();
+            _playback = playback;
+            if (_playback == null) return;
+
+            _playback.OnGameEnded += HandlePlaybackEnded;
+        }
+
+        internal void FixedTick()
+        {
+            if (_playback == null || !_playback.IsPlaying) return;
+            _playback.Tick();
+            ReplaySessionState.SetProgress(_playback.Progress01);
+        }
+
+        internal void Cleanup()
+        {
+            if (_eventManager != null)
+            {
+                _eventManager.OnGameStart -= HandleGameStart;
+                _eventManager.OnGameEnded -= HandleGameEnded;
+                _eventManager.OnTimeScaleFrozen -= HandleTimeScaleFrozen;
+                _eventManager.OnTimeScaleResumed -= HandleTimeScaleResumed;
+            }
+
+            DetachPlayback();
+            _eventManager = null;
+        }
+
+        private void HandleGameStart()
+        {
+            if (HyperRuntime.GameManager == null || !HyperRuntime.GameManager.IsReplayMode ||
+                !ReplaySessionState.HasReplayData || _playback == null)
+            {
+                return;
+            }
+
+            if (ReplaySessionState.IsSeeking)
+            {
+                ReplaySessionState.NotifySeekPlaybackStarted();
+                UnityEngine.Time.timeScale = ReplaySessionState.PlaybackSpeed;
+            }
+
+            _playback.Begin(ReplaySessionState.ReplayNdjson);
+        }
+
+        private void HandleGameEnded()
+        {
+            if (_endingGame) return;
+            _playback?.Stop();
+        }
+
+        private void HandleTimeScaleFrozen()
+        {
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode)
+                _playback?.Suspend();
+        }
+
+        private void HandleTimeScaleResumed()
+        {
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode)
+                _playback?.Resume();
+        }
+
+        private void HandlePlaybackEnded()
+        {
+            ReplaySessionState.MarkEnded();
+
+            GameManager gameManager = HyperRuntime.GameManager;
+            if (gameManager == null || gameManager.HasGameEnded) return;
+
+            _endingGame = true;
+            gameManager.EndGame();
+            _endingGame = false;
+        }
+
+        private void DetachPlayback()
+        {
+            if (_playback == null) return;
+            _playback.Stop();
+            _playback.OnGameEnded -= HandlePlaybackEnded;
+            _playback = null;
+        }
+    }
+}