app.hypergames.hypersdk 1.8.19 → 1.8.21

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [1.8.21](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.20...v1.8.21) (2026-07-08)
+
+
+### Bug Fixes
+
+* smooth tutorial loader and media switching ([b4cfbef](https://github.com/mvmhyper/hyper-sdk/commit/b4cfbef45d5544e7c5dfa37f702acb9f7be67548))
+
+## [1.8.20](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.19...v1.8.20) (2026-07-07)
+
+
+### Bug Fixes
+
+* **tutorial:** enhance display with rounded corners ([f240203](https://github.com/mvmhyper/hyper-sdk/commit/f240203d4ad14df7c6c481df1d656ea4bc356ad7))
+* update tutorial modal content flow ([a6fb29b](https://github.com/mvmhyper/hyper-sdk/commit/a6fb29b092cd7902493031c87868df58a9775500))
+
 ## [1.8.19](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.18...v1.8.19) (2026-06-23)
 
 

package/HyperLoader.unity

@@ -304,7 +304,7 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 1059.0492, y: -280.1698}
+  m_AnchoredPosition: {x: 489.112, y: -280.1698}
   m_SizeDelta: {x: 1044.9, y: 239.347}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &751153944
@@ -840,7 +840,7 @@ GameObject:
   m_Component:
   - component: {fileID: 1064166296}
   m_Layer: 0
-  m_Name: __HyperSDK_BuildMarker_639142756136327602
+  m_Name: __HyperSDK_BuildMarker_639190246458492972
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
@@ -1092,7 +1092,7 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 1059.0492, y: -133.2274}
+  m_AnchoredPosition: {x: 489.112, y: -133.2274}
   m_SizeDelta: {x: 875, y: 54.5378}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!1 &2874543288936963705

package/Runtime/Internal/Managers/DataManager.cs

@@ -403,7 +403,33 @@ namespace Hyper.Internal.Managers
             try
             {
                 var data = JsonUtility.FromJson<TutorialResourceData>(jsonData);
-                if (data.type == "video")
+                if (data.cards != null && data.cards.Length > 0)
+                {
+                    TutorialCardData[] cards = new TutorialCardData[data.cards.Length];
+
+                    for (int i = 0; i < data.cards.Length; i++)
+                    {
+                        TutorialCardResourceData sourceCard = data.cards[i];
+                        string type = (sourceCard.type ?? string.Empty).ToLowerInvariant();
+                        bool isVideo = type == "video";
+
+                        cards[i] = new TutorialCardData
+                        {
+                            type = isVideo ? TutorialType.video : TutorialType.images,
+                            position = sourceCard.position,
+                            description = sourceCard.description,
+                            videoUrl = isVideo ? sourceCard.url : null,
+                            imageUrl = isVideo ? null : sourceCard.url
+                        };
+                    }
+
+                    TutorialData = new TutorialData
+                    {
+                        type = cards[0].type,
+                        cards = cards
+                    };
+                }
+                else if (data.type == "video")
                 {
                     TutorialData = new TutorialData
                     {
@@ -440,6 +466,16 @@ namespace Hyper.Internal.Managers
             public string type;
             public string url;
             public string[] urls;
+            public TutorialCardResourceData[] cards;
+        }
+
+        [Serializable]
+        private class TutorialCardResourceData
+        {
+            public string type;
+            public string url;
+            public string description;
+            public int position;
         }
 
         #endregion
@@ -457,4 +493,4 @@ namespace Hyper
     }
 
     #endregion
-}
+}

package/Runtime/Internal/Managers/GameManager.cs

@@ -6,10 +6,10 @@ using UnityEngine;
 using UnityEngine.EventSystems;
 using UnityEngine.SceneManagement;
 using UnityEngine.UI;
-using System.Linq;
 using Newtonsoft.Json;
 using Hyper.Internal;
 using Hyper.Shared;
+using System.Linq;
 
 
 namespace Hyper.Internal.Managers
@@ -505,11 +505,13 @@ namespace Hyper.Internal.Managers
         {
             bool isPortrait = ResolvePortraitFlag();
             var activeModal = EnsureTutorialModal(isPortrait);
+            _tutorialModalComponent = activeModal.GetComponent<TutorialModal>();
+            MoveTutorialModalToCanvasTop(activeModal);
 
             if (showModal)
             {
+                MoveTutorialModalToCanvasTop(activeModal);
                 _tutorialModalComponent.Show();
-                activeModal.transform.SetAsLastSibling();
             }
         }
 
@@ -1001,8 +1003,8 @@ namespace Hyper.Internal.Managers
 
             _canvasScaler = _canvas.GetComponent<CanvasScaler>();
             _canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
-            _canvasScaler.referenceResolution = new Vector2(1080, 1920);
-            _canvasScaler.matchWidthOrHeight = IsPortrait() ? 0.43f : 0.593f;
+            _canvasScaler.referenceResolution = new Vector2(1080, 2160);
+            _canvasScaler.matchWidthOrHeight = IsPortrait() ? 1f : 0.593f;
 
             CreateHyperCanvasSafeArea();
             CreateHyperCanvasBlockerUI();
@@ -1552,6 +1554,7 @@ namespace Hyper.Internal.Managers
                     _tutorialLandscapeModal.SetActive(false);
                 }
 
+                MoveTutorialModalToCanvasTop(_tutorialPortraitModal);
                 return _tutorialPortraitModal;
             }
             else
@@ -1570,6 +1573,7 @@ namespace Hyper.Internal.Managers
                     _tutorialPortraitModal.SetActive(false);
                 }
 
