app.hypergames.hypersdk 1.3.4 → 1.4.1

package/HyperLoader.unity

@@ -304,7 +304,7 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 489.20746, y: -280.1698}
+  m_AnchoredPosition: {x: 509.1169, y: -280.1698}
   m_SizeDelta: {x: 1044.9, y: 239.347}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &751153944
@@ -461,7 +461,6 @@ GameObject:
   m_Component:
   - component: {fileID: 894728866}
   - component: {fileID: 894728865}
-  - component: {fileID: 894728867}
   m_Layer: 0
   m_Name: Main Camera
   m_TagString: MainCamera
@@ -513,8 +512,8 @@ Camera:
   m_TargetTexture: {fileID: 0}
   m_TargetDisplay: 0
   m_TargetEye: 3
-  m_HDR: 1
-  m_AllowMSAA: 1
+  m_HDR: 0
+  m_AllowMSAA: 0
   m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
@@ -536,50 +535,6 @@ Transform:
   - {fileID: 1064166296}
   m_Father: {fileID: 446519529}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &894728867
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 894728863}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: a79441f348de89743a2939f4d699eac1, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  m_RenderShadows: 1
-  m_RequiresDepthTextureOption: 2
-  m_RequiresOpaqueTextureOption: 2
-  m_CameraType: 0
-  m_Cameras: []
-  m_RendererIndex: -1
-  m_VolumeLayerMask:
-    serializedVersion: 2
-    m_Bits: 1
-  m_VolumeTrigger: {fileID: 0}
-  m_VolumeFrameworkUpdateModeOption: 2
-  m_RenderPostProcessing: 0
-  m_Antialiasing: 0
-  m_AntialiasingQuality: 2
-  m_StopNaN: 0
-  m_Dithering: 0
-  m_ClearDepth: 1
-  m_AllowXRRendering: 1
-  m_AllowHDROutput: 1
-  m_UseScreenCoordOverride: 0
-  m_ScreenSizeOverride: {x: 0, y: 0, z: 0, w: 0}
-  m_ScreenCoordScaleBias: {x: 0, y: 0, z: 0, w: 0}
-  m_RequiresDepthTexture: 0
-  m_RequiresColorTexture: 0
-  m_Version: 2
-  m_TaaSettings:
-    m_Quality: 3
-    m_FrameInfluence: 0.1
-    m_JitterScale: 1
-    m_MipBias: 0
-    m_VarianceClampScale: 0.9
-    m_ContrastAdaptiveSharpening: 0
 --- !u!1 &928973802
 GameObject:
   m_ObjectHideFlags: 0
@@ -1137,7 +1092,7 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 489.20746, y: -133.2274}
+  m_AnchoredPosition: {x: 509.1169, y: -133.2274}
   m_SizeDelta: {x: 875, y: 54.5378}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!1 &2874543288936963705

package/Runtime/Internal/AssemblyInfo.cs

@@ -1,5 +1,5 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("Hyper")]
-[assembly: InternalsVisibleTo("HyperSDK.Editor")]
+[assembly: InternalsVisibleTo("Hyper.Editor")]
 

package/Runtime/Internal/Managers/EventManager.cs

@@ -27,6 +27,8 @@ namespace Hyper.Internal.Managers
         public event Action OnTimeUp;
         public event Action OnGameStart;
         public event Action OnGameEnded;
+        public event Action OnLivesExhausted;
+        public event Action OnHealthExhausted;
 
         #endregion
 
@@ -56,6 +58,8 @@ namespace Hyper.Internal.Managers
         internal void InvokeStartDeadlineReachedEvent() => OnStartDeadlineReached?.Invoke();
         internal void InvokeGameStartEvent() => OnGameStart?.Invoke();
         internal void InvokeGameEndedEvent() => OnGameEnded?.Invoke();
+        internal void InvokeLivesExhaustedEvent() => OnLivesExhausted?.Invoke();
+        internal void InvokeHealthExhaustedEvent() => OnHealthExhausted?.Invoke();
         internal void InvokeConnectionLostEvent() => OnInternetConnectionLost?.Invoke();
         internal void InvokeConnectionFoundEvent() => OnInternetConnectionFound?.Invoke();
         internal void InvokeTutorialLoadingCompleteEvent() => OnTutorialLoadingComplete?.Invoke();

package/Runtime/Internal/Managers/GameManager.cs

@@ -42,6 +42,47 @@ namespace Hyper.Internal.Managers
             }
 
             _isPortrait = Screen.height > Screen.width;
