app.hypergames.hypersdk 1.3.4 → 1.4.0

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()
@@ -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;
@@ -389,8 +515,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
@@ -1268,6 +1395,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);

package/Runtime/Internal/UI/Components/ControlBar.cs

@@ -4,32 +4,82 @@ using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
 
-
 namespace Hyper.Internal
 {
     internal class ControlBar : MonoBehaviour
     {
+        [Header("UI Components")]
+        public Image roundedBG;
         [SerializeField] TextMeshProUGUI scoreText;
         [SerializeField] private RectTransform scoreTextRect;
         [SerializeField] private RectTransform timerText;
         [SerializeField] private Image safeAreaFillerBG;
-        public Image roundedBG;
         [SerializeField] private Image pauseButtonImage;
         [SerializeField] private Image pauseBarsImage;
+        [SerializeField] private Button connectionStatusIcon;
+
+        [Header("Sprites")]
         [SerializeField] Sprite portraitBG;
         [SerializeField] Sprite landscapeBG;
         [SerializeField] Sprite pauseBarsLight;
         [SerializeField] Sprite pauseBarsDark;
 
+        [Header("Lives Display")]
+        [SerializeField] private GameObject livesDisplayPrefab;
+
+        [Header("Health Bar Display")]
+        [SerializeField] private GameObject healthBarDisplayPrefab;
+
         private GameManager _gameManager;
+        private TextMeshProUGUI _scoreTextComponent;
+        private TextMeshProUGUI _timerTextComponent;
+        private LivesDisplay _livesDisplay;
+        private HealthBarDisplay _healthBarDisplay;
+
+        // Layout constants
+        private const float CENTERED_LAYOUT_SCORE_Y = 31f;
+        private const float CENTERED_LAYOUT_TIMER_Y = -13f;
+        private const float CENTERED_LAYOUT_SCORE_FONT_SIZE = 100f;
+        private const float CENTERED_LAYOUT_TIMER_FONT_SIZE = 50f;
+        
+        private const float DEFAULT_LAYOUT_SCORE_Y = 10f;
+        private const float DEFAULT_LAYOUT_TIMER_X = 35f;
+        private const float DEFAULT_LAYOUT_TIMER_Y = 10f;
+        private const float DEFAULT_LAYOUT_SCORE_FONT_SIZE = 100f;
+        private const float DEFAULT_LAYOUT_TIMER_FONT_SIZE = 60f;
+
+        // Theme constants
+        private const string LIGHT_THEME_BG_COLOR = "#F5F5F5";
+        private const string LIGHT_THEME_TEXT_COLOR = "#434343";
+        private const float DARK_THEME_PAUSE_BUTTON_ALPHA = 0.25f;
+        private const float LIGHT_THEME_PAUSE_BUTTON_ALPHA = 1f;
 
         void Awake()
         {
             _gameManager = HyperRuntime.GameManager;
+            CacheTextComponents();
 
             RectTransform rect = transform.GetComponent<RectTransform>();
+            ConfigureOrientation(rect);
+            ConfigureLayout();
+            ConfigureTheme();
+
+            connectionStatusIcon.onClick.AddListener(ShowConnectionLostStatus);
+        }
 
-            // Choose correct sprite based on Orientation
+        private void OnDestroy()
+        {
+            connectionStatusIcon.onClick.RemoveListener(ShowConnectionLostStatus);
+        }
+
+        private void CacheTextComponents()
+            {
+                _scoreTextComponent = scoreTextRect.GetComponent<TextMeshProUGUI>();
+            _timerTextComponent = timerText.GetComponent<TextMeshProUGUI>();
+        }
+
+        private void ConfigureOrientation(RectTransform rect)
+            {
             if (_gameManager.IsPortrait())
             {
                 roundedBG.sprite = portraitBG;
@@ -40,62 +90,174 @@ namespace Hyper.Internal
                 roundedBG.sprite = landscapeBG;
                 rect.sizeDelta = new Vector2(rect.sizeDelta.x, 180);
             }
+        }
 
+        private void ConfigureLayout()
+        {
+            switch (_gameManager.ControlBarLayout)
+            {
+                case ControlBarLayout.HeartsLeft:
+                    ApplyCenteredLayout();
+                    SetupLivesDisplay();
+                    break;
+                case ControlBarLayout.HealthBarLeft:
+                    ApplyCenteredLayout();
+                    HideLivesDisplay();
+                    SetupHealthBarDisplay();
+                    break;
+                case ControlBarLayout.Default:
+                    ApplyDefaultLayout();
+                    HideLivesDisplay();
+                    HideHealthBarDisplay();
+                    break;
+            }
+        }
 
-            // Configure correct positioning based on the selected Layout
-            if (_gameManager.ControlBarLayout == ControlBarLayout.CustomLeft)
+        private void SetupLivesDisplay()
+        {
+            if (_livesDisplay == null && livesDisplayPrefab != null)
             {
-                scoreTextRect.anchoredPosition = new Vector2(0, 31);
-                scoreTextRect.GetComponent<TextMeshProUGUI>().fontSize = 100;
+                GameObject livesInstance = Instantiate(livesDisplayPrefab, roundedBG.transform);
+                _livesDisplay = livesInstance.GetComponent<LivesDisplay>();
 
-                timerText.anchoredPosition = new Vector2(0, -13);
-                timerText.anchorMin = new Vector2(0.5f, 0.5f);
-                timerText.anchorMax = new Vector2(0.5f, 0.5f);
-                timerText.pivot = new Vector2(0.5f, 0.5f);
-                timerText.GetComponent<TextMeshProUGUI>().fontSize = 50;
+                if (_livesDisplay == null)
+            {
+                    Debug.LogError("[ControlBar] LivesDisplay prefab does not have LivesDisplay component!");
+                    Destroy(livesInstance);
+                return;
+            }
+
+                // Position on the left side where timer would be in default layout
+                RectTransform livesRect = livesInstance.GetComponent<RectTransform>();
+                if (livesRect != null)
+                {
+                    livesRect.anchoredPosition = new Vector2(DEFAULT_LAYOUT_TIMER_X, DEFAULT_LAYOUT_TIMER_Y);
+                    livesRect.anchorMin = new Vector2(0f, 0.5f);
+                    livesRect.anchorMax = new Vector2(0f, 0.5f);
+                    livesRect.pivot = new Vector2(0, 0.5f);
+                }
             }
-            else if (_gameManager.ControlBarLayout == ControlBarLayout.Default)
+
+            if (_livesDisplay != null)
             {
-                scoreTextRect.anchoredPosition = new Vector2(0, 10);
-                scoreTextRect.GetComponent<TextMeshProUGUI>().fontSize = 100;
+                _livesDisplay.gameObject.SetActive(true);
+            }
+        }
 
-                timerText.anchoredPosition = new Vector2(40, 10);
-                timerText.anchorMin = new Vector2(0f, 0.5f);
-                timerText.anchorMax = new Vector2(0f, 0.5f);
-                timerText.pivot = new Vector2(0, 0.5f);
-                timerText.GetComponent<TextMeshProUGUI>().fontSize = 60;
-                timerText.GetComponent<TextMeshProUGUI>().alignment = TextAlignmentOptions.MidlineLeft;
+        private void HideLivesDisplay()
+        {
+            if (_livesDisplay != null)
+            {
+                _livesDisplay.gameObject.SetActive(false);
             }
+        }
 
-            //Configure correct coloring based on selected theme
-            if (_gameManager.ControlBarTheme == ControlBarTheme.Dark)
+        private void SetupHealthBarDisplay()
+        {
+            if (_healthBarDisplay == null && healthBarDisplayPrefab != null)
             {
-                roundedBG.color = Color.black;
-                safeAreaFillerBG.color = Color.black;
+                GameObject healthBarInstance = Instantiate(healthBarDisplayPrefab, roundedBG.transform);
+                _healthBarDisplay = healthBarInstance.GetComponent<HealthBarDisplay>();
 
-                scoreTextRect.GetComponent<TextMeshProUGUI>().color = Color.white;
-                timerText.GetComponent<TextMeshProUGUI>().color = Color.white;
+                if (_healthBarDisplay == null)
+                {
+                    Debug.LogError("[ControlBar] HealthBarDisplay prefab does not have HealthBarDisplay component!");
+                    Destroy(healthBarInstance);
+                    return;
+                }
 
-                //pauseButtonImage.sprite = pauseButtonDark;
-                pauseButtonImage.color = new Color(1, 1, 1, 0.25f);
-                pauseBarsImage.sprite = pauseBarsDark;
+                // Position on the left side where timer would be in default layout
+                RectTransform healthBarRect = healthBarInstance.GetComponent<RectTransform>();
+                if (healthBarRect != null)
+                {
+                    healthBarRect.anchoredPosition = new Vector2(DEFAULT_LAYOUT_TIMER_X, DEFAULT_LAYOUT_TIMER_Y);
+                    healthBarRect.anchorMin = new Vector2(0f, 0.5f);
+                    healthBarRect.anchorMax = new Vector2(0f, 0.5f);
+                    healthBarRect.pivot = new Vector2(0, 0.5f);
+                }
+            }
+
+            if (_healthBarDisplay != null)
+            {
+                _healthBarDisplay.gameObject.SetActive(true);
             }
-            else if (_gameManager.ControlBarTheme == ControlBarTheme.Light)
+        }
+
+        private void HideHealthBarDisplay()
+        {
+            if (_healthBarDisplay != null)
             {
-                roundedBG.color = HexToColor("#F5F5F5");
-                safeAreaFillerBG.color = HexToColor("#F5F5F5");
+                _healthBarDisplay.gameObject.SetActive(false);
+            }
+        }
+
+        private void ApplyCenteredLayout()
+        {
+            scoreTextRect.anchoredPosition = new Vector2(0, CENTERED_LAYOUT_SCORE_Y);
+            _scoreTextComponent.fontSize = CENTERED_LAYOUT_SCORE_FONT_SIZE;
 
-                scoreTextRect.GetComponent<TextMeshProUGUI>().color = HexToColor("#434343");
-                timerText.GetComponent<TextMeshProUGUI>().color = HexToColor("#434343");
+            timerText.anchoredPosition = new Vector2(0, CENTERED_LAYOUT_TIMER_Y);
+            timerText.anchorMin = new Vector2(0.5f, 0.5f);
+            timerText.anchorMax = new Vector2(0.5f, 0.5f);
+            timerText.pivot = new Vector2(0.5f, 0.5f);
+            _timerTextComponent.fontSize = CENTERED_LAYOUT_TIMER_FONT_SIZE;
+        }
+
+        private void ApplyDefaultLayout()
+        {
+            scoreTextRect.anchoredPosition = new Vector2(0, DEFAULT_LAYOUT_SCORE_Y);
+            _scoreTextComponent.fontSize = DEFAULT_LAYOUT_SCORE_FONT_SIZE;
 
-                //pauseButtonImage.sprite = pauseButtonLight;
-                pauseButtonImage.color = new Color(1, 1, 1, 1);
-                pauseBarsImage.sprite = pauseBarsLight;
-            } 
+            timerText.anchoredPosition = new Vector2(DEFAULT_LAYOUT_TIMER_X, DEFAULT_LAYOUT_TIMER_Y);
+            timerText.anchorMin = new Vector2(0f, 0.5f);
+            timerText.anchorMax = new Vector2(0f, 0.5f);
+            timerText.pivot = new Vector2(0, 0.5f);
+            _timerTextComponent.fontSize = DEFAULT_LAYOUT_TIMER_FONT_SIZE;
+            _timerTextComponent.alignment = TextAlignmentOptions.MidlineLeft;
         }
 
-        public void ShowConnectionLostStatus()
+        private void ConfigureTheme()
         {
+            switch (_gameManager.ControlBarTheme)
+            {
+                case ControlBarTheme.Dark:
+                    ApplyDarkTheme();
+                    break;
+                case ControlBarTheme.Light:
+                    ApplyLightTheme();
+                    break;
+            }
+        }
+
+        private void ApplyDarkTheme()
+        {
+            roundedBG.color = Color.black;
+            safeAreaFillerBG.color = Color.black;
+
+                _scoreTextComponent.color = Color.white;
+                _timerTextComponent.color = Color.white;
+
+            pauseButtonImage.color = new Color(1, 1, 1, DARK_THEME_PAUSE_BUTTON_ALPHA);
+                pauseBarsImage.sprite = pauseBarsDark;
+        }
+
+        private void ApplyLightTheme()
+        {
+            Color bgColor = HexToColor(LIGHT_THEME_BG_COLOR);
+            Color textColor = HexToColor(LIGHT_THEME_TEXT_COLOR);
+
+            roundedBG.color = bgColor;
+            safeAreaFillerBG.color = bgColor;
+
+            _scoreTextComponent.color = textColor;
+            _timerTextComponent.color = textColor;
+
+            pauseButtonImage.color = new Color(1, 1, 1, LIGHT_THEME_PAUSE_BUTTON_ALPHA);
+            pauseBarsImage.sprite = pauseBarsLight;
+        }
+
+        private void ShowConnectionLostStatus()
+            {
             // Show the connection lost status
             _gameManager.ShowConnectionLost();
         }
@@ -105,6 +267,24 @@ namespace Hyper.Internal
             scoreText.SetText(HyperRuntime.DataManager.CurrentScore.ToString("N0"));
         }
 
+        /// <summary>
+        /// Gets the LivesDisplay component if available.
+        /// Only available when ControlBarLayout is set to HeartsLeft.
+        /// </summary>
+        public LivesDisplay GetLivesDisplay()
+        {
+            return _livesDisplay;
+        }
+
+        /// <summary>
+        /// Gets the HealthBarDisplay component if available.
+        /// Only available when ControlBarLayout is set to HealthBarGreenLeft.
+        /// </summary>
+        public HealthBarDisplay GetHealthBarDisplay()
+        {
+            return _healthBarDisplay;
+        }
+
         Color HexToColor(string hex)
         {
             if (ColorUtility.TryParseHtmlString(hex, out Color color))