+                MoveTutorialModalToCanvasTop(_tutorialLandscapeModal);
                 return _tutorialLandscapeModal;
             }
         }
@@ -1584,32 +1588,22 @@ namespace Hyper.Internal.Managers
 
             GameObject prefab = Resources.Load<GameObject>(prefabPath);
             GameObject instance = Instantiate(prefab);
-            instance.transform.SetParent(_safeArea.transform, false);
+            instance.transform.SetParent(_canvas.transform, false);
 
             RectTransform rectTransform = instance.GetComponent<RectTransform>();
             if (rectTransform != null)
             {
                 rectTransform.anchorMin = Vector2.zero;
                 rectTransform.anchorMax = Vector2.one;
-                rectTransform.pivot = new Vector2(0.5f, 0f);
-
-                if (portrait)
-                {
-                    SafeArea safeArea = FindFirstObjectByType<SafeArea>();
-                    if (safeArea != null)
-                    {
-                        RectTransform safeAreaRect = safeArea.GetComponent<RectTransform>();
-                        if (safeAreaRect != null)
-                        {
-                            rectTransform.anchoredPosition = new Vector2(
-                                rectTransform.anchoredPosition.x,
-                                -safeAreaRect.rect.height
-                            );
-                        }
-                    }
-                }
+                rectTransform.offsetMin = Vector2.zero;
+                rectTransform.offsetMax = Vector2.zero;
+                rectTransform.pivot = new Vector2(0.5f, 0.5f);
+                rectTransform.anchoredPosition = Vector2.zero;
+                rectTransform.sizeDelta = Vector2.zero;
             }
 
+            MoveTutorialModalToCanvasTop(instance);
+
             if (portrait)
             {
                 _tutorialPortraitModal = instance;
@@ -1622,6 +1616,23 @@ namespace Hyper.Internal.Managers
             _tutorialModalComponent = instance.GetComponent<TutorialModal>();
         }
 
+        private void MoveTutorialModalToCanvasTop(GameObject tutorialModal)
+        {
+            if (tutorialModal == null) return;
+            if (_canvas == null) CreateCanvas();
+
+            RectTransform rectTransform = tutorialModal.GetComponent<RectTransform>();
+            tutorialModal.transform.SetParent(_canvas.transform, false);
+            tutorialModal.transform.SetAsLastSibling();
+
+            if (rectTransform == null) return;
+
+            rectTransform.anchorMin = Vector2.zero;
+            rectTransform.anchorMax = Vector2.one;
+            rectTransform.offsetMin = Vector2.zero;
+            rectTransform.offsetMax = Vector2.zero;
+        }
+
         private void HideTutorialModals()
         {
             if (_tutorialPortraitModal != null) _tutorialPortraitModal.SetActive(false);
@@ -1663,4 +1674,4 @@ namespace Hyper.Internal.Managers
 
         #endregion
     }
-}
+}

package/Runtime/Internal/UI/Animation/SlideUp.cs

@@ -62,6 +62,11 @@ namespace Hyper.Internal
         }
 
         public void SlideUpAnimation()