+            SubscribeToLivesEvents();
+        }
+
+        private void SubscribeToLivesEvents()
+        {
+            // Default behavior: automatically end game when lives are exhausted
+            // Developers can still subscribe to OnLivesExhausted for custom behavior
+            _eventManager.OnLivesExhausted += HandleLivesExhausted;
+            _eventManager.OnHealthExhausted += HandleHealthExhausted;
+        }
+
+        private void HandleLivesExhausted()
+        {
+            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();
+            }
+        }
+
+        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();
+            }
         }
 
         internal void Cleanup()
@@ -86,14 +127,14 @@ namespace Hyper.Internal.Managers
             {
                 ShowGameOverModal();
             }
-            
+
             _eventManager.InvokeGameEndedEvent();
         }
 
         public void ExitPracticeMenu()
         {
             if (!IsBattleMode)
-                HyperRuntime.BackendManager.LogEvent(ConsoleEventType.PracticeGameEnd);
+                ShowExitGameMenuModal();
         }
 
         #endregion
@@ -107,6 +148,7 @@ namespace Hyper.Internal.Managers
 
         internal ControlBarTheme ControlBarTheme { get; private set; }
         internal ControlBarLayout ControlBarLayout { get; private set; }
+        internal StartCTA StartCTA { get; private set; }
 
         internal void PauseGame()
         {
@@ -144,6 +186,90 @@ namespace Hyper.Internal.Managers
             _controlBarModal?.UpdateScoreLabel();
         }
 
+        internal void InitializeLives(int maxLives, int initialLives = -1)
+        {
+            var livesDisplay = _controlBarModal?.GetLivesDisplay();
+            livesDisplay?.Initialize(maxLives, initialLives);
+        }
+
+        internal void SetLives(int lives)
+        {
+            var livesDisplay = _controlBarModal?.GetLivesDisplay();
+            livesDisplay?.SetLives(lives);
+        }
+
+        internal void AddLife()
+        {
+            var livesDisplay = _controlBarModal?.GetLivesDisplay();
+            livesDisplay?.AddLife();
+        }
+
+        internal void RemoveLife()
+        {
+            var livesDisplay = _controlBarModal?.GetLivesDisplay();
+            livesDisplay?.RemoveLife();
+        }
+
+        internal int GetCurrentLives()
+        {
+            var livesDisplay = _controlBarModal?.GetLivesDisplay();
+            return livesDisplay?.GetCurrentLives() ?? 0;
+        }
+
+        internal int GetMaxLives()
+        {
+            var livesDisplay = _controlBarModal?.GetLivesDisplay();
+            return livesDisplay?.GetMaxLives() ?? 0;
+        }
+
+        internal void InitializeHealth(float maxHealth, float initialHealth = -1f, bool isNormalized = false)
+        {
+            var healthBarDisplay = _controlBarModal?.GetHealthBarDisplay();
+            healthBarDisplay?.Initialize(maxHealth, initialHealth, isNormalized);
+        }
+
+        internal void SetHealth(float health)
+        {
+            var healthBarDisplay = _controlBarModal?.GetHealthBarDisplay();
+            healthBarDisplay?.SetHealth(health);
+        }
+
+        internal void SetHealthNormalized(float normalizedHealth)
+        {
+            var healthBarDisplay = _controlBarModal?.GetHealthBarDisplay();
+            healthBarDisplay?.SetHealthNormalized(normalizedHealth);
+        }
+
+        internal void AddHealth(float amount)
+        {
+            var healthBarDisplay = _controlBarModal?.GetHealthBarDisplay();
+            healthBarDisplay?.AddHealth(amount);
+        }
+
+        internal void RemoveHealth(float amount)
+        {
+            var healthBarDisplay = _controlBarModal?.GetHealthBarDisplay();
+            healthBarDisplay?.RemoveHealth(amount);
+        }
+
+        internal float GetCurrentHealth()
+        {
+            var healthBarDisplay = _controlBarModal?.GetHealthBarDisplay();
+            return healthBarDisplay?.GetCurrentHealth() ?? 0f;
+        }
+
+        internal float GetMaxHealth()
+        {
+            var healthBarDisplay = _controlBarModal?.GetHealthBarDisplay();
+            return healthBarDisplay?.GetMaxHealth() ?? 0f;
+        }
+
+        internal float GetHealthNormalized()
+        {
+            var healthBarDisplay = _controlBarModal?.GetHealthBarDisplay();
+            return healthBarDisplay?.GetHealthNormalized() ?? 0f;
+        }
+
         internal void ShowConnectionLost()
         {
             if (!IsInGameScene) return;
@@ -282,6 +408,16 @@ namespace Hyper.Internal.Managers
             }
         }
 
