app.hypergames.hypersdk 1.4.21 → 1.5.0

package/Runtime/Internal/Managers/BackendManager.cs

@@ -42,13 +42,28 @@ namespace Hyper.Internal.Managers
 
         #region Public Properties (Internal API)
 
-        public int scoreSubmissionTimeout { get; private set; } = 4;
+        public int scoreSubmissionTimeout { get; private set; } = 6;
         public int CurrentRetryCount => _currentRetryCount;
         public bool isSocketConnected { get; private set; }
         public bool tutorialFetchSuccess { get; private set; }
         public bool tutorialExistsButFailed { get; private set; }
         public bool tutorialDoesNotExist => !tutorialExistsButFailed && !tutorialFetchSuccess && !_isFetchingTutorial;
 
+        /// <summary>
+        /// Type of error that occurred during score submission.
+        /// </summary>
+        public enum SubmissionErrorType
+        {
+            None,
+            NetworkError,
+            TimeoutError,
+            CSRFTokenError,
+            ServerError,
+            EncryptionError
+        }
+
+        public SubmissionErrorType LastSubmissionError { get; private set; } = SubmissionErrorType.None;
+
         #endregion
 
         #region Private Configuration
@@ -156,7 +171,7 @@ namespace Hyper.Internal.Managers
                     entryId = _gameManager?.Config.EntryId,
                     host = _gameManager?.Config.Host,
                     time = _gameManager?.Config.TimeLimit,
-                    username = _gameManager?.Config.Username,
+                    userName = _gameManager?.Config.Username,
                     userId = _gameManager?.Config.UserId,
                     pvp = _gameManager?.Config.isPVP,
                     oldTournamentId = _gameManager?.Config.OldTournamentId
@@ -299,6 +314,7 @@ namespace Hyper.Internal.Managers
         public void StopWebSocket()
         {
             _isManuallyClosed = true;
+            isSocketConnected = false;
             CloseWebSocket();
         }
 
@@ -349,7 +365,15 @@ namespace Hyper.Internal.Managers
 
             if (string.IsNullOrEmpty(_cachedSessionId))
             {
-                HyperDebug.LogError("No valid session ID – cannot send resumeGame");
+                HyperDebug.LogError("[ResumeGame] No valid session ID – cannot send resumeGame");
+                _sendGameResumedCoroutine = null;
+                yield break;
+            }
+
+            // Don't send if socket is not connected - prevents wasting retry attempts
+            if (!isSocketConnected)
+            {
+                HyperDebug.LogWarning("[ResumeGame] Cannot send gameResumed: WebSocket not connected");
                 _sendGameResumedCoroutine = null;
                 yield break;
             }
@@ -373,12 +397,12 @@ namespace Hyper.Internal.Managers
                     };
 
                     string json = JsonConvert.SerializeObject(message);
-                    HyperDebug.Log($"Sending game resumed message: {json}");
+                    HyperDebug.Log($"[ResumeGame] Sending game resumed message (attempt {attempts}/{maxAttempts}): {json}");
                     SendWebSocketMessage(json);
                 }
                 catch (Exception ex)
                 {
-                    HyperDebug.LogError($"SendGameResumed attempt {attempts} failed: {ex.Message}");
+                    HyperDebug.LogError($"[ResumeGame] SendGameResumed attempt {attempts} failed: {ex.Message}");
                 }
 
                 float elapsed = 0f;
@@ -389,6 +413,11 @@ namespace Hyper.Internal.Managers
                     yield return null;
                     elapsed += Time.unscaledDeltaTime;
                 }
+
+                if (!_gameResumed)
+                {
+                    HyperDebug.LogWarning($"[ResumeGame] No gameResumed acknowledgement from server within {timeout} seconds (attempt {attempts}/{maxAttempts}).");
+                }
             }
 
             yield return new WaitForSecondsRealtime(1.5f);
