app.hypergames.hypersdk 1.3.4 → 1.4.1

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))

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

@@ -0,0 +1,269 @@
+using System.Collections;
+using UnityEngine;
+using UnityEngine.UI;
+using Hyper.Internal.Animation;
+using System;
+
+namespace Hyper.Internal
+{
+    /// <summary>
+    /// Manages the display of health bar in the control bar.
+    /// Uses Image.fillAmount to represent health from 0-1.
+    /// </summary>
+    internal class HealthBarDisplay : MonoBehaviour
+    {
+        [Header("UI Components")]
+        [SerializeField] private Image healthFillImage;
+        [SerializeField] private Image underlayFillImage;
+
+        [Header("Configuration")]
+        [SerializeField] private float lowHealthThreshold = 0.3f;
+
+        [Header("Animation")]
+        [SerializeField] private float fillDelay = 0.1f;
+        [SerializeField] private float fillAnimationDuration = 0.3f;
+        [SerializeField] private bool usePulseOnLowHealth = false;
+        [SerializeField] private float pulseDuration = 0.5f;
+
+        private float _currentHealth = 1f;
+        private float _maxHealth = 1f;
+        private HyperTween.TweenHandle _fillTweenHandle;
+        private Coroutine _pulseCoroutine;
+        private bool _healthExhaustedTriggered;
+
+        private void Awake()
+        {
+            if (healthFillImage == null)
+            {
+                Debug.LogError("[HealthBarDisplay] Health fill image is not assigned!");
+            }
+
+            // Initialize to full health
+            if (healthFillImage != null && underlayFillImage != null)
+            {
+                healthFillImage.fillAmount = 1f;
+                underlayFillImage.fillAmount = 1f;
+            }
+        }
+
+        /// <summary>
+        /// Initializes the health bar with a maximum health value.
+        /// </summary>
+        /// <param name="maxHealth">Maximum health value</param>
+        /// <param name="initialHealth">Initial health (defaults to max, or pass 0-1 for normalized)</param>
+        /// <param name="isNormalized">If true, initialHealth is treated as 0-1, otherwise as absolute value</param>
+        public void Initialize(float maxHealth, float initialHealth = -1f, bool isNormalized = false)
+        {
+            if (maxHealth <= 0)
+            {
+                Debug.LogWarning("[HealthBarDisplay] Max health must be greater than 0. Setting to 1.");
+                maxHealth = 1f;
+            }
+
+            _maxHealth = maxHealth;
+
+            if (initialHealth < 0)
+            {
+                _currentHealth = maxHealth;
+            }
+            else if (isNormalized)
+            {
+                _currentHealth = Mathf.Clamp01(initialHealth) * maxHealth;
+            }
+            else
+            {
+                _currentHealth = Mathf.Clamp(initialHealth, 0f, maxHealth);
+            }
+
+            _healthExhaustedTriggered = false;
+            UpdateDisplay();
+        }
+
+        /// <summary>
+        /// Sets the current health value.
+        /// </summary>
+        /// <param name="health">Health value (absolute)</param>
+        public void SetHealth(float health)
+        {
+            float previousHealth = _currentHealth;
+            _currentHealth = Mathf.Clamp(health, 0f, _maxHealth);
+            AnimateHealthChange(previousHealth, _currentHealth);
+
+            // Check if health reached 0
+            if (previousHealth > 0 && _currentHealth <= 0)
+            {
+                CheckHealthExhausted();
+            }
+        }
+
+        /// <summary>
+        /// Sets the current health as a normalized value (0-1).
+        /// </summary>
+        /// <param name="normalizedHealth">Health value from 0 to 1</param>
+        public void SetHealthNormalized(float normalizedHealth)
+        {
+            SetHealth(Mathf.Clamp01(normalizedHealth) * _maxHealth);
+        }
+
+        /// <summary>
+        /// Adds health.
+        /// </summary>
+        /// <param name="amount">Amount of health to add</param>
+        public void AddHealth(float amount)
+        {
+            if (amount > 0)
+            {
+                SetHealth(_currentHealth + amount);
+            }
+        }
+
+        /// <summary>
+        /// Removes health.
+        /// </summary>
+        /// <param name="amount">Amount of health to remove</param>
+        public void RemoveHealth(float amount)
+        {
+            if (amount > 0)
+            {
+                SetHealth(_currentHealth - amount);
+            }
+        }
+
+        /// <summary>
+        /// Gets the current health value.
+        /// </summary>
+        public float GetCurrentHealth() => _currentHealth;
+
+        /// <summary>
+        /// Gets the maximum health value.
+        /// </summary>
+        public float GetMaxHealth() => _maxHealth;
+
+        /// <summary>
+        /// Gets the current health as a normalized value (0-1).
+        /// </summary>
+        public float GetHealthNormalized() => _maxHealth > 0 ? _currentHealth / _maxHealth : 0f;
+
+        private void AnimateHealthChange(float fromHealth, float toHealth)
+        {
+            if (healthFillImage == null) return;
+
+            // Stop existing animation
+            if (_fillTweenHandle != null)
+            {
+                _fillTweenHandle.Kill();
+            }
+
+            float fromFill = _maxHealth > 0 ? fromHealth / _maxHealth : 0f;
+            float toFill = _maxHealth > 0 ? toHealth / _maxHealth : 0f;
+
+            healthFillImage.fillAmount -= Math.Abs(fromHealth - toHealth) / _maxHealth;
+
+            HyperTween.DelayedCall(fillDelay, () =>
+            {
+                // Animate fill amount
+                _fillTweenHandle = underlayFillImage.DOFillAmount(toFill, fillAnimationDuration)
+                    .SetEase(HyperTween.Ease.OutQuad)
+                    .OnComplete(() =>
+                    {
+                        _fillTweenHandle = null;
+
+                        // Start pulse if health is low
+                        if (usePulseOnLowHealth && toFill <= lowHealthThreshold && toFill > 0)
+                        {
+                            StartPulseAnimation();
+                        }
+                        else
+                        {
+                            StopPulseAnimation();
+                        }
+                    });
+            });
+        }
+
+        private void StartPulseAnimation()
+        {
+            if (_pulseCoroutine != null) return;
+            _pulseCoroutine = StartCoroutine(PulseAnimation());
+        }
+
+        private void StopPulseAnimation()
+        {
+            if (_pulseCoroutine != null)
+            {
+                StopCoroutine(_pulseCoroutine);
+                _pulseCoroutine = null;
+            }
+
+            if (healthFillImage != null)
+            {
+                Color color = healthFillImage.color;
+                color.a = 1f;
+                healthFillImage.color = color;
+                underlayFillImage.color = color;
+            }
+        }
+
+        private IEnumerator PulseAnimation()
+        {
+            if (healthFillImage == null) yield break;
+
+            while (true)
+            {
+                if (healthFillImage == null) yield break;
+
+                float normalizedHealth = GetHealthNormalized();
+                if (normalizedHealth > lowHealthThreshold || normalizedHealth <= 0)
+                {
+                    StopPulseAnimation();
+                    yield break;
+                }
+
+                // Pulse alpha
+                float elapsed = 0f;
+                Color startColor = healthFillImage.color;
+                Color pulseColor = new Color(startColor.r, startColor.g, startColor.b, 0.5f);
+
+                while (elapsed < pulseDuration)
+                {
+                    if (healthFillImage == null) yield break;
+                    elapsed += Time.deltaTime;
+                    float t = Mathf.PingPong(elapsed / pulseDuration, 1f);
+                    Color currentColor = Color.Lerp(startColor, pulseColor, t);
+                    healthFillImage.color = currentColor;
+                    underlayFillImage.color = currentColor;
+                    yield return null;
+                }
+            }
+        }
+
+        private void UpdateDisplay()
+        {
+            if (healthFillImage == null) return;
+
+            float normalizedHealth = GetHealthNormalized();
+            healthFillImage.fillAmount = normalizedHealth;
+            underlayFillImage.fillAmount = normalizedHealth;
+        }
+
+        private void CheckHealthExhausted()
+        {
+            if (_currentHealth <= 0 && !_healthExhaustedTriggered)
+            {
+                _healthExhaustedTriggered = true;
+                HyperRuntime.EventManager?.InvokeHealthExhaustedEvent();
+            }
+        }
+
+        private void OnDestroy()
+        {
+            if (_fillTweenHandle != null)
+            {
+                _fillTweenHandle.Kill();
+            }
+            HyperTween.Kill(underlayFillImage);
+            StopPulseAnimation();
+        }
+    }
+}
+

package/Runtime/Internal/UI/Components/HealthBarDisplay.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 60de914bbc6cab74ba739af42321d40f