app.hypergames.hypersdk 1.10.0 → 1.11.0-beta.10

package/Runtime/Internal/Core/HyperRuntime.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 using Hyper.Internal.Managers;
+using Hyper.Shared;
 
 namespace Hyper.Internal
 {
@@ -19,6 +20,8 @@ namespace Hyper.Internal
 
         private static bool _isInitialized;
         private static bool _isSoftRestarting;
+        private static bool _replayRandomResetPending;
+        private static bool _replayCustomRestartPending;
         private static bool _customLoadingComplete;
         private static bool _customLoadingActive;
         private static float _customLoadingProgress;
@@ -30,6 +33,8 @@ namespace Hyper.Internal
         private static DataManager _dataManager;
         private static EventManager _eventManager;
         private static TimerManager _timerManager;
+        private static ReplayManager _replayManager;
+        private static double _fixedSimulationTimeSeconds;
 
         internal static bool IsInitialized => _isInitialized;
         internal static bool IsSoftRestarting
@@ -37,6 +42,7 @@ namespace Hyper.Internal
             get => _isSoftRestarting;
             set => _isSoftRestarting = value;
         }
+        internal static bool IsReplayCustomRestartPending => _replayCustomRestartPending;
         internal static bool CustomLoadingComplete
         {
             get => _customLoadingComplete;
@@ -55,6 +61,8 @@ namespace Hyper.Internal
         internal static DataManager DataManager => _dataManager;
         internal static EventManager EventManager => _eventManager;
         internal static TimerManager Timer => _timerManager;
+        internal static ReplayManager ReplayManager => _replayManager;
+        internal static double FixedSimulationTimeSeconds => _fixedSimulationTimeSeconds;
 
         internal static event Action CustomLoadingStarted
         {
@@ -114,6 +122,85 @@ namespace Hyper.Internal
             }
         }
 
+        /// <summary>
+        /// Restarts replay playback through HyperLoader while preserving replay session data.
+        /// </summary>
+        internal static void RestartReplaySession()
+        {
+            ReplaySessionState.ResetForWatchAgain();
+            RestartReplay();
+        }
+
+        internal static void SeekReplaySession(float targetProgress, float resumeSpeed, float seekSpeed)
+        {
+            if (!ReplaySessionState.IsActive || ReplaySessionState.HasEnded) return;
+
+            ReplaySessionState.RequestSeek(targetProgress, resumeSpeed, seekSpeed);
+            ReplaySessionState.ResetForSeekRestart();
+            RestartReplay();
+        }
+
+        private static void RestartReplay()
+        {
+            _isSoftRestarting = true;
+            Time.timeScale = 1f;
+
+            _replayCustomRestartPending = false;
+            _replayRandomResetPending = false;
+            _replayManager?.PrepareForRestart();
+
+            if (_host != null)
+            {
+                _host.StartCoroutine(RestartSessionCoroutine());
+            }
+            else
+            {
+                ClearAllDontDestroyOnLoadObjects();
+                SceneManager.LoadScene("HyperLoader");
+            }
+        }
+
+        internal static void ResetReplayRandomState()
+        {
+            int originalSeed = unchecked((int)ReplaySessionState.OriginalRandomSeed);
+            if (HyperRandom.CurrentSeed == originalSeed)
+            {
+                // Preserve references held by game code while rewinding every stream.
+                HyperRandom.ResetAll();
+                return;
+            }
+
+            HyperRandom.Init(ReplaySessionState.OriginalRandomSeed);
+        }
+
+        internal static void ApplyPendingReplayRandomReset()
+        {
+            if (!_replayRandomResetPending) return;
+
+            _replayRandomResetPending = false;
+            ResetReplayRandomState();
+        }
+
+        internal static void DeferReplayRandomReset()
+        {
+            _replayRandomResetPending = true;
+        }
+
+        internal static void CompleteCustomRestart()
+        {
+            if (!_replayCustomRestartPending || _host == null) return;
+
+            _replayCustomRestartPending = false;
+            _host.StartCoroutine(CompleteReplayCustomRestartNextFrame());
+        }
+
+        private static IEnumerator CompleteReplayCustomRestartNextFrame()
+        {
+            yield return null;
+            _gameManager?.CompleteReplayCustomRestart();
+            _isSoftRestarting = false;
+        }
+
         /// <summary>
         /// Coroutine-based restart that properly unloads all scenes before reloading.
         /// Handles async scene operations and ensures clean state before restart.
