app.hypergames.hypersdk 1.4.22 → 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; } = 7;
+        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
@@ -350,7 +365,7 @@ 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;
             }
@@ -358,7 +373,7 @@ namespace Hyper.Internal.Managers
             // Don't send if socket is not connected - prevents wasting retry attempts
             if (!isSocketConnected)
             {
-                HyperDebug.LogWarning("Cannot send gameResumed: WebSocket not connected");
+                HyperDebug.LogWarning("[ResumeGame] Cannot send gameResumed: WebSocket not connected");
                 _sendGameResumedCoroutine = null;
                 yield break;
             }
@@ -382,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;
@@ -398,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);
@@ -463,6 +483,13 @@ 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;
@@ -518,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();
         }
 
@@ -538,21 +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 (_isWaitingForFinalScoreResponse)
             {
+                HyperDebug.Log("[Score] Final score response received from server.");
                 _finalScoreSubmitted = true;
                 _isWaitingForFinalScoreResponse = false;
                 return;
             }
 
-            TryUpdateCSRFToken(message);
+            TryUpdateCSRFToken(message, "scoreUpdated");
         }
 
-        private void TryUpdateCSRFToken(string json)
+        private void TryUpdateCSRFToken(string json, string context = null)
         {
             try
             {
@@ -560,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}");
             }
         }
 
@@ -683,16 +720,60 @@ namespace Hyper.Internal.Managers
         {
             _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;
 
@@ -703,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
@@ -723,7 +806,24 @@ 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);
+
+                    if (_currentRetryCount < MAX_RETRY_COUNT)
+                    {
+                        yield return new WaitForSecondsRealtime(1f);
+                    }
+                    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);
 
@@ -731,13 +831,19 @@ namespace Hyper.Internal.Managers
                     {
                         yield return new WaitForSecondsRealtime(1f);
                     }
+
                     continue;
                 }
 
                 // Sending final score via WebSocket
                 _finalScoreSubmitted = false;
                 _isWaitingForFinalScoreResponse = true;
-                _lastSentBatch = new List<ScoreData> { finalScoreData };
+
+                _lastSentBatch.Clear();
+                if (finalScoreData != null)
+                {
+                    _lastSentBatch.Add(finalScoreData);
+                }
 
                 bool sendFailed = false;
                 try
@@ -748,7 +854,8 @@ namespace Hyper.Internal.Managers
                 }
                 catch (Exception ex)
                 {
-                    HyperDebug.LogError($"Failed to send final score via WebSocket: {ex.Message}");
+                    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;
@@ -804,6 +911,8 @@ namespace Hyper.Internal.Managers
                     // 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);
 
@@ -814,6 +923,8 @@ namespace Hyper.Internal.Managers
                 }
             }
 
+            // 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;
@@ -842,7 +953,10 @@ 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 _isWaitingForFinalScoreResponse;
@@ -872,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;
@@ -901,14 +1014,66 @@ namespace Hyper.Internal.Managers
             // and ensures we wait for reconnection to get fresh token via SendGameResumed()
             if (!isSocketConnected)
             {
-                HyperDebug.LogWarning("Cannot send scores: WebSocket not connected");
+                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);
@@ -917,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();
             }
         }

package/Runtime/Internal/Managers/DataManager.cs

