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

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
         {

package/Runtime/Internal/Managers/DataManager.cs

@@ -3,8 +3,14 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
+#if UNITY_EDITOR
+using System.IO;
+using System.Text;
+using Newtonsoft.Json;
+#endif
 using UnityEngine;
 using Hyper.Internal;
+using Hyper.Internal.Replay;
 using Hyper.Shared;
 
 namespace Hyper.Internal.Managers
@@ -18,6 +24,7 @@ namespace Hyper.Internal.Managers
 
         private EventManager _eventManager;
         private GameManager _gameManager;
+        private ReplayActivityRecorder _replayRecorder;
 
         void Awake()
         {
@@ -26,13 +33,32 @@ namespace Hyper.Internal.Managers
 
         internal void Initialize()
         {
+            _replayRecorder = new ReplayActivityRecorder(GetUnixTimeSeconds, GetSimulationTimeSeconds);
+#if UNITY_EDITOR
+            _replayRecorder.ActivityRecorded += CaptureEditorReplayActivity;
+#endif
             _eventManager.OnTutorialFetchComplete += GetAndAssignTutorialResources;
+            _eventManager.OnGameStart += HandleGameStarted;
+            _eventManager.OnGamePaused += HandleGamePaused;
+            _eventManager.OnGameResumed += HandleGameResumed;
+            _eventManager.OnGameEnded += HandleGameEnded;
             AudioListener.volume = 0;
         }
 
         internal void Cleanup()
         {
             StopAllCoroutines();
+#if UNITY_EDITOR
+            if (_replayRecorder != null)
+                _replayRecorder.ActivityRecorded -= CaptureEditorReplayActivity;
+#endif
+            if (_eventManager == null) return;
+
+            _eventManager.OnTutorialFetchComplete -= GetAndAssignTutorialResources;
+            _eventManager.OnGameStart -= HandleGameStarted;
+            _eventManager.OnGamePaused -= HandleGamePaused;
+            _eventManager.OnGameResumed -= HandleGameResumed;
+            _eventManager.OnGameEnded -= HandleGameEnded;
         }
 
         #endregion
@@ -50,7 +76,7 @@ namespace Hyper.Internal.Managers
             CurrentScore = score;
             _gameManager.UpdateScoreLabel();
 
-            float currentTimestamp = _gameManager.Config.GameMode == GameMode.Practice
+            float currentTimestamp = _gameManager.IsPracticeMode
                 ? HyperRuntime.Timer.CurrentTime
                 : _gameManager.Config.TimeLimit - HyperRuntime.Timer.CurrentTime;
 
@@ -77,12 +103,66 @@ namespace Hyper.Internal.Managers
             modifiers.globalModifiers = GlobalMultiplier;
             modifiers.activePowerUps = ActivePowerups;
 
-            if (score > GetBestScore())
+            if (!_gameManager.IsReplayMode && score > GetBestScore())
             {
                 SetBestScore(CurrentScoreData, _gameManager.Config.SessionId);
             }
         }
 
+        public void RecordActivity(float value)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordValue(value);
+        }
+
+        public void RecordActivity(float first, float second)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordValues(first, second);
+        }
+
+        public void RecordActivity(float first, float second, float third)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordValues(first, second, third);
+        }
+
+        public void RecordActivity(string action)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordAction(action);
+        }
+
+        public void RecordActivity(string firstAction, string secondAction)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordActions(firstAction, secondAction);
+        }
+
+        public void RecordActivity(string action, float first)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordActionValue(action, first);
+        }
+
+        public void RecordActivity(float first, string action)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordValueAction(first, action);
+        }
+
+        public void RecordActivity(string action, float first, float second)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordActionValues(action, first, second);
+        }
+
+        public void RecordActivity(float first, float second, string action)
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.RecordValuesAction(first, second, action);
+        }
+
         public void SetComboMultiplier(float value)
         {
             ComboMultiplier = Mathf.Max(1f, value);
@@ -243,7 +323,7 @@ namespace Hyper.Internal.Managers
         {
             while (true)
             {
-                float currentTimestamp = _gameManager.Config.GameMode == GameMode.Practice
+                float currentTimestamp = _gameManager.IsPracticeMode
                     ? HyperRuntime.Timer.CurrentTime
                     : _gameManager.Config.TimeLimit - HyperRuntime.Timer.CurrentTime;
 
@@ -251,34 +331,139 @@ namespace Hyper.Internal.Managers
 
                 if (currentGameSecond > _lastCapturedGameSecond)
                 {
-                    // Get objects from pools to avoid allocations in this hot path
-                    var newScore = GetPooledScoreData();
-                    var snapshot = GetPooledScoreSnapshot();
-                    var modifiers = GetPooledGameplayModifiers();
+                    CaptureScoreSnapshot(currentGameSecond, _replayRecorder?.Drain());
+                }
 
-                    newScore.cumulativeScore = CurrentScore;
-                    newScore.timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
-                    newScore.isFinal = false;
+                yield return null;
+            }
+        }
 
-                    snapshot.scoreTime = currentGameSecond;
-                    snapshot.scoreDelta = CurrentScore - _lastCapturedScore;
+        private void CaptureScoreSnapshot(float gameSecond, List<object[]> playActivities)
+        {
+            var newScore = GetPooledScoreData();
+            var snapshot = GetPooledScoreSnapshot();
+            var modifiers = GetPooledGameplayModifiers();
 
-                    modifiers.comboModifiers = ComboMultiplier;
-                    modifiers.globalModifiers = GlobalMultiplier;
-                    modifiers.activePowerUps = ActivePowerups;
+            newScore.cumulativeScore = CurrentScore;
+            newScore.timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
+            newScore.isFinal = false;
 
-                    snapshot.gameplayModifiers = modifiers;
-                    newScore.scoreSnapshot = snapshot;
+            snapshot.scoreTime = gameSecond;
+            snapshot.scoreDelta = CurrentScore - _lastCapturedScore;
+            snapshot.playActivities = playActivities;
+
+            modifiers.comboModifiers = ComboMultiplier;
+            modifiers.globalModifiers = GlobalMultiplier;
+            modifiers.activePowerUps = ActivePowerups;
 
-                    PendingScores.Add(newScore);
+            snapshot.gameplayModifiers = modifiers;
+            newScore.scoreSnapshot = snapshot;
+            PendingScores.Add(newScore);
 
-                    _lastCapturedGameSecond = currentGameSecond;
-                    _lastCapturedScore = CurrentScore;
+            _lastCapturedGameSecond = gameSecond;
+            _lastCapturedScore = CurrentScore;
+        }
+
+        private void HandleGameStarted()
+        {
+            if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
+            if (!CanRecordReplayActivity()) return;
+#if UNITY_EDITOR
+            _editorReplay.Clear();
+            _editorReplay.AppendLine(JsonConvert.SerializeObject(
+                new object[] { HyperRandom.CurrentSeed }));
+            _editorReplay.AppendLine(JsonConvert.SerializeObject(new object[] { "hypergamer" }));
+            _editorReplay.AppendLine(JsonConvert.SerializeObject(new object[] { string.Empty }));
+#endif
+            _replayRecorder?.StartSession();
+        }
+
+        private void HandleGamePaused()
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.PauseSession();
+        }
+
+        private void HandleGameResumed()
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.ResumeSession();
+        }
+
+        private void HandleGameEnded()
+        {
+            if (!CanRecordReplayActivity()) return;
+            _replayRecorder?.EndSession();
+#if UNITY_EDITOR
+            SaveEditorReplay();
+#endif
+            List<object[]> remainingActivities = _replayRecorder?.Drain();
+            if (remainingActivities == null || remainingActivities.Count == 0) return;
+
+            if (PendingScores.Count > 0 && PendingScores[PendingScores.Count - 1].cumulativeScore == CurrentScore)
+            {
+                ScoreSnapshot latestSnapshot = PendingScores[PendingScores.Count - 1].scoreSnapshot;
+                if (latestSnapshot.playActivities == null)
+                {
+                    latestSnapshot.playActivities = remainingActivities;
                 }
+                else
+                {
+                    latestSnapshot.playActivities.AddRange(remainingActivities);
+                }
+                return;
+            }
 
-                yield return null;
+            CaptureScoreSnapshot(GetCurrentGameTime(), remainingActivities);
+        }
+
+        private bool CanRecordReplayActivity()
+        {
+            if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
+            return _gameManager != null && _gameManager.IsBattleMode && !_gameManager.IsReplayMode;
+        }
+
+#if UNITY_EDITOR
+        private readonly StringBuilder _editorReplay = new StringBuilder(4096);
+
+        private void CaptureEditorReplayActivity(object[] activity)
+        {
+            _editorReplay.AppendLine(JsonConvert.SerializeObject(activity));
+        }
+
+        private void SaveEditorReplay()
+        {
+            try
+            {
+                File.WriteAllText(ReplaySessionState.EditorReplayFilePath, _editorReplay.ToString());
+                HyperDebug.Log($"Replay saved to {ReplaySessionState.EditorReplayFilePath}");
+            }
+            catch (Exception exception)
+            {
+                HyperDebug.LogWarning($"Unable to save Editor replay: {exception.Message}");
             }
         }
+#endif
+
+        private float GetCurrentGameTime()
+        {
+            if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
+            if (_gameManager == null || HyperRuntime.Timer == null) return Mathf.Max(0f, _lastCapturedGameSecond);
+
+            return _gameManager.IsPracticeMode
+                ? HyperRuntime.Timer.CurrentTime
+                : _gameManager.Config.TimeLimit - HyperRuntime.Timer.CurrentTime;
+        }
+
+        private static double GetUnixTimeSeconds()
+        {
+            return DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000d;
+        }
+
+        private static double GetSimulationTimeSeconds()
+        {
+            return Time.fixedTimeAsDouble;
+        }
 
         private ScoreData GetPooledScoreData()
         {
@@ -337,6 +522,7 @@ namespace Hyper.Internal.Managers
 
             snapshot.scoreTime = 0f;
             snapshot.scoreDelta = 0;
+            snapshot.playActivities = null;
 
             if (_scoreSnapshotPool.Count < SCORE_POOL_CAPACITY)
             {