@@ -454,6 +483,18 @@ namespace Hyper.Internal.Managers
 
         public void OnSocketConnected()
         {
+            if (HyperRuntime.Timer.SessionTimeRemaining <= 0)
+            {
+                HyperDebug.LogWarning("Session time remaining is 0 - closing WebSocket connection");
+                CloseWebSocket();
+                return;
+            }
+
+            // Mark connected before any follow-up actions (resumeGame, UI updates, etc.)
+            isSocketConnected = true;
+            _isManuallyClosed = false;
+            _isSocketErrorCalled = false;
+
             if (_gameManager.HasGameStarted)
             {
                 _gameManager?.ShowConnectionRestored();
@@ -463,20 +504,18 @@ namespace Hyper.Internal.Managers
             {
                 _eventManager?.InvokeConnectionFoundEvent();
             }
-
-            isSocketConnected = true;
-            _isManuallyClosed = false;
-            _isSocketErrorCalled = false;
         }
 
         public void OnSocketDisconnected()
         {
+            isSocketConnected = false;
+
             if (!_isManuallyClosed)
             {
                 _gameManager?.ShowConnectionLost();
             }
 
-            if (!_gameManager.HasGameStarted && isSocketConnected)
+            if (!_gameManager.HasGameStarted)
             {
                 _isSocketErrorCalled = true;
                 _gameManager?.ShowLoadingFailedModal(true);
@@ -506,14 +545,16 @@ namespace Hyper.Internal.Managers
                 _sendGameStartedCoroutine = null;
             }
 
-            TryUpdateCSRFToken(message);
+            HyperDebug.Log("[WebSocket] Received gameStarted event from server.");
+            TryUpdateCSRFToken(message, "gameStarted");
         }
 
         public void OnSocketGameResumed(string message)
         {
             _gameResumed = true;
+            HyperDebug.Log("[WebSocket] Received gameResumed event from server.");
 
-            TryUpdateCSRFToken(message);
+            TryUpdateCSRFToken(message, "gameResumed");
             ResumeScoreSending();
         }
 
@@ -526,20 +567,23 @@ namespace Hyper.Internal.Managers
         {
             if (_lastSentBatch != null && _lastSentBatch.Count > 0)
             {
-                _lastScoreData = _lastSentBatch.Last();
+                _lastScoreData = _lastSentBatch[_lastSentBatch.Count - 1];
+                HyperDebug.Log($"[Score] Server acknowledged score update. CumulativeScore={_lastScoreData.cumulativeScore}, IsFinal={_lastScoreData.isFinal}");
                 _eventManager?.InvokeWebSocketScoreSubmitted(_lastScoreData);
             }
 
-            if (_isFinalScoreSubmission)
+            if (_isWaitingForFinalScoreResponse)
             {
+                HyperDebug.Log("[Score] Final score response received from server.");
                 _finalScoreSubmitted = true;
-                _isFinalScoreSubmission = false;
+                _isWaitingForFinalScoreResponse = false;
+                return;
             }
 
-            TryUpdateCSRFToken(message);
+            TryUpdateCSRFToken(message, "scoreUpdated");
         }
 
-        private void TryUpdateCSRFToken(string json)
+        private void TryUpdateCSRFToken(string json, string context = null)
         {
             try
             {
@@ -547,11 +591,17 @@ namespace Hyper.Internal.Managers
                 if (parsed.TryGetValue("csrfToken", out object tokenObj))
                 {
                     _csrfToken = tokenObj.ToString();
+                    int tokenLength = string.IsNullOrEmpty(_csrfToken) ? 0 : _csrfToken.Length;
+                    HyperDebug.Log($"[CSRF] Token updated from '{context ?? "unknown"}'. Length={tokenLength}");
+                }
+                else
+                {
+                    HyperDebug.LogWarning($"[CSRF] No csrfToken field present in message when updating from '{context ?? "unknown"}'.");
                 }
             }
             catch (Exception ex)
             {
-                HyperDebug.LogError($"Failed to parse CSRF token: {ex.Message}");
+                HyperDebug.LogError($"[CSRF] Failed to parse CSRF token from '{context ?? "unknown"}': {ex.Message}");
             }
         }
 
@@ -663,27 +713,67 @@ namespace Hyper.Internal.Managers
 
             _finalScoreSubmissionCoroutine = null;
 
-#if UNITY_WEBGL && !UNITY_EDITOR
-            _finalScoreSubmissionCoroutine = StartCoroutine(FinalScoreSubmissionCoroutine());
-#else
-            _finalScoreSubmissionCoroutine = StartCoroutine(FinalScoreSubmissionCoroutineDemo());
-#endif
+            SubmitScore();
         }
 
         private IEnumerator FinalScoreSubmissionCoroutine()
         {
             _gameManager?.GameOverModalComponent?.Init();
             _currentRetryCount = 0;
+            LastSubmissionError = SubmissionErrorType.None;
+
+            // Keep connection alive during game end sequence
+            // WebSocket connections can be closed by proxies/firewalls if idle for too long (typically 30-60 seconds)
+            // During gameplay, scores are sent every second, keeping the connection active
+            // But at game end, we stop sending scores, so the connection might go idle
+            // We ensure the connection is active right before submission by checking and reconnecting if needed
+            if (!isSocketConnected)
+            {
+                HyperDebug.LogWarning("WebSocket disconnected at game end - attempting to reconnect before submission");
+                InitializeWebSocket();
+
+                // Wait a bit for connection to establish
+                float reconnectWait = 0f;
+                const float maxReconnectWait = 3f;
+                while (!isSocketConnected && reconnectWait < maxReconnectWait)
+                {
+                    yield return new WaitForSecondsRealtime(0.1f);
+                    reconnectWait += 0.1f;
+                }
+
+                if (isSocketConnected)
+                {
+                    HyperDebug.Log("Connection restored before score submission");
+                }
+            }
+            else
+            {
+                // Connection is active - ensure it stays active by verifying it's still connected
+                // The act of checking and the upcoming gameResumed call will keep it active
+                HyperDebug.Log("Connection active - maintaining during game end sequence");
+            }
 
             while (_currentRetryCount < MAX_RETRY_COUNT)
             {
                 if (_hasSessionEnded)
                 {
+                    LastSubmissionError = SubmissionErrorType.NetworkError;
                     _gameManager?.ShowRetryTimeExpiredModal();
                     _finalScoreSubmissionCoroutine = null;
                     yield break;
                 }
 
+                // Check if we received a late response during retry wait
+                // This handles the case where backend responds after timeout but before next retry
+                if (_finalScoreSubmitted)
+                {
+                    LastSubmissionError = SubmissionErrorType.None;
+                    _gameManager?.GameOverModalComponent?.ScoreHasBeenSubmitted();
+                    StopWebSocket();
+                    _finalScoreSubmissionCoroutine = null;
+                    yield break;
+                }
+
                 var finalScoreData = _dataManager?.CurrentScoreData;
                 finalScoreData.isFinal = true;
 
@@ -694,17 +784,19 @@ namespace Hyper.Internal.Managers
 
                 if (string.IsNullOrEmpty(encryptedScoreData))
                 {
-                    HyperDebug.LogError("Encryption failed");
+                    LastSubmissionError = SubmissionErrorType.EncryptionError;
+                    HyperDebug.LogError("Encryption failed [ENCRYPTION_ERROR]");
                     yield break;
                 }
 
+                // Reset gameResumed flag for this attempt
+                _gameResumed = false;
+
+                // Ensure game is resumed to get new CSRF token before final score submission
                 if (_sendGameResumedCoroutine == null)
                 {
                     _sendGameResumedCoroutine = StartCoroutine(SendGameResumedCoroutine());
-
-                    //? Ensure game is resumed to get new CSRF token before final score submission
                     yield return _sendGameResumedCoroutine;
-
                     _sendGameResumedCoroutine = null;
                 }
                 else
@@ -714,7 +806,8 @@ namespace Hyper.Internal.Managers
 
                 if (!isSocketConnected)
                 {
-                    HyperDebug.LogError("WebSocket not connected - cannot submit final score");
+                    LastSubmissionError = SubmissionErrorType.NetworkError;
+                    HyperDebug.LogError("WebSocket not connected - cannot submit final score [NETWORK_ERROR]");
                     _currentRetryCount++;
                     _gameManager?.GameOverModalComponent?.UpdateAttemptCount(_currentRetryCount, MAX_RETRY_COUNT);
 
@@ -725,10 +818,32 @@ namespace Hyper.Internal.Managers
                     continue;
                 }
 
+                // Verify that gameResumed succeeded (CSRF token was refreshed)
+                // If _gameResumed is still false, the CSRF token wasn't refreshed and submission will fail
+                if (!_gameResumed)
+                {
+                    LastSubmissionError = SubmissionErrorType.CSRFTokenError;
+                    HyperDebug.LogWarning("gameResumed did not succeed - CSRF token may be stale. Retrying entire submission process (including gameResumed)... [CSRF_TOKEN_ERROR]");
+                    _currentRetryCount++;
+                    _gameManager?.GameOverModalComponent?.UpdateAttemptCount(_currentRetryCount, MAX_RETRY_COUNT);
+
+                    if (_currentRetryCount < MAX_RETRY_COUNT)
+                    {
+                        yield return new WaitForSecondsRealtime(1f);
+                    }
+
+                    continue;
+                }
+
                 // Sending final score via WebSocket
                 _finalScoreSubmitted = false;
-                _isFinalScoreSubmission = true;
-                _lastSentBatch = new List<ScoreData> { finalScoreData };
+                _isWaitingForFinalScoreResponse = true;
+
+                _lastSentBatch.Clear();
+                if (finalScoreData != null)
+                {
+                    _lastSentBatch.Add(finalScoreData);
+                }
 
                 bool sendFailed = false;
                 try
@@ -739,8 +854,10 @@ namespace Hyper.Internal.Managers
                 }
                 catch (Exception ex)
                 {
-                    HyperDebug.LogError($"Failed to send final score via WebSocket: {ex.Message}");
-                    _isFinalScoreSubmission = false;
+                    LastSubmissionError = SubmissionErrorType.NetworkError;
+                    HyperDebug.LogError($"Failed to send final score via WebSocket: {ex.Message} [NETWORK_ERROR]");
+                    // Keep _isWaitingForFinalScoreResponse = true since we're still in final score submission mode
+                    // and will retry. We're still waiting for a final score response.
                     sendFailed = true;
                 }
 
@@ -765,7 +882,8 @@ namespace Hyper.Internal.Managers
                     if (_hasSessionEnded)
                     {
                         _gameManager?.ShowRetryTimeExpiredModal();
-                        _isFinalScoreSubmission = false;
+                        // Session ended - can't retry anymore, so set to false
+                        _isWaitingForFinalScoreResponse = false;
                         _finalScoreSubmissionCoroutine = null;
                         yield break;
                     }
@@ -783,13 +901,18 @@ namespace Hyper.Internal.Managers
                 else if (_hasSessionEnded)
                 {
                     _gameManager?.ShowRetryTimeExpiredModal();
-                    _isFinalScoreSubmission = false;
+                    // Session ended - can't retry anymore, so set to false
+                    _isWaitingForFinalScoreResponse = false;
                     _finalScoreSubmissionCoroutine = null;
                     yield break;
                 }
                 else
                 {
-                    _isFinalScoreSubmission = false;
+                    // Timeout occurred, but keep _isWaitingForFinalScoreResponse = true
+                    // because we're still in final score submission mode and will retry.
+                    // If backend responds during retry wait, we'll catch it.
+                    LastSubmissionError = SubmissionErrorType.TimeoutError;
+                    HyperDebug.LogWarning($"Score submission timeout after {timeout} seconds [TIMEOUT_ERROR]");
                     _currentRetryCount++;
                     _gameManager?.GameOverModalComponent?.UpdateAttemptCount(_currentRetryCount, MAX_RETRY_COUNT);
 
@@ -800,7 +923,9 @@ namespace Hyper.Internal.Managers
                 }
             }
 