@@ -44,7 +44,7 @@ namespace Hyper.Internal.Managers
         public void UpdateScore(int score)
         {
             if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
-            
+
             if (_gameManager.HasGameEnded) return;
 
             CurrentScore = score;
@@ -56,23 +56,26 @@ namespace Hyper.Internal.Managers
 
             float currentGameSecond = Mathf.Floor(currentTimestamp);
 
-            CurrentScoreData = new ScoreData
+            // Reuse a single ScoreData graph for CurrentScoreData to avoid per-call allocations
+            if (CurrentScoreData == null)
             {
-                cumulativeScore = CurrentScore,
-                timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(),
-                isFinal = true,
-                scoreSnapshot = new ScoreSnapshot
-                {
-                    scoreTime = currentGameSecond,
-                    scoreDelta = CurrentScore - _lastCapturedScore,
-                    gameplayModifiers = new GameplayModifiers
-                    {
-                        comboModifiers = ComboMultiplier,
-                        globalModifiers = GlobalMultiplier,
-                        activePowerUps = ActivePowerups.ToList()
-                    }
-                }
-            };
+                CurrentScoreData = _currentScoreDataBuffer;
+                CurrentScoreData.scoreSnapshot = _currentSnapshotBuffer;
+                CurrentScoreData.scoreSnapshot.gameplayModifiers = _currentModifiersBuffer;
+            }
+
+            CurrentScoreData.cumulativeScore = CurrentScore;
+            CurrentScoreData.timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
+            CurrentScoreData.isFinal = true;
+
+            var snapshot = CurrentScoreData.scoreSnapshot;
+            snapshot.scoreTime = currentGameSecond;
+            snapshot.scoreDelta = CurrentScore - _lastCapturedScore;
+
+            var modifiers = snapshot.gameplayModifiers;
+            modifiers.comboModifiers = ComboMultiplier;
+            modifiers.globalModifiers = GlobalMultiplier;
+            modifiers.activePowerUps = ActivePowerups;
 
             if (score > GetBestScore())
             {
@@ -130,6 +133,7 @@ namespace Hyper.Internal.Managers
         internal List<ScoreData> PendingScores { get; private set; } = new List<ScoreData>();
         internal TutorialData TutorialData { get; private set; }
         internal bool HasReferencedTutorialResources { get; private set; }
+        private const int SCORE_POOL_CAPACITY = 15;
 
         internal void ConfigurePlayerSoundSetting()
         {
@@ -152,7 +156,7 @@ namespace Hyper.Internal.Managers
         internal void StartCapturingScores()
         {
             if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
-            
+
             if (_scoreCaptureCoroutine == null)
             {
                 _scoreCaptureCoroutine = StartCoroutine(CaptureScoreEverySecond());
@@ -200,6 +204,16 @@ namespace Hyper.Internal.Managers
         private float _lastCapturedGameSecond = -1f;
         private int _lastCapturedScore = 0;
 
+        // Reusable object graph for CurrentScoreData to avoid allocations in UpdateScore()
+        private readonly ScoreData _currentScoreDataBuffer = new ScoreData();
+        private readonly ScoreSnapshot _currentSnapshotBuffer = new ScoreSnapshot();
+        private readonly GameplayModifiers _currentModifiersBuffer = new GameplayModifiers();
+
+        // Pools used for per-second score snapshots captured into PendingScores
+        private readonly Queue<ScoreData> _scoreDataPool = new Queue<ScoreData>();
+        private readonly Queue<ScoreSnapshot> _scoreSnapshotPool = new Queue<ScoreSnapshot>();
+        private readonly Queue<GameplayModifiers> _gameplayModifiersPool = new Queue<GameplayModifiers>();
+
         #endregion
 
         #region Score Capture Logic
@@ -216,23 +230,24 @@ namespace Hyper.Internal.Managers
 
                 if (currentGameSecond > _lastCapturedGameSecond)
                 {
-                    ScoreData newScore = new ScoreData
-                    {
-                        cumulativeScore = CurrentScore,
-                        timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(),
-                        isFinal = false,
-                        scoreSnapshot = new ScoreSnapshot
-                        {
-                            scoreTime = currentGameSecond,
-                            scoreDelta = CurrentScore - _lastCapturedScore,
-                            gameplayModifiers = new GameplayModifiers
-                            {
-                                comboModifiers = ComboMultiplier,
-                                globalModifiers = GlobalMultiplier,
-                                activePowerUps = ActivePowerups.ToList()
-                            }
-                        }
-                    };
+                    // Get objects from pools to avoid allocations in this hot path
+                    var newScore = GetPooledScoreData();
+                    var snapshot = GetPooledScoreSnapshot();
+                    var modifiers = GetPooledGameplayModifiers();
+
+                    newScore.cumulativeScore = CurrentScore;
+                    newScore.timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
+                    newScore.isFinal = false;
+
+                    snapshot.scoreTime = currentGameSecond;
+                    snapshot.scoreDelta = CurrentScore - _lastCapturedScore;
+
+                    modifiers.comboModifiers = ComboMultiplier;
+                    modifiers.globalModifiers = GlobalMultiplier;
+                    modifiers.activePowerUps = ActivePowerups;
+
+                    snapshot.gameplayModifiers = modifiers;
+                    newScore.scoreSnapshot = snapshot;
 
                     PendingScores.Add(newScore);
 
@@ -244,6 +259,84 @@ namespace Hyper.Internal.Managers
             }
         }
 
+        private ScoreData GetPooledScoreData()
+        {
+            return _scoreDataPool.Count > 0 ? _scoreDataPool.Dequeue() : new ScoreData();
+        }
+
+        private ScoreSnapshot GetPooledScoreSnapshot()
+        {
+            return _scoreSnapshotPool.Count > 0 ? _scoreSnapshotPool.Dequeue() : new ScoreSnapshot();
+        }
+
+        private GameplayModifiers GetPooledGameplayModifiers()
+        {
+            return _gameplayModifiersPool.Count > 0 ? _gameplayModifiersPool.Dequeue() : new GameplayModifiers();
+        }
+
+        internal void ReturnScoreDataToPool(List<ScoreData> scores)
+        {
+            if (scores == null) return;
+
+            for (int i = 0; i < scores.Count; i++)
+            {
+                ReturnScoreDataToPool(scores[i]);
+            }
+        }
+
+        private void ReturnScoreDataToPool(ScoreData data)
+        {
+            if (data == null) return;
+
+            if (data.scoreSnapshot != null)
+            {
+                ReturnScoreSnapshotToPool(data.scoreSnapshot);
+                data.scoreSnapshot = null;
+            }
+
+            data.cumulativeScore = 0;
+            data.isFinal = false;
+            data.timestampUtc = null;
+
+            if (_scoreDataPool.Count < SCORE_POOL_CAPACITY)
+            {
+                _scoreDataPool.Enqueue(data);
+            }
+        }
+
+        private void ReturnScoreSnapshotToPool(ScoreSnapshot snapshot)
+        {
+            if (snapshot == null) return;
+
+            if (snapshot.gameplayModifiers != null)
+            {
+                ReturnGameplayModifiersToPool(snapshot.gameplayModifiers);
+                snapshot.gameplayModifiers = null;
+            }
+
+            snapshot.scoreTime = 0f;
+            snapshot.scoreDelta = 0;
+
+            if (_scoreSnapshotPool.Count < SCORE_POOL_CAPACITY)
+            {
+                _scoreSnapshotPool.Enqueue(snapshot);
+            }
+        }
+
+        private void ReturnGameplayModifiersToPool(GameplayModifiers modifiers)
+        {
+            if (modifiers == null) return;
+
+            modifiers.comboModifiers = 0f;
+            modifiers.globalModifiers = 0f;
+            modifiers.activePowerUps = null;
+
+            if (_gameplayModifiersPool.Count < SCORE_POOL_CAPACITY)
+            {
+                _gameplayModifiersPool.Enqueue(modifiers);
+            }
+        }
+
         private void SetBestScore(ScoreData scoreData, string sessionId)
         {
             BestScoreWrapper bestScore = new BestScoreWrapper(scoreData, sessionId);

package/Runtime/Internal/ScriptableObjects/HyperSDKSettings.cs

@@ -38,6 +38,9 @@ namespace Hyper.Internal
         [Tooltip("Choose the start CTA overlay shown before gameplay begins. Hyper requires one of these overlays - do not add your own start buttons.")]
         public StartCTA startCTA = StartCTA.TapToPlay;
 
+        [Tooltip("If Start CTA is set to Swipe to Play, choose the swipe direction used for the visual cue.")]
+        public SwipeDirection swipeDirection = SwipeDirection.Up;
+
         #endregion
 
         #region Control Bar Settings