+        internal void ShowExitGameMenuModal()
+        {
+            if (IsInGameScene) return;
+
+            EnsureExitGameMenuModal();
+            _exitGameMenuModal.SetActive(true);
+
+            SetBlockerActive(true);
+        }
+
         internal void ShowGameOverModal()
         {
             if (IsBattleMode)
@@ -319,7 +455,7 @@ namespace Hyper.Internal.Managers
         internal void LoadPracticeMenuScene()
         {
             if (!HyperRuntime.GameContent.IsPracticeMenu) return;
-            
+
             if (HyperRuntime.GameContent.HasTransitionScene)
             {
                 StartCoroutine(PracticeMenuLoadingCoroutine());
@@ -389,8 +525,9 @@ namespace Hyper.Internal.Managers
 
         private void LoadConfiguration()
         {
-            ControlBarLayout = HyperRuntime.Settings.topBarLayout;
-            ControlBarTheme = HyperRuntime.Settings.topBarTheme;
+            ControlBarLayout = HyperRuntime.Settings.controlBarLayout;
+            ControlBarTheme = HyperRuntime.Settings.controlBarTheme;
+            StartCTA = HyperRuntime.Settings.startCTA;
         }
 
 #if UNITY_WEBGL && !UNITY_EDITOR
@@ -757,6 +894,7 @@ namespace Hyper.Internal.Managers
         private GameObject _startGameDeadlineStatusBar;
         private GameObject _loadingFailedModal;
         private GameObject _sessionTimeOutModal;
+        private GameObject _exitGameMenuModal;
         private GameObject _scoreSubmissionFailedModalPortrait;
         private GameObject _scoreSubmissionFailedModalLandscape;
         private GameObject _retryTimeExpiredModalPortrait;
@@ -990,6 +1128,30 @@ namespace Hyper.Internal.Managers
             _sessionTimeOutModal = InstantiateModal(prefab);
         }
 
+        private void EnsureExitGameMenuModal()
+        {
+            if (_exitGameMenuModal != null)
+            {
+                _exitGameMenuModal.SetActive(true);
+                return;
+            }
+
+            if (_canvas == null) CreateCanvas();
+
+            GameObject prefab = Resources.Load<GameObject>("UIPrefabs/ExitGameMenuModal");
+            _exitGameMenuModal = InstantiateModal(prefab);
+        }
+
+        internal void HideExitGameMenuModal()
+        {
+            if (_exitGameMenuModal != null && _exitGameMenuModal.activeInHierarchy)
+            {
+                _exitGameMenuModal.SetActive(false);
+            }
+            
+            SetBlockerActive(false);
+        }
+
         private void EnsureScoreSubmissionFailedModal(bool portrait)
         {
             if (portrait && _scoreSubmissionFailedModalPortrait != null)
@@ -1268,6 +1430,12 @@ namespace Hyper.Internal.Managers
 
             _startingInstructionModal = instance;
             _startingInstructionModalComponent = instance.GetComponent<StartingInstructionModal>();
+
+            // Configure the CTA text based on settings
+            if (_startingInstructionModalComponent != null)
+            {
+                _startingInstructionModalComponent.Configure(StartCTA);
+            }
         }
 
         private void HideStartingInstructionModal()

package/Runtime/Internal/ScriptableObjects/HyperSDKSettings.cs

@@ -31,24 +31,30 @@ namespace Hyper.Internal
 
         #endregion
 
-        #region Control Bar Configuration
+        #region Start CTA
 
-        // [Space(20)]
-        // [Header("Top Bar Configurations")]
-        // [Tooltip("Select the color theme (light or dark) for the top bar.")]
-        [HideInInspector] 
-        public ControlBarTheme topBarTheme = ControlBarTheme.Dark;
+        [Space(20)]
+        [Header("Start CTA Overlay")]
+        [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;
+
+        #endregion
+
+        #region Control Bar Settings
+
+        [Space(20)]
+        [Header("Control Bar Settings")]
+        [Tooltip("Select the layout type for the in-game control bar.")]
+        public ControlBarLayout controlBarLayout = ControlBarLayout.Default;
 
         // [Space(5)]
-        // [Tooltip("Select the layout type for the in-game top bar.")]
+        // [Tooltip("Select the color theme (light or dark) for the control bar.")]
         [HideInInspector] 
-        public ControlBarLayout topBarLayout = ControlBarLayout.Default;
+        public ControlBarTheme controlBarTheme = ControlBarTheme.Dark;
 
         #endregion
 
         #region Editor Testing
-
-        [Space(10)]
         [Header("Editor Simulation")]
         [Tooltip("Configuration settings for testing within the Unity Editor.")]
         public URLData _settings;

package/Runtime/Internal/UI/Animation/BlinkingText.cs

@@ -4,7 +4,7 @@ using TMPro;
 namespace Hyper.Internal
 {
     [RequireComponent(typeof(TMP_Text))]
-    internal class BlinkText : MonoBehaviour
+    internal class BlinkingText : MonoBehaviour
     {
         private float blinkSpeed = 6f;
         private TMP_Text text;

package/Runtime/Internal/UI/Animation/HyperTween.cs

@@ -162,6 +162,34 @@ namespace Hyper.Internal.Animation
             return handle;
         }
 
+        /// <summary>
+        /// Animates an Image's fillAmount (0-1).
+        /// </summary>
+        public static TweenHandle DoFillAmount(Image target, float endValue, float duration)
+        {
+            EnsureCoroutineRunner();
+            var handle = new TweenHandle();
+            var coroutine = coroutineRunner.StartCoroutine(AnimateFillAmount(target, endValue, duration, handle));
+            TrackCoroutine(target, coroutine);
+            handle.coroutine = coroutine;
+            handle.target = target;
+            return handle;
+        }
+
+        /// <summary>
+        /// Animates a Transform's local scale.
+        /// </summary>
+        public static TweenHandle DoScale(Transform target, Vector3 endValue, float duration)
+        {
+            EnsureCoroutineRunner();
+            var handle = new TweenHandle();
+            var coroutine = coroutineRunner.StartCoroutine(AnimateScale(target, endValue, duration, handle));
+            TrackCoroutine(target, coroutine);
+            handle.coroutine = coroutine;
+            handle.target = target;
+            return handle;
+        }
+
         /// <summary>
         /// Executes a callback after a delay.
         /// </summary>
@@ -345,6 +373,56 @@ namespace Hyper.Internal.Animation
             handle.InvokeComplete();
         }
 
+        private static IEnumerator AnimateFillAmount(Image target, float endValue, float duration, TweenHandle handle)
+        {
+            float startValue = target.fillAmount;
+            float elapsed = 0f;
+
+            while (elapsed < duration)
+            {
+                if (target == null)
+                {
+                    UntrackCoroutine(target, handle.coroutine);
+                    yield break;
+                }
+
+                elapsed += handle.useUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime;
+                float t = Mathf.Clamp01(elapsed / duration);
+                float easedT = ApplyEasing(t, handle.ease);
+                target.fillAmount = Mathf.Lerp(startValue, endValue, easedT);
+                yield return null;
+            }
+
+            target.fillAmount = endValue;
+            UntrackCoroutine(target, handle.coroutine);
+            handle.InvokeComplete();
+        }
+
+        private static IEnumerator AnimateScale(Transform target, Vector3 endValue, float duration, TweenHandle handle)
+        {
+            Vector3 startValue = target.localScale;
+            float elapsed = 0f;
+
+            while (elapsed < duration)
+            {
+                if (target == null)
+                {
+                    UntrackCoroutine(target, handle.coroutine);
+                    yield break;
+                }
+
+                elapsed += handle.useUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime;
+                float t = Mathf.Clamp01(elapsed / duration);
+                float easedT = ApplyEasing(t, handle.ease);
+                target.localScale = Vector3.Lerp(startValue, endValue, easedT);
+                yield return null;
+            }
+
+            target.localScale = endValue;
+            UntrackCoroutine(target, handle.coroutine);
+            handle.InvokeComplete();
+        }
+
         private static IEnumerator DelayedCallCoroutine(float delay, Action callback, TweenHandle handle)
         {
             float elapsed = 0f;
@@ -467,6 +545,16 @@ namespace Hyper.Internal.Animation
             return HyperTween.DoColor(target, endValue, duration);
         }
 
+        public static HyperTween.TweenHandle DOFillAmount(this Image target, float endValue, float duration)
+        {
+            return HyperTween.DoFillAmount(target, endValue, duration);
+        }
+
+        public static HyperTween.TweenHandle DOScale(this Transform target, Vector3 endValue, float duration)
+        {
+            return HyperTween.DoScale(target, endValue, duration);
+        }
+
         public static void DOKill(this Component target)
         {
             HyperTween.Kill(target);