app.hypergames.hypersdk 1.3.4 → 1.4.1

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

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

@@ -0,0 +1,46 @@
+using TMPro;
+using UnityEngine;
+using System.Runtime.InteropServices;
+using Hyper.Internal.Managers;
+using Hyper.Shared;
+
+namespace Hyper.Internal
+{
+    internal class ExitGameMenuModal : MonoBehaviour
+    {
+        [SerializeField] private CanvasGroup ctaButtonsHolder;
+        [SerializeField] private GameObject loadingCircle;
+        private GameManager _gameManager;
+
+        void Awake()
+        {
+            _gameManager = HyperRuntime.GameManager;
+        }
+
+        private void DisableButtonHolder()
+        {
+            ctaButtonsHolder.interactable = false;
+            ctaButtonsHolder.alpha = 0.6f;
+
+            loadingCircle.SetActive(true);
+        }
+
+        // Buttons
+        public void Exit()
+        {
+            DisableButtonHolder();
+            HyperRuntime.BackendManager.LogEvent(ConsoleEventType.PracticeGameEnd);
+        }
+
+        public void ContinuePlaying()
+        {
+            Hide();
+        }
+
+        private void Hide()
+        {
+            _gameManager.HideExitGameMenuModal();
+        }
+    }
+}
+

package/Runtime/Internal/UI/Modals/ExitGameMenuModal.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a90f1b8b2fc0170469bee39da74afb1b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -1,6 +1,9 @@
 using System.Runtime.InteropServices;
 using Hyper.Internal.Managers;
+using Hyper.Shared;
+using TMPro;
 using UnityEngine;
+using UnityEngine.UI;
 
 namespace Hyper.Internal
 {
@@ -11,10 +14,19 @@ namespace Hyper.Internal
         [DllImport("__Internal")]
         private static extern void MarkGameStartedOnHTML();
 #endif
+        [SerializeField] private TextMeshProUGUI startCtaLabel;
+        [SerializeField] private BlinkingText blinkingText;
+        [SerializeField] private RectTransform swipeGif;
         private EventManager _eventManager;
         private DataManager _dataManager;
         private GameManager _gameManager;
         private BackendManager _backendManager;
+        private StartCTA _currentCTA;
+
+        // Swipe detection variables
+        private Vector2 _swipeStartPosition;
+        private bool _isTrackingSwipe;
+        private const float SWIPE_THRESHOLD = 50f; // Minimum distance in pixels for a swipe
 
         void Awake()
         {
@@ -24,10 +36,155 @@ namespace Hyper.Internal
             _backendManager = HyperRuntime.BackendManager;
         }
 
-        public void OnTap()
+        void Update()
+        {
+            if (!gameObject.activeSelf) return;
+
+            if (_currentCTA == StartCTA.TapToPlay)
+            {
+                HandleTapInput();
+            }
+            else
+            {
+                HandleSwipeInput();
+            }
+        }
+
+        /// <summary>
+        /// Configures the CTA text and input mode based on the selected StartCTA type.
+        /// </summary>
+        public void Configure(StartCTA cta)
+        {
+            _currentCTA = cta;
+
+            if (startCtaLabel == null)
+            {
+                // Fallback: try to find it if not assigned
+                startCtaLabel = GetComponentInChildren<TextMeshProUGUI>();
+            }
+
+            if (startCtaLabel == null)
+            {
+                HyperDebug.LogWarning("[StartingInstructionModal] Start CTA label not found. Make sure the TextMeshProUGUI component is assigned in the prefab.");
+                return;
+            }
+
+            switch (cta)
+            {
+                case StartCTA.SwipeToPlayVertical:
+                case StartCTA.SwipeToPlayHorizontal:
+                    startCtaLabel.text = "SWIPE TO PLAY";
+                    blinkingText.enabled = false;
+                    break;
+                case StartCTA.TapToPlay:
+                default:
+                    startCtaLabel.text = "TAP TO PLAY";
+                    blinkingText.enabled = true;
+                    break;
+            }
+
+            UpdateSwipeGraphics();
+        }
+
+        /// <summary>
+        /// Handles tap input detection (works with both old and new Input System).
+        /// </summary>
+        private void HandleTapInput()
+        {
+            bool tapDetected = false;
+
+            // Check mouse input (works in editor and desktop)
+            if (Input.GetMouseButtonDown(0))
+            {
+                tapDetected = true;
+            }
+
+            // Check touch input (works on mobile and WebGL)
+            if (Input.touchCount > 0)
+            {
+                Touch touch = Input.GetTouch(0);
+                if (touch.phase == TouchPhase.Began)
+                {
+                    tapDetected = true;
+                }
+            }
+
+            if (tapDetected)
+            {
+                StartGame();
+            }
+        }
+
+        /// <summary>
+        /// Handles swipe input detection (works with both old and new Input System).
+        /// </summary>
+        private void HandleSwipeInput()
+        {
+            bool swipeDetected = false;
+            Vector2 currentPosition = Vector2.zero;
+
+            // Check mouse input (works in editor and desktop)
+            if (Input.GetMouseButtonDown(0))
+            {
+                _swipeStartPosition = Input.mousePosition;
+                _isTrackingSwipe = true;
+            }
+            else if (Input.GetMouseButton(0) && _isTrackingSwipe)
+            {
+                currentPosition = Input.mousePosition;
+                Vector2 delta = currentPosition - _swipeStartPosition;
+                
+                if (IsSwipeDirectionValid(delta))
+                {
+                    swipeDetected = true;
+                    _isTrackingSwipe = false;
+                }
+            }
+            else if (Input.GetMouseButtonUp(0))
+            {
+                _isTrackingSwipe = false;
+            }
+
+            // Check touch input (works on mobile and WebGL)
+            if (Input.touchCount > 0)
+            {
+                Touch touch = Input.GetTouch(0);
+                
+                if (touch.phase == TouchPhase.Began)
+                {
+                    _swipeStartPosition = touch.position;
+                    _isTrackingSwipe = true;
+                }
+                else if (touch.phase == TouchPhase.Moved && _isTrackingSwipe)
+                {
+                    currentPosition = touch.position;
+                    Vector2 delta = currentPosition - _swipeStartPosition;
+                    
+                    if (IsSwipeDirectionValid(delta))
+                    {
+                        swipeDetected = true;
+                        _isTrackingSwipe = false;
+                    }
+                }
+                else if (touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled)
+                {
+                    _isTrackingSwipe = false;
+                }
+            }
+
+            if (swipeDetected)
+            {
+                StartGame();
+            }
+        }
+
+        /// <summary>
+        /// Starts the game - called when tap or swipe is detected.
+        /// </summary>
+        private void StartGame()
         {
             _gameManager.HideStartGameDeadlineSnackBar();
-           _dataManager.UpdateScore(0);
+            _dataManager.UpdateScore(0);
             HyperRuntime.Timer.StartActiveGameTimer();
 
             // Only proceed if connected
@@ -39,10 +196,52 @@ namespace Hyper.Internal
             }
 
 #if UNITY_WEBGL && !UNITY_EDITOR
-    MarkGameStartedOnHTML();
+            MarkGameStartedOnHTML();
 #endif
             _eventManager.InvokeGameStartEvent();
             gameObject.SetActive(false);
         }
