app.hypergames.hypersdk 1.5.10 → 1.7.0

package/Runtime/Internal/Managers/GameManager.cs

@@ -59,32 +59,14 @@ namespace Hyper.Internal.Managers
         {
             if (!IsInGameScene || _hasGameEnded || !_hasGameStarted) return;
 
-            // Automatically end the game when lives are exhausted
-            // Use appropriate method based on game mode
-            if (IsBattleMode)
-            {
-                EndBattleGame();
-            }
-            else
-            {
-                EndPracticeGame();
-            }
+            EndGame();
         }
 
         private void HandleHealthExhausted()
         {
             if (!IsInGameScene || _hasGameEnded || !_hasGameStarted) return;
 
-            // Automatically end the game when health is exhausted
-            // Use appropriate method based on game mode
-            if (IsBattleMode)
-            {
-                EndBattleGame();
-            }
-            else
-            {
-                EndPracticeGame();
-            }
+            EndGame();
         }
 
         internal void Cleanup()
@@ -107,6 +89,22 @@ namespace Hyper.Internal.Managers
         public bool HasGameStarted => _hasGameStarted;
         public bool HasGameEnded => _hasGameEnded;
 
+        internal int BattleTimeRemaining =>
+            IsBattleMode && HyperRuntime.Timer != null
+                ? HyperRuntime.Timer.BattleTimeRemaining
+                : 0;
+
+        /// <summary>
+        /// Ends the current session for whichever mode is active (practice or battle).
+        /// </summary>
+        public void EndGame()
+        {
+            if (IsBattleMode)
+                EndBattleGame();
+            else
+                EndPracticeGame();
+        }
+
         public void EndBattleGame()
         {
             if (!IsBattleMode) return;
@@ -187,7 +185,9 @@ namespace Hyper.Internal.Managers
 
         void OnApplicationFocus(bool hasFocus)
         {
+#if !UNITY_EDITOR
             HandlePauseState(!hasFocus);
+#endif
         }
 
         void HandlePauseState(bool shouldPause)
@@ -220,6 +220,14 @@ namespace Hyper.Internal.Managers
                     _eventManager.InvokeTimeScaleResumedEvent();
                     HyperDebug.Log("Time scale resumed event invoked");
 
+                    // Always restart capturing when game resumes, even if offline,
+                    // so scores accumulate for the offline batch and are flushed on reconnect.
+                    if (!_hasGameEnded && _hasGameStarted)
+                    {
+                        _dataManager.StartCapturingScores();
+                    }
+
+                    // Only resume server session if connected
                     if (_backendManager.isSocketConnected && !_hasGameEnded && _hasGameStarted)
                     {
                         _backendManager.SendGameResumed();
@@ -711,8 +719,6 @@ namespace Hyper.Internal.Managers
 
         private void OptimizeForWebGL()
         {
-            QualitySettings.streamingMipmapsActive = false;
-            QualitySettings.billboardsFaceCameraPosition = false;
             Resources.UnloadUnusedAssets();
         }
 
@@ -993,7 +999,7 @@ namespace Hyper.Internal.Managers
             _canvasScaler = _canvas.GetComponent<CanvasScaler>();
             _canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
             _canvasScaler.referenceResolution = new Vector2(1080, 1920);
-            _canvasScaler.matchWidthOrHeight = 0.5f;
+            _canvasScaler.matchWidthOrHeight = IsPortrait() ? 0.43f : 0.73f;
 
             CreateSafeArea();
             CreateBlockerUI();

package/Runtime/Internal/Managers/TimeManager.cs

@@ -68,6 +68,11 @@ namespace Hyper.Internal.Managers
             ? (int)_battleTimer
             : (int)_practiceTimer;
 
+        /// <summary>
+        /// Match countdown seconds (floored, clamped at zero). Same source as battle branch of <see cref="CurrentTime"/>.
+        /// </summary>
+        internal int BattleTimeRemaining => Mathf.Max(0, (int)_battleTimer);
+
         public int SessionTimeRemaining => (int)_sessionTimer;
 
         private GameManager _gameManager;

package/Runtime/Internal/ScriptableObjects/HyperGameContentConfig.cs

@@ -49,6 +49,14 @@ namespace Hyper.Internal
 
         #endregion
 
+        #region Custom Pre-Loading
+
+        [Header("Custom Pre-Loading")]
+        [Tooltip("Enable if your game needs to perform custom work (e.g. downloading assets, fetching remote config) after SDK initialization but before the game scene loads. When enabled, the bootstrap will pause and wait for HyperSDK.Loader.CompleteCustomLoading() to be called.")]
+        public bool EnableCustomLoading = false;
+
+        #endregion
+
         #region Game Posters & Hints
 
         [Space]

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

@@ -96,16 +96,9 @@ namespace Hyper.Internal
 
         public void ForfeitGame()
         {   
+            HyperRuntime.GameManager.EndGame();
             if (!IsPVPMode)
-            {
-                HyperRuntime.GameManager.EndPracticeGame();
                 _gameManager.LoadPracticeMenuScene();
-            }
-
-            else
-            {
-                HyperRuntime.GameManager.EndBattleGame();
-            }
         }
 
         public void ToggleSound()

package/Runtime/Plugins/WebGL/HyperCorePlugin.jslib

@@ -56,6 +56,32 @@ mergeInto(LibraryManager.library, {
         window.location.reload();
     },
 
+    HyperIsMobileUserAgent: function () {
+        var ua = navigator.userAgent || '';
+        if (/Android|iPhone|iPad|iPod|Opera Mini|IEMobile|WPDesktop|Mobile/i.test(ua)) {
+            return 1;
+        }
+        return 0;
+    },
+
+    // Large screen.* vs small inner viewport: typical of desktop Chrome DevTools device toolbar (not a guarantee).
+    HyperIsLikelyDesktopDevtoolsMobileViewport: function () {
+        try {
+            var sw = window.screen.width;
+            var sh = window.screen.height;
+            var screenLong = Math.max(sw, sh);
+            var iw = window.innerWidth;
+            var ih = window.innerHeight;
+            var innerLong = Math.max(iw, ih);
+            if (screenLong >= 1280 && innerLong <= 900 && screenLong > innerLong * 1.35) {
+                return 1;
+            }
+            return 0;
+        } catch (e) {
+            return 0;
+        }
+    },
+
     getDeviceScreenResolution: function () {
         // Get the device screen width and height
         const width = window.screen.width;

package/Runtime/Public/Core/HyperSDK.cs

@@ -15,6 +15,7 @@ namespace Hyper
         private static GameAPIAdapter _gameAdapter;
         private static DataAPIAdapter _dataAdapter;
         private static EventAPIAdapter _eventAdapter;
+        private static LoaderAPIAdapter _loaderAdapter;
 
         /// <summary>
         /// Returns true if the SDK runtime has been initialized.
@@ -89,11 +90,33 @@ namespace Hyper
             }
         }
 
+        /// <summary>
+        /// Access loader control for custom pre-loading workflows.
+        /// Use when EnableCustomLoading is enabled in HyperGameContentConfig.
+        /// </summary>
+        public static ILoaderAPI Loader
+        {
+            get
+            {
+                if (_loaderAdapter == null)
+                {
+                    _loaderAdapter = new LoaderAPIAdapter();
+                }
+                return _loaderAdapter;
+            }
+        }
+
         /// <summary>
         /// Current Hyper SDK version string.
         /// </summary>
         public static string Version => HyperSDKVersion.Version;
 
+        /// <summary>True if the player is treated as mobile (heuristic). In the Unity Editor, follows the Device Simulator when active.</summary>
+        public static bool PlayerDeviceIsMobile => PlayerDeviceClassification.PlayerDeviceIsMobile;
+
+        /// <summary>True if the player is treated as PC/desktop (opposite of <see cref="PlayerDeviceIsMobile"/>).</summary>
+        public static bool PlayerDeviceIsPC => PlayerDeviceClassification.PlayerDeviceIsPC;
+
         private static void EnsureAdaptersReady()
         {
             if (_gameAdapter == null)
@@ -121,32 +144,106 @@ namespace Hyper
     /// </summary>
     public interface IGameAPI
     {
+		/// <summary>
+		/// True when the current mode is Battle (PvP or timed battle).
+		/// </summary>
         bool IsBattleMode { get; }
+		/// <summary>
+		/// True when the current mode is Practice.
+		/// </summary>
         bool IsPracticeMode { get; }
+		/// <summary>
+		/// True if the game is currently paused by the SDK.
+		/// </summary>
         bool IsPaused { get; }
+		/// <summary>
+		/// True once gameplay has begun (post countdown/start).
+		/// </summary>
         bool HasGameStarted { get; }
+		/// <summary>
+		/// True after the current game session has ended.
+		/// </summary>
         bool HasGameEnded { get; }
 
+        /// <summary>
+        /// Seconds remaining on the PvP match clock. Zero in practice mode or when not in a timed battle.
+        /// </summary>
+        int BattleTimeRemaining { get; }
+
+        /// <summary>
+        /// Ends the current session for whichever mode is active (practice or battle).
+        /// </summary>
+        void EndGame();
+
+        [Obsolete("Use EndGame() instead; it ends practice or battle based on the current mode.")]
         void EndBattleGame();
+
+        [Obsolete("Use EndGame() instead; it ends practice or battle based on the current mode.")]
         void EndPracticeGame();
+
+		/// <summary>
+		/// Closes the practice menu and enters gameplay (only relevant when practice scene is a menu).
+		/// </summary>
         void ExitPracticeMenu();
 
         // Lives Management (only available when ControlBarLayout is HeartsLeft)
+		/// <summary>
+		/// Initialize the lives system with a maximum and optional initial value.
+		/// </summary>
         void InitializeLives(int maxLives, int initialLives = -1);
+		/// <summary>
+		/// Set the current number of lives.
+		/// </summary>
         void SetLives(int lives);
+		/// <summary>
+		/// Increment lives by one.
+		/// </summary>
         void AddLife();
+		/// <summary>
+		/// Decrement lives by one.
+		/// </summary>
         void RemoveLife();
+		/// <summary>
+		/// Get the current number of lives.
+		/// </summary>
         int GetCurrentLives();
+		/// <summary>
+		/// Get the configured maximum number of lives.
+		/// </summary>
         int GetMaxLives();
 
         // Health Management (only available when ControlBarLayout is HealthBarGreenLeft)
+		/// <summary>
+		/// Initialize the health system with a maximum and optional initial value.
+		/// </summary>
         void InitializeHealth(float maxHealth, float initialHealth = -1f, bool isNormalized = false);
+		/// <summary>
+		/// Set the current health (absolute units).
+		/// </summary>
         void SetHealth(float health);
+		/// <summary>
+		/// Set the current health as a normalized value in [0,1].
+		/// </summary>
         void SetHealthNormalized(float normalizedHealth);
+		/// <summary>
+		/// Add to the current health by an absolute amount.
+		/// </summary>
         void AddHealth(float amount);
+		/// <summary>
+		/// Remove from the current health by an absolute amount.
+		/// </summary>
         void RemoveHealth(float amount);
+		/// <summary>
+		/// Get the current health (absolute units).
+		/// </summary>
         float GetCurrentHealth();
+		/// <summary>
+		/// Get the maximum health (absolute units).
+		/// </summary>
         float GetMaxHealth();
+		/// <summary>
+		/// Get the current health normalized to [0,1].
+		/// </summary>
         float GetHealthNormalized();
     }
 
@@ -155,34 +252,119 @@ namespace Hyper
     /// </summary>
     public interface IDataAPI
     {
+		/// <summary>
+		/// Current in-session score value.
+		/// </summary>
         int CurrentScore { get; }
 
+		/// <summary>
+		/// Overwrite the current score with a new value.
+		/// </summary>
         void UpdateScore(int score);
+		/// <summary>
+		/// Set the combo multiplier applied to scoring.
+		/// </summary>
         void SetComboMultiplier(float value);
+		/// <summary>
+		/// Set a global multiplier applied to scoring.
+		/// </summary>
         void SetGlobalMultiplier(float value);
+		/// <summary>
+		/// Register that a powerup is active by type identifier.
+		/// </summary>
         void AddPowerup(string powerupType);
+		/// <summary>
+		/// Remove an active powerup by type identifier.
+		/// </summary>
         void RemovePowerup(string powerupType);
+		/// <summary>
+		/// Retrieve the best/high score recorded for the player.
+		/// </summary>
         int GetBestScore();
     }
 
+    /// <summary>
+    /// Public API for custom pre-loading control during the HyperLoader bootstrap.
+    /// </summary>
+    public interface ILoaderAPI
+    {
+        /// <summary>
+        /// Report progress of your custom loading (0.0 to 1.0).
+        /// This feeds into the loading bar so players see smooth progress during your custom work.
+        /// Optional — if not called, the loader will simulate progress automatically.
+        /// </summary>
+        void ReportCustomLoadingProgress(float progress);
+
+        /// <summary>
+        /// Signal that your custom pre-loading is complete.
+        /// The HyperLoader bootstrap will resume and load the game scene.
+        /// Must be called when EnableCustomLoading is true in HyperGameContentConfig.
+        /// </summary>
+        void CompleteCustomLoading();
+    }
+
     /// <summary>
     /// Public API for SDK events.
     /// </summary>
     public interface IEventAPI
     {
+		/// <summary>
+		/// Fired when gameplay begins.
+		/// </summary>
         event Action OnGameStart;
+		/// <summary>
+		/// Fired when the match timer reaches zero (battle mode).
+		/// </summary>
         event Action OnTimeUp;
+		/// <summary>
+		/// Fired when the game is paused by the SDK.
+		/// </summary>
         event Action OnGamePaused;
+		/// <summary>
+		/// Fired when the game resumes from a paused state.
+		/// </summary>
         event Action OnGameResumed;
+		/// <summary>
+		/// Fired when the current game session ends.
+		/// </summary>
         event Action OnGameEnded;
+		/// <summary>
+		/// Fired when the SDK sound setting changes (true = enabled).
+		/// </summary>
         event Action<bool> OnSoundChanged;
+		/// <summary>
+		/// Fired when lives reach zero (when lives UI is in use).
+		/// </summary>
         event Action OnLivesExhausted;
+		/// <summary>
+		/// Fired when health reaches zero (when health UI is in use).
+		/// </summary>
         event Action OnHealthExhausted;
+		/// <summary>
+		/// Fired when a custom restart flow is requested by the SDK.
+		/// </summary>
         event Action OnCustomRestart;
     }
 
     #region Adapter Implementations
 
+    /// <summary>
+    /// Bridges the public loader API to the internal HyperRuntime custom loading state.
+    /// </summary>
+    internal sealed class LoaderAPIAdapter : ILoaderAPI
+    {
+        public void ReportCustomLoadingProgress(float progress)
+        {
+            HyperRuntime.CustomLoadingProgress = Mathf.Clamp01(progress);
+        }
+
+        public void CompleteCustomLoading()
+        {
+            HyperRuntime.CustomLoadingComplete = true;
+            HyperDebug.Log("Custom pre-loading complete. Bootstrap resuming");
+        }
+    }
+
     /// <summary>
     /// Bridges the public game API to the internal GameManager without exposing it to consumers.
     /// </summary>
@@ -196,8 +378,17 @@ namespace Hyper
         public bool HasGameStarted => Manager != null && Manager.HasGameStarted;
         public bool HasGameEnded => Manager != null && Manager.HasGameEnded;
 
+        public int BattleTimeRemaining => Manager?.BattleTimeRemaining ?? 0;
+
+        /// <inheritdoc/>
+        public void EndGame() => Manager?.EndGame();
+
+        [Obsolete("Use EndGame() instead; it ends practice or battle based on the current mode.")]
         public void EndBattleGame() => Manager?.EndBattleGame();
+
+        [Obsolete("Use EndGame() instead; it ends practice or battle based on the current mode.")]
         public void EndPracticeGame() => Manager?.EndPracticeGame();
+
         public void ExitPracticeMenu() => Manager?.ExitPracticeMenu();
 
         public void InitializeLives(int maxLives, int initialLives = -1) => Manager?.InitializeLives(maxLives, initialLives);

package/Runtime/Public/PlayerDeviceClassification.cs

@@ -0,0 +1,41 @@
+using System.Runtime.InteropServices;
+using Hyper.Shared;
+using UnityEngine;
+
+namespace Hyper
+{
+    internal static class PlayerDeviceClassification
+    {
+        internal static bool PlayerDeviceIsMobile => Resolve() == DevicePlatform.Mobile;
+
+        internal static bool PlayerDeviceIsPC => !PlayerDeviceIsMobile;
+
+        private static DevicePlatform Resolve()
+        {
+#if UNITY_EDITOR
+            // Unity Device Simulator: Device.Application matches the simulated device; Application does not.
+            return UnityEngine.Device.Application.isMobilePlatform ? DevicePlatform.Mobile : DevicePlatform.PC;
+#elif UNITY_WEBGL && !UNITY_EDITOR
+            if (HyperIsLikelyDesktopDevtoolsMobileViewport() != 0)
+                return DevicePlatform.PC;
+            if (Application.isMobilePlatform || HyperIsMobileUserAgent() != 0)
+                return DevicePlatform.Mobile;
+            return DevicePlatform.PC;
+#else
+            return Application.isMobilePlatform ? DevicePlatform.Mobile : DevicePlatform.PC;
+#endif
+        }
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern int HyperIsMobileUserAgent();
+
+        [DllImport("__Internal")]
+        private static extern int HyperIsLikelyDesktopDevtoolsMobileViewport();
+#else
+        private static int HyperIsMobileUserAgent() => 0;
+
+        private static int HyperIsLikelyDesktopDevtoolsMobileViewport() => 0;
+#endif
+    }
+}

package/Runtime/Public/PlayerDeviceClassification.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6462d3b83a3aab741899fa52596c2263

package/Runtime/Resources/HyperGameContentConfig.asset

@@ -25,4 +25,5 @@ MonoBehaviour:
     sceneGUID: 
     scenePath: 
     sceneName: 
+  EnableCustomLoading: 0
   gamePosterSprite: {fileID: 0}

package/Runtime/Resources/UIPrefabs/GamePausedModal_Battle.prefab

@@ -1526,7 +1526,7 @@ RectTransform:
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
   m_AnchoredPosition: {x: 242.0348, y: -33.43245}
-  m_SizeDelta: {x: 342.7, y: 46.0515}
+  m_SizeDelta: {x: 0, y: 46.0515}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!222 &8480469813127575513
 CanvasRenderer:

package/Runtime/Resources/UIPrefabs/ScoreSubmissionFailedModal_Landscape.prefab

@@ -28,7 +28,7 @@ RectTransform:
   m_GameObject: {fileID: 858581963775131442}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
   m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_LocalScale: {x: 0.82, y: 0.82, z: 0.82}
   m_ConstrainProportionsScale: 1
   m_Children:
   - {fileID: 3260987079844009583}
@@ -40,7 +40,7 @@ RectTransform:
   m_AnchorMin: {x: 0.5, y: 0.5}
   m_AnchorMax: {x: 0.5, y: 0.5}
   m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 890.68, y: 921.8411}
+  m_SizeDelta: {x: 890.68, y: 854.7493}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!222 &5855589522202011792
 CanvasRenderer:
@@ -130,9 +130,9 @@ RectTransform:
   m_Children: []
   m_Father: {fileID: 1314863699767144124}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0.5, y: 1}
-  m_AnchorMax: {x: 0.5, y: 1}
-  m_AnchoredPosition: {x: 0.0000076293945, y: -354}
+  m_AnchorMin: {x: 0.5, y: 0.6192544}
+  m_AnchorMax: {x: 0.5, y: 0.6192544}
+  m_AnchoredPosition: {x: 0.0000076293945, y: -3}
   m_SizeDelta: {x: 766, y: 150.8242}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!222 &4673185574738174376
@@ -267,10 +267,10 @@ RectTransform:
   - {fileID: 8757155083608065361}
   m_Father: {fileID: 1314863699767144124}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0.5, y: 1}