-            _isFinalScoreSubmission = false;
+            // All retries exhausted - log the final error type for debugging
+            HyperDebug.LogError($"Score submission failed after {MAX_RETRY_COUNT} attempts. Error type: {LastSubmissionError}");
+            _isWaitingForFinalScoreResponse = false;
             _gameManager?.GameOverModalComponent?.AllAttemptsHaveFailed();
             _finalScoreSubmissionCoroutine = null;
         }
@@ -828,10 +953,13 @@ namespace Hyper.Internal.Managers
         #region Score Submission (WebSocket)
 
         private Coroutine _scoreSenderCoroutine;
-        private List<ScoreData> _lastSentBatch = new List<ScoreData>();
+        // Stores standalone copies of the last batch that was sent over the socket.
+        // We explicitly clone these so they are not affected by the DataManager's object pooling.
+        private readonly List<ScoreData> _lastSentBatch = new List<ScoreData>();
+        private readonly List<ScoreData> _scoreSendBuffer = new List<ScoreData>();
         private ScoreData _lastScoreData;
         private readonly WaitForSeconds _scoreSendInterval = new WaitForSeconds(1f);
-        private bool _isFinalScoreSubmission;
+        private bool _isWaitingForFinalScoreResponse;
         private bool _finalScoreSubmitted;
 
         public void StartSendingScores()