@@ -122,6 +209,7 @@ namespace Hyper.Internal
         {
             yield return UnloadAllScenesCoroutine();
 
+            Clear();
             ClearAllDontDestroyOnLoadObjects();
             SceneManager.LoadScene("HyperLoader");
         }
@@ -302,6 +390,9 @@ namespace Hyper.Internal
             _gameManager = _singletonObject.AddComponent<GameManager>();
             _gameManager.Initialize();
 
+            _replayManager = new ReplayManager();
+            _replayManager.Initialize(_eventManager);
+
             _timerManager = new TimerManager();
             _timerManager.Initialize();
             _timerManager.InjectEventHooks();
@@ -313,6 +404,14 @@ namespace Hyper.Internal
             _timerManager?.Update();
         }
 
+        internal static void FixedTick()
+        {
+            if (!_isInitialized) return;
+            _fixedSimulationTimeSeconds += Time.fixedDeltaTime;
+            _replayManager?.FixedTick();
+            _timerManager?.FixedTick();
+        }
+
         internal static void Clear()
         {
             if (_host == null)
@@ -323,6 +422,9 @@ namespace Hyper.Internal
 
             _timerManager = null;
 
+            _replayManager?.Cleanup();
+            _replayManager = null;
+
             _dataManager?.Cleanup();
             _dataManager = null;
 
@@ -339,6 +441,9 @@ namespace Hyper.Internal
             _customLoadingComplete = false;
             _customLoadingActive = false;
             _customLoadingProgress = 0f;
+            _replayRandomResetPending = false;
+            _replayCustomRestartPending = false;
+            _fixedSimulationTimeSeconds = 0d;
 
             if (_singletonObject != null)
             {
@@ -364,6 +469,11 @@ namespace Hyper.Internal
             {
                 if (obj.scene.name == "DontDestroyOnLoad" && obj.transform.parent == null)
                 {
+                    if (ReplaySessionState.IsSeeking && ReplayPresentationCanvas.IsPresentationRoot(obj))
+                    {
+                        continue;
+                    }
+
                     UnityEngine.Object.Destroy(obj);
                 }
             }
@@ -372,6 +482,7 @@ namespace Hyper.Internal
         internal static void OnHostDestroyed(HyperRuntimeHost host)
         {
             if (_host != host) return;
+            _replayManager?.Cleanup();
             ResetStaticState();
         }
 
@@ -385,11 +496,15 @@ namespace Hyper.Internal
             _gameManager = null;
             _backendManager = null;
             _dataManager = null;
+            _replayManager = null;
             _gameContent = null;
             _isInitialized = false;
             _customLoadingComplete = false;
             _customLoadingActive = false;
             _customLoadingProgress = 0f;
+            _replayRandomResetPending = false;
+            _replayCustomRestartPending = false;
+            _fixedSimulationTimeSeconds = 0d;
         }
     }
 }

package/Runtime/Internal/Core/HyperRuntimeHost.cs

@@ -6,6 +6,7 @@ namespace Hyper.Internal
     /// Lightweight MonoBehaviour that allows the internal runtime to participate in
     /// Unity's update loop without exposing managed objects to public assemblies.
     /// </summary>
+    [DefaultExecutionOrder(-10000)]
     internal sealed class HyperRuntimeHost : MonoBehaviour
     {
         private void Awake()
@@ -18,6 +19,11 @@ namespace Hyper.Internal
             HyperRuntime.Tick();
         }
 
+        private void FixedUpdate()
+        {
+            HyperRuntime.FixedTick();
+        }
+
         private void OnDestroy()
         {
             HyperRuntime.OnHostDestroyed(this);

package/Runtime/Internal/Data/URLData.cs

@@ -27,6 +27,11 @@ namespace Hyper.Internal
         /// </summary>
         public bool isPVP => GameMode == GameMode.Battle;
 
+        /// <summary>
+        /// Returns true for modes that use battle gameplay, scenes, and timers.
+        /// </summary>
+        public bool IsBattleGameplay => GameMode == GameMode.Battle || GameMode == GameMode.Replay;
+
         #endregion
 
         #region Internal Fields
@@ -114,5 +119,17 @@ namespace Hyper.Internal
         {
             GameMode = GameMode.Practice;
         }
+
+        public void SetModeAsReplay()
+        {
+            GameMode = GameMode.Replay;
+        }
+
+        internal void SetModeFromLaunchFlags(bool isPVP, bool isReplay)
+        {
+            GameMode = isReplay
+                ? GameMode.Replay
+                : isPVP ? GameMode.Battle : GameMode.Practice;
+        }
     }
