app.hypergames.hypersdk 1.9.1 → 1.11.0-beta.1

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

@@ -0,0 +1,147 @@
+using UnityEngine;
+using UnityEngine.Sprites;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    /// <summary>
+    /// Applies a pixel-configurable, rounded bottom cutout to a standard uGUI Image.
+    /// The assigned sprite, Image color, UI masks, and raycast target remain supported.
+    /// </summary>
+    [ExecuteAlways]
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof(Image))]
+    public sealed class ConcaveImage : MonoBehaviour
+    {
+        private const string ShaderResourcePath = "Shaders/ConcaveImage";
+        private const string ShaderName = "Hyper/UI/Concave Image";
+        private const float PortraitCutoutHeight = 55f;
+        private const float LandscapeCutoutHeight = 35f;
+
+        private static readonly int RectSizeId = Shader.PropertyToID("_RectSize");
+        private static readonly int PivotId = Shader.PropertyToID("_Pivot");
+        private static readonly int SpriteUVRectId = Shader.PropertyToID("_SpriteUVRect");
+        private static readonly int SideInsetId = Shader.PropertyToID("_SideInset");
+        private static readonly int CutoutHeightId = Shader.PropertyToID("_CutoutHeight");
+        private static readonly int CornerRadiusId = Shader.PropertyToID("_CornerRadius");
+        private static readonly int AASoftnessId = Shader.PropertyToID("_AASoftness");
+
+        [Header("Cutout (UI pixels)")]
+        [SerializeField, Min(0f)] private float sideInset = 32f;
+        [SerializeField, Min(0f)] private float cutoutHeight = 30f;
+        [SerializeField, Min(0f)] private float cornerRadius = 30f;
+        [SerializeField, Min(0.25f)] private float aaSoftness = 1f;
+
+        private Image image;
+        private RectTransform rectTransform;
+        private Material materialInstance;
+        private bool? lastPortraitState;
+
+        public float SideInset { get => sideInset; set { sideInset = Mathf.Max(0f, value); ApplyProperties(); } }
+        public float CutoutHeight { get => cutoutHeight; set { cutoutHeight = Mathf.Max(0f, value); ApplyProperties(); } }
+        public float CornerRadius { get => cornerRadius; set { cornerRadius = Mathf.Max(0f, value); ApplyProperties(); } }
+
+        private void OnEnable()
+        {
+            EnsureMaterial();
+            SyncCutoutHeightWithOrientation();
+            ApplyProperties();
+        }
+
+        private void Update()
+        {
+            SyncCutoutHeightWithOrientation();
+        }
+
+        private void OnValidate()
+        {
+            sideInset = Mathf.Max(0f, sideInset);
+            cutoutHeight = Mathf.Max(0f, cutoutHeight);
+            cornerRadius = Mathf.Max(0f, cornerRadius);
+            aaSoftness = Mathf.Max(0.25f, aaSoftness);
+
+            if (!isActiveAndEnabled) return;
+            EnsureMaterial();
+            ApplyProperties();
+        }
+
+        private void OnRectTransformDimensionsChange()
+        {
+            ApplyProperties();
+        }
+
+        private void OnDidApplyAnimation()
+        {
+            ApplyProperties();
+        }
+
+        private void SyncCutoutHeightWithOrientation()
+        {
+            if (!Application.isPlaying) return;
+
+            var gameManager = HyperRuntime.GameManager;
+            if (gameManager == null) return;
+
+            bool isPortrait = gameManager.IsPortrait();
+            if (lastPortraitState == isPortrait) return;
+
+            lastPortraitState = isPortrait;
+            cutoutHeight = isPortrait ? PortraitCutoutHeight : LandscapeCutoutHeight;
+            ApplyProperties();
+        }
+
+        private void OnDestroy()
+        {
+            if (materialInstance == null) return;
+
+            if (Application.isPlaying) Destroy(materialInstance);
+            else DestroyImmediate(materialInstance);
+        }
+
+        private void EnsureMaterial()
+        {
+            if (image == null) image = GetComponent<Image>();
+            if (rectTransform == null) rectTransform = transform as RectTransform;
+
+            if (materialInstance != null)
+            {
+                if (image.material != materialInstance) image.material = materialInstance;
+                return;
+            }
+
+            Shader shader = Resources.Load<Shader>(ShaderResourcePath);
+            if (shader == null) shader = Shader.Find(ShaderName);
+            if (shader == null)
+            {
+                Debug.LogWarning($"{nameof(ConcaveImage)} could not find shader '{ShaderName}'.", this);
+                return;
+            }
+
+            materialInstance = new Material(shader)
+            {
+                name = $"{name} Concave Image (Instance)",
+                hideFlags = HideFlags.HideAndDontSave
+            };
+            image.material = materialInstance;
+        }
+
+        private void ApplyProperties()
+        {
+            if (materialInstance == null || rectTransform == null) return;
+
+            Vector2 size = rectTransform.rect.size;
+            Vector2 pivot = rectTransform.pivot;
+            Vector4 spriteUV = image.sprite != null
+                ? DataUtility.GetOuterUV(image.sprite)
+                : new Vector4(0f, 0f, 1f, 1f);
+            materialInstance.SetVector(RectSizeId, new Vector4(size.x, size.y, 0f, 0f));
+            materialInstance.SetVector(PivotId, new Vector4(pivot.x, pivot.y, 0f, 0f));
+            materialInstance.SetVector(SpriteUVRectId, spriteUV);
+            materialInstance.SetFloat(SideInsetId, sideInset);
+            materialInstance.SetFloat(CutoutHeightId, cutoutHeight);
+            materialInstance.SetFloat(CornerRadiusId, cornerRadius);
+            materialInstance.SetFloat(AASoftnessId, aaSoftness);
+            image.SetMaterialDirty();
+        }
+    }
+}

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

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

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