@@ -858,21 +986,20 @@ namespace Hyper.Internal.Managers
         {
             while (true)
             {
-                List<ScoreData> scoresToSend = null;
+                var scoresToSend = _scoreSendBuffer;
+                scoresToSend.Clear();
 
-                try
+                if (_dataManager?.PendingScores.Count > 0)
                 {
-                    if (_dataManager?.PendingScores.Count > 0)
-                    {
-                        scoresToSend = new List<ScoreData>(_dataManager?.PendingScores);
-                        _dataManager?.PendingScores.Clear();
-                        SendScoresOverWebSocket(scoresToSend);
-                    }
+                    // Copy pending scores into our reusable buffer, then clear the source list
+                    scoresToSend.AddRange(_dataManager?.PendingScores);
+                    _dataManager?.PendingScores.Clear();
+                    HyperDebug.Log($"[Score] Preparing to send {scoresToSend.Count} score sample(s) over WebSocket. LastPendingCumulativeScore={scoresToSend[scoresToSend.Count - 1].cumulativeScore}");
+                    SendScoresOverWebSocket(scoresToSend);
                 }
-                finally
+                else
                 {
-                    scoresToSend?.Clear();
-                    scoresToSend = null;
+                    HyperDebug.Log("[Score] No pending scores to send in this tick.");
                 }
 
                 yield return _scoreSendInterval;
@@ -883,10 +1010,70 @@ namespace Hyper.Internal.Managers
         {
             if (scores == null || scores.Count == 0) return;
 
+            // Don't send if socket is not connected - prevents sending with expired tokens
+            // and ensures we wait for reconnection to get fresh token via SendGameResumed()
+            if (!isSocketConnected)
+            {
+                int lastScore = scores[scores.Count - 1].cumulativeScore;
+                HyperDebug.LogWarning($"[Score] Cannot send scores: WebSocket not connected. LastBatchCumulativeScore={lastScore} [ErrorType=NetworkError]");
+                return;
+            }
+
             try
             {
-                _lastSentBatch = new List<ScoreData>(scores);
-                var scoreData = scores.Last();
+                // Clone the last batch into standalone ScoreData instances
+                // so that pooling/reset in DataManager does not zero out the values we log/use here.
+                _lastSentBatch.Clear();
+
+                ScoreData scoreData = null;
+                if (scores.Count > 0)
+                {
+                    // We only need the last score point for submission, but we keep the whole batch
+                    // for events so listeners can inspect the last acknowledged score accurately.
+                    for (int i = 0; i < scores.Count; i++)
+                    {
+                        var source = scores[i];
+                        if (source == null) continue;
+
+                        var cloned = new ScoreData
+                        {
+                            cumulativeScore = source.cumulativeScore,
+                            isFinal = source.isFinal,
+                            timestampUtc = source.timestampUtc
+                        };
+
+                        if (source.scoreSnapshot != null)
+                        {
+                            var snapshot = source.scoreSnapshot;
+                            var clonedSnapshot = new ScoreSnapshot
+                            {
+                                scoreTime = snapshot.scoreTime,
+                                scoreDelta = snapshot.scoreDelta
+                            };
+
+                            if (snapshot.gameplayModifiers != null)
+                            {
+                                var mods = snapshot.gameplayModifiers;
+                                var clonedMods = new GameplayModifiers
+                                {
+                                    comboModifiers = mods.comboModifiers,
+                                    globalModifiers = mods.globalModifiers,
+                                    activePowerUps = mods.activePowerUps != null
+                                        ? new List<string>(mods.activePowerUps)
+                                        : null
+                                };
+
+                                clonedSnapshot.gameplayModifiers = clonedMods;
+                            }
+
+                            cloned.scoreSnapshot = clonedSnapshot;
+                        }
+
+                        _lastSentBatch.Add(cloned);
+                    }
+
+                    scoreData = scores[scores.Count - 1];
+                }
 
                 string rawScoreJson = JsonConvert.SerializeObject(scoreData);
                 var compressedScoreData = JsonCompressor.CompressJson(rawScoreJson);
@@ -895,25 +1082,27 @@ namespace Hyper.Internal.Managers
 
                 if (string.IsNullOrEmpty(encryptedData))
                 {
-                    HyperDebug.LogError("Encryption failed");
+                    int lastScore = scoreData != null ? scoreData.cumulativeScore : -1;
+                    HyperDebug.LogError($"[Score] Encryption failed for per-second submission. CumulativeScore={lastScore} [ErrorType=EncryptionError]");
                     return;
                 }
 
                 var message = new WebSocketScoreMessage(_cachedSessionId, _csrfToken, encryptedData);
                 string json = JsonConvert.SerializeObject(message);
+                int csrfLength = string.IsNullOrEmpty(_csrfToken) ? 0 : _csrfToken.Length;
+                int cumulativeScore = scoreData != null ? scoreData.cumulativeScore : -1;
+                HyperDebug.Log($"[Score] Sending per-second score. CumulativeScore={cumulativeScore}, BatchSize={scores.Count}, SessionId={_cachedSessionId}, CsrfLength={csrfLength}");
                 SendWebSocketMessage(json);
-
-#if UNITY_EDITOR
-                _lastScoreData = _lastSentBatch.Last();
-                _lastSentBatch.Clear();
-#endif
             }
             catch (Exception ex)
             {
-                HyperDebug.LogError($"Failed to send scores via WebSocket: {ex.Message}");
+                int lastScore = scores[scores.Count - 1].cumulativeScore;
+                HyperDebug.LogError($"[Score] Failed to send scores via WebSocket. LastBatchCumulativeScore={lastScore} [ErrorType=NetworkError, Exception={ex.Message}]");
             }
             finally
             {
+                if (_dataManager == null) _dataManager = HyperRuntime.DataManager;
+                _dataManager?.ReturnScoreDataToPool(scores);
                 scores?.Clear();
             }
         }