-  m_AnchorMax: {x: 0.5, y: 1}
-  m_AnchoredPosition: {x: 0, y: -818}
-  m_SizeDelta: {x: 766, y: 138.0001}
+  m_AnchorMin: {x: 0.5, y: 0}
+  m_AnchorMax: {x: 0.5, y: 0}
+  m_AnchoredPosition: {x: 0, y: 104}
+  m_SizeDelta: {x: 766, y: 138.00012}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!225 &60913365496353251
 CanvasGroup:
@@ -316,9 +316,9 @@ RectTransform:
   m_Children: []
   m_Father: {fileID: 1314863699767144124}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 1}
-  m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 445.34, y: -144.2}
+  m_AnchorMin: {x: 0.5, y: 1}
+  m_AnchorMax: {x: 0.5, y: 1}
+  m_AnchoredPosition: {x: 0.33999634, y: -144.2}
   m_SizeDelta: {x: 180, y: 180}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!222 &1807166882388356321
@@ -871,7 +871,7 @@ PrefabInstance:
       objectReference: {fileID: 0}
     - target: {fileID: 6466996468591858475, guid: 6a53542e1517b294097a062f761d422c, type: 3}
       propertyPath: m_AnchorMax.y
-      value: 0.5
+      value: 0.3654065
       objectReference: {fileID: 0}
     - target: {fileID: 6466996468591858475, guid: 6a53542e1517b294097a062f761d422c, type: 3}
       propertyPath: m_AnchorMin.x
@@ -879,7 +879,7 @@ PrefabInstance:
       objectReference: {fileID: 0}
     - target: {fileID: 6466996468591858475, guid: 6a53542e1517b294097a062f761d422c, type: 3}
       propertyPath: m_AnchorMin.y
-      value: 0.5
+      value: 0.3654065
       objectReference: {fileID: 0}
     - target: {fileID: 6466996468591858475, guid: 6a53542e1517b294097a062f761d422c, type: 3}
       propertyPath: m_SizeDelta.x
@@ -919,11 +919,11 @@ PrefabInstance:
       objectReference: {fileID: 0}
     - target: {fileID: 6466996468591858475, guid: 6a53542e1517b294097a062f761d422c, type: 3}
       propertyPath: m_AnchoredPosition.x
-      value: 0.0000000029685907
+      value: 0
       objectReference: {fileID: 0}
     - target: {fileID: 6466996468591858475, guid: 6a53542e1517b294097a062f761d422c, type: 3}
       propertyPath: m_AnchoredPosition.y
-      value: -122
+      value: 2
       objectReference: {fileID: 0}
     - target: {fileID: 6466996468591858475, guid: 6a53542e1517b294097a062f761d422c, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x