app.hypergames.hypersdk 1.8.9 → 1.8.11

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.8.11](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.10...v1.8.11) (2026-04-30)
+
+
+### Bug Fixes
+
+* normalize score ordering and prevent duplicate final score delta ([ad47380](https://github.com/mvmhyper/hyper-sdk/commit/ad47380e7af6d3c6323a53732bc56d2c0fd545fa))
+
+## [1.8.10](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.9...v1.8.10) (2026-04-22)
+
+
+### Bug Fixes
+
+* hold score batches until startGame ack ([bf49863](https://github.com/mvmhyper/hyper-sdk/commit/bf498637b2c7a14e9d8eba5f62345fc97b59d6aa))
+
 ## [1.8.9](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.8...v1.8.9) (2026-04-17)
 
 

package/HyperLoader.unity

@@ -840,7 +840,7 @@ GameObject:
   m_Component:
   - component: {fileID: 1064166296}
   m_Layer: 0
-  m_Name: __HyperSDK_BuildMarker_639114648052637778
+  m_Name: __HyperSDK_BuildMarker_639122897878079609
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0

package/Runtime/Internal/Managers/BackendManager.cs

@@ -294,6 +294,9 @@ namespace Hyper.Internal.Managers
         private Coroutine _sendGameResumedCoroutine;
         private bool _gameStarted;
         private bool _gameResumed;
+        private bool _canFlushScoresAfterGameStartAck;
+        private bool _hasLoggedWaitingForGameStartAck;
+        private bool _hasLoggedFirstFlushAfterGameStartAck;
         private bool _isManuallyClosed;
         private bool _isSocketErrorCalled;
 
@@ -361,6 +364,10 @@ namespace Hyper.Internal.Managers
 
         public void SendGameStarted()
         {
+            _canFlushScoresAfterGameStartAck = false;
+            _hasLoggedWaitingForGameStartAck = false;
+            _hasLoggedFirstFlushAfterGameStartAck = false;
+
             if (_sendGameStartedCoroutine == null)
             {
                 _sendGameStartedCoroutine = StartCoroutine(SendGameStartedCoroutine());
@@ -583,7 +590,14 @@ namespace Hyper.Internal.Managers
             {
                 _gameManager?.ShowConnectionRestored();
 
-                if (!_gameManager.IsPaused)
+                // If gameplay started locally but backend never acknowledged startGame,
+                // reconnect must bootstrap the backend session with startGame first.
+                if (!_gameStarted)
+                {
+                    HyperDebug.Log("[Reconnect] Game has started locally but startGame ack not received yet. Sending startGame on reconnect.");
+                    SendGameStarted();
+                }
+                else if (!_gameManager.IsPaused)
                 {
                     SendGameResumed();
                 }
@@ -633,6 +647,8 @@ namespace Hyper.Internal.Managers
         public void OnSocketGameStarted(string message)
         {
             _gameStarted = true;
+            _canFlushScoresAfterGameStartAck = true;
+            _hasLoggedWaitingForGameStartAck = false;
 
             if (_sendGameStartedCoroutine != null)
             {
@@ -642,6 +658,8 @@ namespace Hyper.Internal.Managers
 
             HyperDebug.Log("[WebSocket] Received gameStarted event from server.");
             TryUpdateCSRFToken(message, "gameStarted");
+            int pendingCount = _dataManager?.PendingScores?.Count ?? 0;
+            HyperDebug.Log($"[Score] gameStarted acknowledged by backend. Score flush gate opened. PendingCount={pendingCount}");
         }
 
         public void OnSocketGameResumed(string message)
@@ -649,6 +667,14 @@ namespace Hyper.Internal.Managers
             _gameResumed = true;
             HyperDebug.Log("[WebSocket] Received gameResumed event from server.");
 
+            if (!_canFlushScoresAfterGameStartAck)
+            {
+                _canFlushScoresAfterGameStartAck = true;
+                _hasLoggedWaitingForGameStartAck = false;
+                int pendingCount = _dataManager?.PendingScores?.Count ?? 0;
+                HyperDebug.Log($"[Score] gameResumed acknowledged before gameStarted ack. Opening score flush gate. PendingCount={pendingCount}");
+            }
+
             TryUpdateCSRFToken(message, "gameResumed");
             ResumeScoreSending();
         }
@@ -902,24 +928,6 @@ namespace Hyper.Internal.Managers
                     yield break;
                 }
 
-                var finalScoreData = _dataManager?.CurrentScoreData;
-                finalScoreData.isFinal = true;
-
-                // For consistency with per-second and backlog submissions, always send
-                // the final score as an array of ScoreData.
-                var finalScoreList = new List<ScoreData>(1) { finalScoreData };
-                string rawScoreJson = JsonConvert.SerializeObject(finalScoreList);
-                var compressedScoreData = JsonCompressor.CompressJson(rawScoreJson);
-                string scoreJson = compressedScoreData.MinifiedJson;
-                string encryptedScoreData = EncryptScore(scoreJson);
-
-                if (string.IsNullOrEmpty(encryptedScoreData))
-                {
-                    LastSubmissionError = SubmissionErrorType.EncryptionError;
-                    HyperDebug.LogError("Encryption failed [ENCRYPTION_ERROR]");
-                    yield break;
-                }
-
                 // Reset gameResumed flag for this attempt
                 _gameResumed = false;
 
@@ -1016,6 +1024,39 @@ 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();
+                }
+
+                // For consistency with per-second and backlog submissions, always send
+                // the final score as an array of ScoreData.
+                var finalScoreList = new List<ScoreData>(1) { finalScoreData };
+                string rawScoreJson = JsonConvert.SerializeObject(finalScoreList);
+                var compressedScoreData = JsonCompressor.CompressJson(rawScoreJson);
+                string scoreJson = compressedScoreData.MinifiedJson;
+                string encryptedScoreData = EncryptScore(scoreJson);
+
+                if (string.IsNullOrEmpty(encryptedScoreData))
+                {
+                    LastSubmissionError = SubmissionErrorType.EncryptionError;
+                    HyperDebug.LogError("Encryption failed [ENCRYPTION_ERROR]");
+                    yield break;
+                }
+
                 _lastSentBatch.Clear();
                 if (finalScoreData != null)
                 {
@@ -1173,8 +1214,25 @@ 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;
+                    continue;
+                }
+
+                if (!_canFlushScoresAfterGameStartAck)
+                {
+                    int pendingCount = _dataManager?.PendingScores?.Count ?? 0;
+                    if (!_hasLoggedWaitingForGameStartAck)
+                    {
+                        HyperDebug.LogWarning($"[Score] Waiting for gameStarted acknowledgement before flushing score batches. PendingCount={pendingCount}");
+                        _hasLoggedWaitingForGameStartAck = true;
+                    }
+
                     _isWaitingForTokenLogEmitted = false;
                     yield return _scoreSendInterval;
                     continue;
@@ -1211,6 +1269,11 @@ namespace Hyper.Internal.Managers
                     scoresToSend.AddRange(_dataManager?.PendingScores);
                     _dataManager?.PendingScores.Clear();
                     int count = scoresToSend.Count;
+                    if (!_hasLoggedFirstFlushAfterGameStartAck)
+                    {
+                        HyperDebug.Log($"[Score] First score flush after gameStarted acknowledgement. BatchSize={count}");
+                        _hasLoggedFirstFlushAfterGameStartAck = true;
+                    }
                     HyperDebug.Log($"[Score] Preparing to send {count} score sample(s) over WebSocket. LastPendingCumulativeScore={scoresToSend[count - 1].cumulativeScore}");
 
                     // Send the entire batch as an array payload.

package/Runtime/Internal/Managers/DataManager.cs

@@ -66,7 +66,7 @@ namespace Hyper.Internal.Managers
 
             CurrentScoreData.cumulativeScore = CurrentScore;
             CurrentScoreData.timestampUtc = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
-            CurrentScoreData.isFinal = true;
+            CurrentScoreData.isFinal = false;
 
             var snapshot = CurrentScoreData.scoreSnapshot;
             snapshot.scoreTime = currentGameSecond;

package/Runtime/Internal/UI/Modals/StartingInstructionModal.cs

@@ -283,12 +283,13 @@ namespace Hyper.Internal
             _dataManager.UpdateScore(0);
             HyperRuntime.Timer.StartActiveGameTimer();
 
-            // Only proceed if connected
+            _dataManager.StartCapturingScores(); // Start capture/sender immediately so offline starts still buffer score samples.
+            _backendManager.StartSendingScores(); // Sender loop already pauses actual submissions while disconnected or token-gated.
+
+            // startGame handshake can only be emitted when socket is connected.
             if (_backendManager.isSocketConnected)
             {
                 _backendManager.SendGameStarted();
-                _dataManager.StartCapturingScores();
-                _backendManager.StartSendingScores();
             }
 
 #if UNITY_WEBGL && !UNITY_EDITOR

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "app.hypergames.hypersdk",
-  "version": "1.8.9",
+  "version": "1.8.11",
   "displayName": "HyperSDK",
   "description": "Official Unity SDK for Hyper: multiplayer battles, leaderboards, deterministic RNG, session management, tutorials, and WebGL optimizations for production-ready games.",
   "unity": "6000.0",