-}
+}

package/Runtime/Internal/Managers/BackendManager.cs

@@ -5,6 +5,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Globalization;
+using System.IO;
 using System.Runtime.InteropServices;
 using System.Text;
 using UnityEngine;
@@ -139,6 +140,233 @@ namespace Hyper.Internal.Managers
 
         #endregion
 
+        #region Replay
+
+        internal IEnumerator FetchReplay(
+            string entryId,
+            Action onSuccess,
+            Action<string> onFailure)
+        {
+            if (string.IsNullOrWhiteSpace(entryId))
+            {
+                onFailure?.Invoke("Replay entryId is missing.");
+                yield break;
+            }
+
+            string escapedEntryId = UnityWebRequest.EscapeURL(entryId.Trim());
+            string replayAccessUrl =
+                $"https://staging-ingress.nestechops.com/hyper/tournaments/HYP/me/tournaments/entries/{escapedEntryId}/replay";
+            string lastError = "Unknown replay download error.";
+
+            for (int attempt = 1; attempt <= MAX_RETRY_COUNT; attempt++)
+            {
+                using (UnityWebRequest request = UnityWebRequest.Get(replayAccessUrl))
+                {
+                    request.timeout = GENERAL_REQUEST_TIMEOUT;
+                    request.SetRequestHeader(
+                        "Accept",
+                        "application/x-ndjson, application/ndjson, text/plain");
+
+                    yield return request.SendWebRequest();
+
+                    if (request.result == UnityWebRequest.Result.Success)
+                    {
+                        if (TryParseReplayResponse(
+                            request.downloadHandler.text,
+                            out ReplayResponse replay,
+                            out string parseError))
+                        {
+                            ReplaySessionState.SetMetadata(
+                                replay.PlayerName,
+                                replay.AvatarUrl,
+                                replay.Seed);
+                            ReplaySessionState.SetReplayData(replay.ActivityNdjson);
+                            HyperDebug.Log($"Replay downloaded for entry {entryId}.");
+                            onSuccess?.Invoke();
+                            yield break;
+                        }
+
+                        lastError = parseError;
+                    }
+                    else
+                    {
+                        lastError = $"HTTP {request.responseCode}: {request.error}";
+                    }
+                }
+
+                HyperDebug.LogWarning(
+                    $"Replay download attempt {attempt}/{MAX_RETRY_COUNT} failed: {lastError}");
+
+                if (attempt < MAX_RETRY_COUNT)
+                {
+                    yield return new WaitForSecondsRealtime(0.5f);
+                }
+            }
+
+            onFailure?.Invoke(lastError);
+        }
+
+        internal IEnumerator FetchReplayAvatar(
+            string avatarUrl,
+            Action<Texture2D> onSuccess,
+            Action<string> onFailure)
+        {
+            if (string.IsNullOrWhiteSpace(avatarUrl))
+            {
+                onSuccess?.Invoke(null);
+                yield break;
+            }
+
+            string lastError = "Unknown replay avatar download error.";
+            for (int attempt = 1; attempt <= MAX_RETRY_COUNT; attempt++)
+            {
+                using (UnityWebRequest request = UnityWebRequestTexture.GetTexture(avatarUrl, false))
+                {
+                    request.timeout = GENERAL_REQUEST_TIMEOUT;
+                    yield return request.SendWebRequest();
+
+                    if (request.result == UnityWebRequest.Result.Success)
+                    {
+                        Texture2D avatar = DownloadHandlerTexture.GetContent(request);
+                        if (avatar != null)
+                        {
+                            HyperDebug.Log("Replay avatar downloaded.");
+                            onSuccess?.Invoke(avatar);
+                            yield break;
+                        }
+
+                        lastError = "The replay avatar response contained no texture.";
+                    }
+                    else
+                    {
+                        lastError = $"HTTP {request.responseCode}: {request.error}";
+                    }
+                }
+
+                HyperDebug.LogWarning(
+                    $"Replay avatar attempt {attempt}/{MAX_RETRY_COUNT} failed: {lastError}");
+
+                if (attempt < MAX_RETRY_COUNT)
+                {
+                    yield return new WaitForSecondsRealtime(0.5f);
+                }
+            }
+
+            onFailure?.Invoke(lastError);
+        }
+
+        internal IEnumerator CheckInternetConnection(Action<bool> onComplete)
+        {
+            using (UnityWebRequest request = UnityWebRequest.Head(GetServerUrl()))
+            {
+                request.timeout = 2;
+                yield return request.SendWebRequest();
+
+                // Any HTTP response proves that the backend was reachable. A 4xx/5xx
+                // response is still connectivity; replay validation belongs to bootstrap.
+                bool isConnected = request.responseCode > 0 &&
+                                   request.result != UnityWebRequest.Result.ConnectionError;
+                onComplete?.Invoke(isConnected);
+            }
+        }
+
+        internal static bool TryParseReplayResponse(
+            string ndjson,
+            out ReplayResponse replay,
+            out string error)
+        {
+            replay = default;
+            error = null;
+
+            if (string.IsNullOrWhiteSpace(ndjson))
+            {
+                error = "The replay response was empty.";
+                return false;
+            }
+
+            using (var reader = new StringReader(ndjson))
+            {
+                string seedLine = reader.ReadLine();
+                string nameLine = reader.ReadLine();
+                string avatarLine = reader.ReadLine();
+                string activities = reader.ReadToEnd();
+
+                if (seedLine == null || nameLine == null || avatarLine == null)
+                {
+                    error = "The replay response is missing required metadata.";
+                    return false;
+                }
+
+                try
+                {
+                    JArray seedData = JArray.Parse(seedLine);
+                    JArray nameData = JArray.Parse(nameLine);
+                    JArray avatarData = JArray.Parse(avatarLine);
+
+                    if (seedData.Count != 1 ||
+                        seedData[0].Type != JTokenType.Integer ||
+                        !long.TryParse(
+                            seedData[0].ToString(),
+                            NumberStyles.Integer,
+                            CultureInfo.InvariantCulture,
+                            out long seed))
+                    {
+                        error = "Replay metadata contains an invalid seed.";
+                        return false;
+                    }
+
+                    if (nameData.Count != 1 || nameData[0].Type != JTokenType.String)
+                    {
+                        error = "Replay metadata contains an invalid player name.";
+                        return false;
+                    }
+
+                    if (avatarData.Count != 1 || avatarData[0].Type != JTokenType.String)
+                    {
+                        error = "Replay metadata contains an invalid avatar URL.";
+                        return false;
+                    }
+
+                    if (string.IsNullOrWhiteSpace(activities))
+                    {
+                        error = "The replay response contains no gameplay activities.";
+                        return false;
+                    }
+
+                    replay = new ReplayResponse(
+                        seed,
+                        nameData[0].Value<string>() ?? string.Empty,
+                        avatarData[0].Value<string>() ?? string.Empty,
+                        activities);
+
+                    return true;
+                }
+                catch (JsonException)
+                {
+                    error = "Replay metadata contains invalid JSON.";
+                    return false;
+                }
+            }
+        }
+
+        internal readonly struct ReplayResponse
+        {
+            internal long Seed { get; }
+            internal string PlayerName { get; }
+            internal string AvatarUrl { get; }
+            internal string ActivityNdjson { get; }
+
+            internal ReplayResponse(long seed, string playerName, string avatarUrl, string activityNdjson)
+            {
+                Seed = seed;
+                PlayerName = playerName;
+                AvatarUrl = avatarUrl;
+                ActivityNdjson = activityNdjson;
+            }
+        }
+
+        #endregion
+
         #region Session Management
 
         private Coroutine _createSessionCoroutine;