+        {
+            SlideUpAnimation(0.5f);
+        }
+
+        public void SlideUpAnimation(float duration)
         {
             if (!isInitialized || rectTransform == null)
             {
@@ -82,7 +87,7 @@ namespace Hyper.Internal
             rectTransform.anchoredPosition = new Vector2(originalAnchoredPosition.x, offScreenY);
 
             // Animate to original position
-            rectTransform.DOAnchorPosY(originalAnchoredPosition.y, 0.5f)
+            rectTransform.DOAnchorPosY(originalAnchoredPosition.y, duration)
                 .SetEase(HyperTween.Ease.OutQuad)
                 .SetUpdate(true);
         }

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

@@ -0,0 +1,146 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    [RequireComponent(typeof(RawImage))]
+    public class RoundedRawImage : MonoBehaviour
+    {
+        private const string ShaderResourcePath = "Shaders/RoundedRawImage";
+        private const string MaterialResourcePath = "Materials/RoundedRawImage";
+        private static readonly int RadiusId = Shader.PropertyToID("_Radius");
+        private static readonly int CornerRadiiId = Shader.PropertyToID("_CornerRadii");
+        private static readonly int SoftnessId = Shader.PropertyToID("_Softness");
+        private static readonly int RectSizeId = Shader.PropertyToID("_RectSize");
+        private static readonly int PivotId = Shader.PropertyToID("_Pivot");
+        private static readonly int UseUIAlphaClipId = Shader.PropertyToID("_UseUIAlphaClip");
+
+        [SerializeField] private float radius = 28f;
+        [SerializeField] private float softness = 1.5f;
+        [SerializeField] private Vector4 cornerRadii = new Vector4(28f, 28f, 28f, 28f);
+        [SerializeField] private Vector2 materialPivotReference = new Vector2(0.5f, 0.4535f);
+
+        private RawImage rawImage;
+        private RectTransform rectTransform;
+        private RectTransform parentRectTransform;
+        private Material materialInstance;
+
+        internal void Configure(float cornerRadius, float edgeSoftness)
+        {
+            Configure(new Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius), edgeSoftness);
+        }
+
+        internal void Configure(Vector4 radii, float edgeSoftness)
+        {
+            cornerRadii = new Vector4(
+                Mathf.Max(0f, radii.x),
+                Mathf.Max(0f, radii.y),
+                Mathf.Max(0f, radii.z),
+                Mathf.Max(0f, radii.w)
+            );
+            radius = Mathf.Max(cornerRadii.x, cornerRadii.y, cornerRadii.z, cornerRadii.w);
+            softness = Mathf.Max(0.001f, edgeSoftness);
+            EnsureMaterial();
+            ApplyProperties(true);
+        }
+
+        private void Awake()
+        {
+            EnsureMaterial();
+            ApplyProperties(true);
+        }
+
+        private void OnEnable()
+        {
+            EnsureMaterial();
+            ApplyProperties(true);
+        }
+
+        private void LateUpdate()
+        {
+            ApplyProperties(false);
+        }
+
+        private void OnValidate()
+        {
+            if (!Application.isPlaying || !isActiveAndEnabled) return;
+
+            EnsureMaterial();
+            ApplyProperties(true);
+        }
+
+        private void OnDestroy()
+        {
+            if (materialInstance != null)
+            {
+                Destroy(materialInstance);
+                materialInstance = null;
+            }
+        }
+
+        private void EnsureMaterial()
+        {
+            if (rawImage == null) rawImage = GetComponent<RawImage>();
+            if (rectTransform == null) rectTransform = transform as RectTransform;
+            if (parentRectTransform == null && transform.parent != null)
+            {
+                parentRectTransform = transform.parent as RectTransform;
+            }
+
+            if (materialInstance != null)
+            {
+                rawImage.material = materialInstance;
+                return;
+            }
+
+            Material sourceMaterial = Resources.Load<Material>(MaterialResourcePath);
+            if (sourceMaterial != null)
+            {
+                materialInstance = new Material(sourceMaterial)
+                {
+                    name = "Tutorial Rounded Raw Image (Instance)"
+                };
+
+                rawImage.material = materialInstance;
+                return;
+            }
+
+            Shader shader = Resources.Load<Shader>(ShaderResourcePath);
+            if (shader == null)
+            {
+                shader = Shader.Find("Hyper/UI/Rounded Raw Image");
+            }
+
+            if (shader == null)
+            {
+                Debug.LogWarning("RoundedRawImage could not find the Hyper/UI/Rounded Raw Image shader.");
+                return;
+            }
+
+            materialInstance = new Material(shader)
+            {
+                name = "Tutorial Rounded Raw Image (Instance)"
+            };
+
+            rawImage.material = materialInstance;
+        }
+
+        private void ApplyProperties(bool force)
+        {
+            if (materialInstance == null || rectTransform == null) return;
+
+            RectTransform sizeSource = parentRectTransform != null && parentRectTransform.name.Contains("Display Area") ?
+                parentRectTransform : rectTransform;
+            Vector2 size = sizeSource.rect.size;
+            Vector2 pivot = materialPivotReference;
+
+            materialInstance.SetFloat(RadiusId, radius);
+            materialInstance.SetVector(CornerRadiiId, cornerRadii);
+            materialInstance.SetFloat(SoftnessId, softness);
+            materialInstance.SetVector(RectSizeId, new Vector4(size.x, size.y, 0f, 0f));
+            materialInstance.SetVector(PivotId, new Vector4(pivot.x, pivot.y, 0f, 0f));
+            materialInstance.SetFloat(UseUIAlphaClipId, 1f);
+            materialInstance.EnableKeyword("UNITY_UI_ALPHACLIP");
+        }
+    }
+}

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

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

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