+
+        private void UpdateSwipeGraphics()
+        {
+            bool showVertical = _currentCTA == StartCTA.SwipeToPlayVertical;
+            bool showHorizontal = _currentCTA == StartCTA.SwipeToPlayHorizontal;
+
+            if (swipeGif != null)
+            {
+                if (showVertical)
+                {
+                    swipeGif.anchoredPosition = new Vector3(0, 286, 0);
+                    swipeGif.transform.rotation = Quaternion.Euler(0, 0, 90);
+                    swipeGif.gameObject.SetActive(true);
+                }
+                else if (showHorizontal)
+                {
+                    swipeGif.anchoredPosition = new Vector3(0, 220, 0);
+                    swipeGif.transform.rotation = Quaternion.Euler(0, 0, 0);
+                    swipeGif.gameObject.SetActive(true);
+                }
+                else
+                {
+                    swipeGif.gameObject.SetActive(false);
+                }
+            }
+        }
+
+        private bool IsSwipeDirectionValid(Vector2 delta)
+        {
+            float absX = Mathf.Abs(delta.x);
+            float absY = Mathf.Abs(delta.y);
+
+            switch (_currentCTA)
+            {
+                case StartCTA.SwipeToPlayVertical:
+                    return absY >= SWIPE_THRESHOLD && absY >= absX;
+                case StartCTA.SwipeToPlayHorizontal:
+                    return absX >= SWIPE_THRESHOLD && absX >= absY;
+                default:
+                    return false;
+            }
+        }
     }
 }

package/Runtime/Internal/Utils/HyperConstants.cs

@@ -65,6 +65,33 @@ namespace Hyper.Internal
                 return devPath;
             }
         }
+
+        /// <summary>
+        /// Returns the control bar preview folder path, checking dev mode (Assets/) first, then package mode (Packages/).
+        /// </summary>
+        public static string CONTROL_BAR_PREVIEW_FOLDER_PATH
+        {
+            get
+            {
+                const string devPath = "Assets/HyperSDK/Editor/Resources/ControlBarPreviews";
+                const string packagePath = "Packages/app.hypergames.hypersdk/Editor/Resources/ControlBarPreviews";
+                
+                // Check dev mode first (Assets/)
+                if (AssetDatabase.IsValidFolder(devPath))
+                {
+                    return devPath;
+                }
+                
+                // Fall back to package mode (Packages/)
+                if (AssetDatabase.IsValidFolder(packagePath))
+                {
+                    return packagePath;
+                }
+                
+                // Default to dev path if neither found (for backwards compatibility)
+                return devPath;
+            }
+        }
 #endif
         
         #endregion