app.hypergames.hypersdk 1.3.4 → 1.4.0

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

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

@@ -0,0 +1,327 @@
+using System.Collections;
+using UnityEngine;
+using TMPro;
+using UnityEngine.UI;
+using Hyper.Internal.Animation;
+
+namespace Hyper.Internal
+{
+    /// <summary>
+    /// Manages the display of lives/hearts in the control bar.
+    /// Dynamically creates and manages heart icons based on current lives.
+    /// </summary>
+    internal class LivesDisplay : MonoBehaviour
+    {
+        [Header("Configuration")]
+        [SerializeField] private Sprite heartFullSprite;
+        [SerializeField] private Sprite heartEmptySprite;
+        [SerializeField] private float heartSize = 50f;
+        [SerializeField] private float spacing = 10f;
+        [SerializeField, Min(1)] private int maxVisibleHearts = 3;
+
+        [Header("Animation")]
+        [SerializeField] private float fadeDuration = 0.3f;
+        [SerializeField] private bool useScaleAnimation = false;
+        [SerializeField] private float scaleAmount = 0.8f;
+        [SerializeField] private float scaleDuration = 0.15f;
+
+        [Header("Container")]
+        [SerializeField] private RectTransform container;
+        [SerializeField] private TextMeshProUGUI overflowLabel;
+
+        private int _currentLives;
+        private int _maxLives;
+        private Image[] _heartImages;
+        private bool _livesExhaustedTriggered;
+
+        private void Awake()
+        {
+            if (container == null)
+            {
+                container = GetComponent<RectTransform>();
+            }
+
+            ConfigureLayoutGroup();
+
+            if (overflowLabel != null)
+            {
+                overflowLabel.gameObject.SetActive(false);
+                overflowLabel.text = string.Empty;
+            }
+        }
+
+        private void ConfigureLayoutGroup()
+        {
+            HorizontalLayoutGroup layoutGroup = container.GetComponent<HorizontalLayoutGroup>();
+            if (layoutGroup == null)
+            {
+                layoutGroup = container.gameObject.AddComponent<HorizontalLayoutGroup>();
+            }
+
+            layoutGroup.spacing = spacing;
+            layoutGroup.childAlignment = TextAnchor.MiddleLeft;
+            layoutGroup.childControlWidth = false;
+            layoutGroup.childControlHeight = false;
+            layoutGroup.childForceExpandWidth = false;
+            layoutGroup.childForceExpandHeight = false;
+        }
+
+        /// <summary>
+        /// Initializes the lives display with a maximum number of lives.
+        /// Creates heart icons based on the max value.
+        /// </summary>
+        /// <param name="maxLives">Maximum number of lives to display</param>
+        /// <param name="initialLives">Initial number of lives (defaults to max)</param>
+        public void Initialize(int maxLives, int initialLives = -1)
+        {
+            if (maxLives < 0)
+            {
+                Debug.LogWarning("[LivesDisplay] Max lives cannot be negative. Setting to 0.");
+                maxLives = 0;
+            }
+
+            _maxLives = maxLives;
+            _currentLives = initialLives >= 0 ? initialLives : maxLives;
+
+            if (_currentLives > _maxLives)
+            {
+                _currentLives = _maxLives;
+            }
+
+            _livesExhaustedTriggered = false;
+            CreateHeartIcons();
+            UpdateDisplay();
+        }
+
+        /// <summary>
+        /// Sets the current number of lives and updates the display.
+        /// </summary>
+        /// <param name="lives">Number of lives to set</param>
+        public void SetLives(int lives)
+        {
+            int previousLives = _currentLives;
+            _currentLives = Mathf.Clamp(lives, 0, _maxLives);
+            UpdateDisplay();
+
+            // Only check if lives decreased to 0
+            if (previousLives > 0 && _currentLives == 0)
+            {
+                CheckLivesExhausted();
+            }
+        }
+
+        /// <summary>
+        /// Adds one life (up to max).
+        /// </summary>
+        public void AddLife()
+        {
+            if (_currentLives < _maxLives)
+            {
+                _currentLives++;
+                UpdateDisplay();
+            }
+        }
+
+        /// <summary>
+        /// Removes one life (down to 0).
+        /// </summary>
+        public void RemoveLife()
+        {
+            if (_currentLives > 0)
+            {
+                int lostLifeIndex = _currentLives - 1;
+                _currentLives--;
+                UpdateDisplay();
+                AnimateLifeLost(lostLifeIndex);
+                CheckLivesExhausted();
+            }
+        }
+
+        /// <summary>
+        /// Gets the current number of lives.
+        /// </summary>
+        public int GetCurrentLives() => _currentLives;
+
+        /// <summary>
+        /// Gets the maximum number of lives.
+        /// </summary>
+        public int GetMaxLives() => _maxLives;
+
+        private void CreateHeartIcons()
+        {
+            // Clear existing hearts
+            ClearHearts();
+
+            if (_maxLives <= 0)
+            {
+                _heartImages = new Image[0];
+                return;
+            }
+
+            int heartSlots = maxVisibleHearts > 0
+                ? Mathf.Min(_maxLives, maxVisibleHearts)
+                : _maxLives;
+
+            _heartImages = new Image[heartSlots];
+
+            for (int i = 0; i < heartSlots; i++)
+            {
+                GameObject heartObject = new GameObject($"Heart_{i}");
+                heartObject.transform.SetParent(container, false);
+
+                RectTransform heartRect = heartObject.AddComponent<RectTransform>();
+                heartRect.sizeDelta = new Vector2(heartSize, heartSize);
+
+                Image heartImage = heartObject.AddComponent<Image>();
+                heartImage.sprite = heartFullSprite;
+                heartImage.preserveAspect = true;
+
+                _heartImages[i] = heartImage;
+            }
+        }
+
+        private void UpdateDisplay()
+        {
+            if (_heartImages == null) return;
+
+            for (int i = 0; i < _heartImages.Length; i++)
+            {
+                if (_heartImages[i] != null)
+                {
+                    bool isFull = i < Mathf.Min(_currentLives, _heartImages.Length);
+                    _heartImages[i].sprite = isFull ? heartFullSprite : heartEmptySprite;
+                    _heartImages[i].gameObject.SetActive(true);
+
+                    // Reset color to full opacity for immediate updates
+                    Color color = _heartImages[i].color;
+                    color.a = 1f;
+                    _heartImages[i].color = color;
+                }
+            }
+
+            UpdateOverflowLabel();
+        }
+
+        private void AnimateLifeLost(int heartIndex)
+        {
+            if (_heartImages == null || heartIndex < 0 || heartIndex >= _heartImages.Length)
+                return;
+
+            Image heartImage = _heartImages[heartIndex];
+            if (heartImage == null) return;
+
+            // Update sprite immediately
+            Color color = heartImage.color;
+            color.a = 0.45f;
+            heartImage.color = color;
+            heartImage.sprite = heartEmptySprite;
+
+            // Stop any existing animations on this heart
+            HyperTween.Kill(heartImage);
+            if (heartImage.transform != null)
+            {
+                HyperTween.Kill(heartImage.transform);
+            }
+
+            // Fade animation: fade out then fade back in with empty sprite
+            AnimateHeartFade(heartImage);
+
+            // Optional scale animation
+            if (useScaleAnimation && heartImage.transform != null)
+            {
+                AnimateHeartScale(heartImage.transform);
+            }
+        }
+
+        private void AnimateHeartFade(Image heartImage)
+        {
+            if (heartImage == null) return;
+
+            Color startColor = heartImage.color;
+            Color fadeOutColor = new Color(startColor.r, startColor.g, startColor.b, 0f);
+            Color fadeInColor = new Color(startColor.r, startColor.g, startColor.b, 1f);
+            float halfDuration = fadeDuration * 0.5f;
+
+            // Fade out, then fade back in
+            heartImage.DOColor(fadeOutColor, halfDuration)
+                .SetEase(HyperTween.Ease.OutQuad)
+                .OnComplete(() =>
+                {
+                    if (heartImage != null)
+                    {
+                        heartImage.DOColor(fadeInColor, halfDuration)
+                            .SetEase(HyperTween.Ease.InQuad);
+                    }
+                });
+        }
+
+        private void AnimateHeartScale(Transform heartTransform)
+        {
+            if (heartTransform == null) return;
+
+            Vector3 originalScale = Vector3.one;
+            Vector3 scaledDown = originalScale * scaleAmount;
+            float halfDuration = scaleDuration * 0.5f;
+
+            // Scale down, then scale back up
+            heartTransform.DOScale(scaledDown, halfDuration)
+                .SetEase(HyperTween.Ease.OutQuad)
+                .OnComplete(() =>
+                {
+                    if (heartTransform != null)
+                    {
+                        heartTransform.DOScale(originalScale, halfDuration)
+                            .SetEase(HyperTween.Ease.InQuad);
+                    }
+                });
+        }
+
+        private void CheckLivesExhausted()
+        {
+            if (_currentLives <= 0 && !_livesExhaustedTriggered)
+            {
+                _livesExhaustedTriggered = true;
+                HyperRuntime.EventManager?.InvokeLivesExhaustedEvent();
+            }
+        }
+
+        private void ClearHearts()
+        {
+            if (_heartImages == null) return;
+
+            foreach (Image heart in _heartImages)
+            {
+                if (heart != null)
+                {
+                    Destroy(heart.gameObject);
+                }
+            }
+
+            _heartImages = null;
+        }
+
+        private void OnDestroy()
+        {
+            ClearHearts();
+        }
+
+        private void UpdateOverflowLabel()
+        {
+            if (overflowLabel == null) return;
+
+            int heartSlots = _heartImages != null ? _heartImages.Length : 0;
+            int overflow = Mathf.Max(0, _currentLives - heartSlots);
+            if (overflow > 0)
+            {
+                overflowLabel.gameObject.SetActive(true);
+                overflowLabel.text = $"+{overflow}";
+            }
+            else
+            {
+                overflowLabel.text = string.Empty;
+                overflowLabel.gameObject.SetActive(false);
+            }
+        }
+    }
+}
+

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cb2e75c824ecc1e4f8f4461666f2ae4b