@@ -53,10 +53,12 @@ namespace Hyper.Internal
             if (_gameManager.IsPracticeMode && footerHLG != null)
                 footerHLG.spacing = HyperRuntime.GameContent.IsPracticeMenu ? 246 : 42;
 
+#if !UNITY_EDITOR
             if (HyperRuntime.BackendManager.tutorialDoesNotExist)
             {
                 UpdateTutorialButtonSpacing();
             }
+#endif
         }
 
         void OnDestroy()

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

@@ -28,6 +28,11 @@ namespace Hyper.Internal
         // Start is called before the first frame update
         void OnEnable()
         {
+#if UNITY_EDITOR
+            EnableTutorialButton();
+            return;
+#endif
+
             if (HyperRuntime.BackendManager.tutorialDoesNotExist)
             {
                 DisableTutorialButton();
@@ -50,6 +55,11 @@ namespace Hyper.Internal
 
         void DisableTutorialButton()
         {
+#if UNITY_EDITOR
+            EnableTutorialButton();
+            return;
+#endif
+
             tutorialEnabled.gameObject.SetActive(false);
             tutorialDisabled.gameObject.SetActive(true);
 

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

@@ -33,10 +33,13 @@ namespace Hyper.Internal
 
         void OnEnable()
         {
-            // Fade in and enable
-            tutorialLoaderModalCG.DOFade(1, 0.3f).SetUpdate(true);
+            KillTweens();
+            tutorialLoaderModalCG.alpha = 0f;
 
             HandleLoadingTutorial();
+
+            // Fade in after loading state has reset its own tweens.
+            tutorialLoaderModalCG.DOFade(1, 0.3f).SetUpdate(true);
         }
 
         void OnDestroy()
@@ -56,9 +59,12 @@ namespace Hyper.Internal
 
         void HandleTutorialLoadingComplete()
         {
+            if (!gameObject.activeInHierarchy) return;
+
             // Debug.Log($"Tutorial Loading Completed!");
 
             // Fade out and disable
+            tutorialLoaderModalCG.DOKill();
             tutorialLoaderModalCG.DOFade(0, 0.15f).SetDelay(2f).SetUpdate(true).OnComplete(() =>
             {
                 tutorialLoaderModalCG.gameObject.SetActive(false);
@@ -68,10 +74,19 @@ namespace Hyper.Internal
         void HandleLoadingTutorial()
         {
             KillTweens();
+            bool shouldFailEditorRetry = false;
 
             if (loadingFailedOnce)
             {
+#if UNITY_EDITOR
+                TutorialModal tutorialModal = GetComponentInParent<TutorialModal>(true);
+                if (tutorialModal == null || !tutorialModal.TryStartEditorTutorialLoad())
+                {
+                    shouldFailEditorRetry = true;
+                }
+#else
                 HyperRuntime.BackendManager.GetTutorial(() => { });
+#endif
                 
                 // Move UI from failed position back to start position
                 rectTransform.DOAnchorPos(loaderStartPosition, 0.5f).SetUpdate(true).SetEase(HyperTween.Ease.OutQuad);
@@ -93,11 +108,23 @@ namespace Hyper.Internal
 
             loaderText.SetActive(false);
             loaderTextTween.SetActive(true);
+
+            if (shouldFailEditorRetry)
+            {
+                StartCoroutine(InvokeTutorialFetchFailedNextFrame());
+            }
+        }
+
+        private System.Collections.IEnumerator InvokeTutorialFetchFailedNextFrame()
+        {
+            yield return null;
+            _eventManager.InvokeTutorialFetchFailedEvent();
         }
 
         void HandleTutorialFailed()
         {
             KillTweens();
+            tutorialLoaderModalCG.alpha = 1f;
 
             loaderTextTween.SetActive(false);
             loaderText.SetActive(true);
@@ -119,8 +146,8 @@ namespace Hyper.Internal
         {
             rectTransform.DOKill();
             loadingFailedElements.DOKill();
+            tutorialLoaderModalCG.DOKill();
         }
 
-
     }
-}
+}