@@ -832,6 +1060,14 @@ namespace Hyper.Internal.Managers
 
         public void StartReconnectionCoroutine()
         {
+            if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
+
+            if (_gameManager != null && _gameManager.IsReplayMode)
+            {
+                _gameManager.RetryReplayLoading();
+                return;
+            }
+
             if (_reconnectionCoroutine != null)
             {
                 HyperDebug.LogWarning("Reconnection already in progress");
@@ -1075,23 +1311,9 @@ namespace Hyper.Internal.Managers
                 _finalScoreSubmitted = false;
                 _isWaitingForFinalScoreResponse = true;
 
-                float currentScoreDataScoreTime = _dataManager.CurrentScoreData.cumulativeScore + _dataManager.CurrentScoreData.scoreSnapshot.scoreTime;
-                float lastCapturedScoreDataScoreTime = _lastSentBatch.Last().cumulativeScore + _lastSentBatch.Last().scoreSnapshot.scoreTime;
-                ScoreData finalScoreData;
-
-                if (currentScoreDataScoreTime > lastCapturedScoreDataScoreTime)
-                {
-                    finalScoreData = _dataManager.CurrentScoreData;
-                    finalScoreData.isFinal = true;
-                }
-                else
-                {
-                    finalScoreData = _lastSentBatch.Last();
-                    finalScoreData.isFinal = true;
-                    finalScoreData.timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
-                    finalScoreData.scoreSnapshot.scoreDelta = 0;
-                    finalScoreData.scoreSnapshot.gameplayModifiers = new GameplayModifiers();
-                }
+                ScoreData finalScoreData = CreateFinalScoreMarker(
+                    _dataManager.CurrentScoreData,
+                    _lastSentBatch.LastOrDefault());
 
                 // For consistency with per-second and backlog submissions, always send
                 // the final score as an array of ScoreData.
@@ -1207,8 +1429,9 @@ namespace Hyper.Internal.Managers
 
             _gameManager.GameOverModalComponent.Init();
 
-            var finalScoreData = _dataManager.CurrentScoreData;
-            finalScoreData.isFinal = true;
+            var finalScoreData = CreateFinalScoreMarker(
+                _dataManager.CurrentScoreData,
+                _lastSentBatch.LastOrDefault());
 
             yield return new WaitForSecondsRealtime(3f);
 
@@ -1265,10 +1488,6 @@ namespace Hyper.Internal.Managers
                 // Scores will be flushed when the connection is restored.
                 if (!isSocketConnected)
                 {
-#if UNITY_WEBGL && !UNITY_EDITOR
-                    int pendingCount = _dataManager?.PendingScores?.Count ?? 0;
-                    HyperDebug.Log($"[Score] Socket disconnected - accumulating scores for offline batch. PendingCount={pendingCount}");
-#endif
                     _isWaitingForTokenLogEmitted = false;
                     _hasLoggedWaitingForGameStartAck = false;
                     yield return _scoreSendInterval;
@@ -1524,7 +1743,8 @@ namespace Hyper.Internal.Managers
                 var clonedSnapshot = new ScoreSnapshot
                 {
                     scoreTime = snapshot.scoreTime,
-                    scoreDelta = snapshot.scoreDelta
+                    scoreDelta = snapshot.scoreDelta,
+                    playActivities = ClonePlayActivities(snapshot.playActivities)
                 };
 
                 if (snapshot.gameplayModifiers != null)
@@ -1548,6 +1768,43 @@ namespace Hyper.Internal.Managers
             return cloned;
         }
 
+        internal static ScoreData CreateFinalScoreMarker(ScoreData currentScore, ScoreData lastSentScore)
+        {
+            ScoreData scoreSource = currentScore ?? lastSentScore;
+            float currentScoreTime = currentScore?.scoreSnapshot?.scoreTime ?? 0f;
+            float lastSentScoreTime = lastSentScore?.scoreSnapshot?.scoreTime ?? 0f;
+
+            return new ScoreData
+            {
+                cumulativeScore = scoreSource?.cumulativeScore ?? 0,
+                isFinal = true,
+                timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(),
+                scoreSnapshot = new ScoreSnapshot
+                {
+                    // CurrentScoreData is refreshed only when the score changes, while
+                    // periodic snapshots can continue afterward. Never let the final
+                    // completion marker move the score timeline backward.
+                    scoreTime = Mathf.Max(currentScoreTime, lastSentScoreTime),
+                    scoreDelta = 0,
+                    gameplayModifiers = new GameplayModifiers(),
+                    playActivities = null
+                }
+            };
+        }
+
+        private static List<object[]> ClonePlayActivities(List<object[]> source)
+        {
+            if (source == null || source.Count == 0) return null;
+
+            var clone = new List<object[]>(source.Count);
+            for (int i = 0; i < source.Count; i++)
+            {
+                object[] activity = source[i];
+                clone.Add(activity == null ? null : (object[])activity.Clone());
+            }
+            return clone;
+        }
+
         [Serializable]
         private class WebSocketScoreMessage
         {