@@ -2,6 +2,7 @@ using Hyper.Internal.Managers;
 using Hyper.Shared;
 using TMPro;
 using UnityEngine;
+using UnityEngine.Serialization;
 using UnityEngine.UI;
 
 namespace Hyper.Internal
@@ -9,7 +10,10 @@ namespace Hyper.Internal
     internal class ControlBar : MonoBehaviour
     {
         [Header("UI Components")]
-        public Image roundedBG;
+        [Tooltip("Legacy content container. Its Image is disabled; it is no longer used as the visual control-bar background.")]
+        public GameObject roundedBG;
+        [Tooltip("Procedural control-bar background containing the ConcaveImage component.")]
+        [SerializeField] private Image controlBarBackground;
         [SerializeField] TextMeshProUGUI scoreText;
         [SerializeField] private RectTransform scoreTextRect;
         [SerializeField] private RectTransform timerText;
@@ -17,6 +21,9 @@ namespace Hyper.Internal
         [SerializeField] private Image pauseButtonImage;
         [SerializeField] private Image pauseBarsImage;
         [SerializeField] private Button connectionStatusIcon;
+        [Tooltip("Shown only for the Hearts Left layout in landscape orientation.")]
+        [FormerlySerializedAs("pcLandscapeHeartsDivider")]
+        [SerializeField] private GameObject landscapeHeartsDivider;
 
         [Header("Sprites")]
         [SerializeField] Sprite pauseBarsLight;
@@ -33,6 +40,8 @@ namespace Hyper.Internal
         private TextMeshProUGUI _timerTextComponent;
         private LivesDisplay _livesDisplay;
         private HealthBarDisplay _healthBarDisplay;
+        private GameObject _pauseButtonRoot;
+        private GameObject _replayMarker;
 
         // Layout constants
         private const float CENTERED_LAYOUT_SCORE_Y = 31f;
@@ -46,6 +55,9 @@ namespace Hyper.Internal
         private const float DEFAULT_LAYOUT_SCORE_FONT_SIZE = 100f;
         private const float DEFAULT_LAYOUT_TIMER_FONT_SIZE = 60f;
 
+        private const float LANDSCAPE_HEARTS_TIMER_X = -80f;
+        private const float LANDSCAPE_HEARTS_SCORE_X = 285.2284f;
+
         // Theme constants
         private const string LIGHT_THEME_BG_COLOR = "#F5F5F5";
         private const string LIGHT_THEME_TEXT_COLOR = "#434343";
@@ -58,6 +70,7 @@ namespace Hyper.Internal
         void Awake()
         {
             _gameManager = HyperRuntime.GameManager;
+            ConfigureControlBarBackground();
             CacheTextComponents();
 
             RectTransform rect = transform.GetComponent<RectTransform>();
@@ -65,12 +78,26 @@ namespace Hyper.Internal
             ConfigureLayout();
             ConfigureTheme();
 
-            connectionStatusIcon.onClick.AddListener(ShowConnectionLostStatus);
+            ConfigureReplayState();
+
+            connectionStatusIcon?.onClick.AddListener(ShowConnectionLostStatus);
+        }
+
+        private void ConfigureControlBarBackground()
+        {
+            if (controlBarBackground == null)
+            {
+                ConcaveImage concaveImage = GetComponentInChildren<ConcaveImage>(true);
+                if (concaveImage != null)
+                {
+                    controlBarBackground = concaveImage.GetComponent<Image>();
+                }
+            }
         }
 
         private void OnDestroy()
         {
-            connectionStatusIcon.onClick.RemoveListener(ShowConnectionLostStatus);
+            connectionStatusIcon?.onClick.RemoveListener(ShowConnectionLostStatus);
         }
 
         private void CacheTextComponents()
@@ -93,10 +120,26 @@ namespace Hyper.Internal
 
         private void ConfigureLayout()
         {
+            bool useLandscapeHeartsLayout =
+                _gameManager.ControlBarLayout == ControlBarLayout.HeartsLeft &&
+                !_gameManager.IsPortrait();
+
+            if (landscapeHeartsDivider != null)
+            {
+                landscapeHeartsDivider.SetActive(useLandscapeHeartsLayout);
+            }
+
             switch (_gameManager.ControlBarLayout)
             {
                 case ControlBarLayout.HeartsLeft:
-                    ApplyCenteredLayout();
+                    if (useLandscapeHeartsLayout)
+                    {
+                        ApplyLandscapeHeartsLayout();
+                    }
+                    else
+                    {
+                        ApplyCenteredLayout();
+                    }
                     SetupLivesDisplay();
                     break;
                 case ControlBarLayout.HealthBarLeft:
@@ -215,6 +258,24 @@ namespace Hyper.Internal
             _timerTextComponent.alignment = TextAlignmentOptions.MidlineLeft;
         }
 
+        private void ApplyLandscapeHeartsLayout()
+        {
+            // Begin with the standard score/timer sizing and vertical positions.
+            ApplyDefaultLayout();
+
+            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.anchoredPosition = new Vector2(LANDSCAPE_HEARTS_TIMER_X, DEFAULT_LAYOUT_TIMER_Y);
+            _timerTextComponent.alignment = TextAlignmentOptions.MidlineRight;
+
+            scoreTextRect.anchorMin = new Vector2(0.5f, 0.5f);
+            scoreTextRect.anchorMax = new Vector2(0.5f, 0.5f);
+            scoreTextRect.pivot = new Vector2(0.5f, 0.5f);
+            scoreTextRect.anchoredPosition = new Vector2(LANDSCAPE_HEARTS_SCORE_X, DEFAULT_LAYOUT_SCORE_Y);
+            _scoreTextComponent.alignment = TextAlignmentOptions.MidlineLeft;
+        }
+
         private void ConfigureTheme()
         {
             switch (_gameManager.ControlBarTheme)
@@ -230,7 +291,7 @@ namespace Hyper.Internal
 
         private void ApplyDarkTheme()
         {
-            roundedBG.color = Color.black;
+            if (controlBarBackground != null) controlBarBackground.color = Color.black;
             safeAreaFillerBG.color = Color.black;
 
             _scoreTextComponent.color = Color.white;
@@ -245,7 +306,7 @@ namespace Hyper.Internal
             Color bgColor = HexToColor(LIGHT_THEME_BG_COLOR);
             Color textColor = HexToColor(LIGHT_THEME_TEXT_COLOR);
 
-            roundedBG.color = bgColor;
+            if (controlBarBackground != null) controlBarBackground.color = bgColor;
             safeAreaFillerBG.color = bgColor;
 
             _scoreTextComponent.color = textColor;
@@ -257,10 +318,29 @@ namespace Hyper.Internal
 
         private void ShowConnectionLostStatus()
         {
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode) return;
             // Show the connection lost status
             _gameManager.ShowConnectionLost();
         }
 
+        private void ConfigureReplayState()
+        {
+            Transform[] children = GetComponentsInChildren<Transform>(true);
+            for (int i = 0; i < children.Length; i++)
+            {
+                if (children[i].name == "PauseButton") _pauseButtonRoot = children[i].gameObject;
+                else if (children[i].name == "Replay Marker") _replayMarker = children[i].gameObject;
+            }
+
+            bool replay = HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode;
+            if (_pauseButtonRoot != null) _pauseButtonRoot.SetActive(!replay);
+            if (_replayMarker != null)
+            {
+                _replayMarker.SetActive(replay);
+            }
+            if (connectionStatusIcon != null) connectionStatusIcon.gameObject.SetActive(!replay);
+        }
+
         public void UpdateScoreLabel()
         {
             int currentScore = HyperRuntime.DataManager.CurrentScore;

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

@@ -2,6 +2,7 @@ using Hyper.Internal.Managers;
 using UnityEngine;
 using UnityEngine.EventSystems;
 using UnityEngine.UI;
+using Hyper.Shared;
 
 namespace Hyper.Internal
 {
@@ -31,6 +32,7 @@ namespace Hyper.Internal
 
         public void OnPointerDown(PointerEventData eventData)
         {
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode) return;
             if (!_isTypeRush)
             {
                 _gameManager.PauseGame();
@@ -39,10 +41,11 @@ namespace Hyper.Internal
 
         public void OnPointerUp(PointerEventData eventData)
         {
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode) return;
             if (_isTypeRush)
             {
                 _gameManager.PauseGame();
             }
         }
     }
-}
+}