app.hypergames.hypersdk 1.8.19 → 1.8.21

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

@@ -6,13 +6,24 @@ using UnityEngine;
 using UnityEngine.UI;
 using UnityEngine.Video;
 using UnityEngine.Networking;
+using Hyper.Internal.Animation;
 using Hyper.Internal.Managers;
 using Hyper.Shared;
+using TMPro;
 
 namespace Hyper.Internal
 {
     internal class TutorialModal : MonoBehaviour
     {
+        // Keep the seek wiring available while the tutorial video uses a passive progress bar.
+        private const bool VideoSeekingEnabled = false;
+        private const float LoaderFadeOutDelay = 2.15f;
+        private const float SlideInDuration = 0.33f;
+        private const float ContentFadeInDuration = 0.28f;
+        private const float ContentFadeOutDuration = 0.18f;
+        private const float MediaFadeInDuration = 0.18f;
+        private const float VideoRevealDelay = 0.05f;
+        private const float HiddenPreloadPlayDuration = 0.75f;
 
 #if UNITY_WEBGL && !UNITY_EDITOR
     [DllImport("__Internal")]
@@ -23,20 +34,25 @@ namespace Hyper.Internal
         private CanvasGroup tutorialCG;
 
         [SerializeField] TutorialLoaderModal tutorialLoaderModal;
+        [SerializeField] private CanvasGroup tutorialContentGroup;
 
         [Header("Display Components")]
         [SerializeField] private RawImage tutorialDisplayP;
         [SerializeField] private RawImage tutorialDisplayL;
         [SerializeField] private VideoPlayer videoPlayer;
+        [SerializeField] private RawImage tutorialImageDisplay;
+        [SerializeField] private TMP_Text descriptionText;
+
+#if UNITY_EDITOR
+        [Header("Editor Tutorial Test")]
+        [SerializeField] private EditorTutorialCard[] editorTutorialCards;
+        [SerializeField] private Vector2 editorLoadDelayRange = new Vector2(1f, 2f);
+#endif
 
         [Header("Video Textures")]
         [SerializeField] private RenderTexture tutorialVideoTextureP;
         [SerializeField] private RenderTexture tutorialVideoTextureL;
 
-        [Header("Aspect Ratio Fitters")]
-        [SerializeField] private AspectRatioFitter aspectRatioFitterP;
-        [SerializeField] private AspectRatioFitter aspectRatioFitterL;
-
         [Header("UI Controls")]
         [SerializeField] private Slider timeSlider;
         [SerializeField] private Button backButton;
@@ -46,16 +62,39 @@ namespace Hyper.Internal
         [SerializeField] private Transform indicatorParent;
         [SerializeField] private GameObject indicatorPrefab;
         private Sprite[] tutorialImages;
+        private readonly List<TutorialCardData> tutorialCards = new List<TutorialCardData>();
         private RawImage currentDisplay;
         private int currentImageIndex = 0;
+        private int currentCardIndex = 0;
         private bool isDraggingSlider = false;
         private float cachedVideoLength = 0f;
         private Coroutine updateVideoTimeCo = null;
+        private Coroutine editorTutorialLoadCo = null;
+        private Coroutine hiddenPreloadCloseCo = null;
+        private Coroutine mediaDisplayFadeCo = null;
         private TutorialData tutorialData;
+        private bool isClosing;
+        private bool hasInvokedTutorialLoadComplete;
+        private bool hasPreparedTutorialContent;
+        private bool isDirectContentOpen;
+        private bool contentRevealScheduled;
+        private HyperTween.TweenHandle contentRevealDelayTween;
 
         private EventManager _eventManager;
         private DataManager _dataManager;
 
+#if UNITY_EDITOR
+        [Serializable]
+        private class EditorTutorialCard
+        {
+            public TutorialType type = TutorialType.video;
+            public VideoClip videoClip;
+            public Sprite image;
+            [TextArea] public string description;
+            public int position;
+        }
+#endif
+
         private void Awake()
         {
             _eventManager = HyperRuntime.EventManager;
@@ -63,31 +102,32 @@ namespace Hyper.Internal
 
             slideUp = GetComponent<SlideUp>();
             tutorialCG = GetComponent<CanvasGroup>();
+            Hide();
 
             tutorialLoaderModal.gameObject.SetActive(true);
 
             _eventManager.OnTutorialResourcesReferenced += ShowTutorialBasedOnType;
+            _eventManager.OnTutorialLoadingComplete += HandleTutorialLoadingComplete;
         }
 
         void OnEnable()
         {
             SetupSliderControls();
 
+            if (hasPreparedTutorialContent) return;
+
             if (_dataManager.HasReferencedTutorialResources)
             {
-                // ShowTutorialBasedOnType();
-                if (tutorialData != null && tutorialData.type == TutorialType.video)
-                {
-                    PlayCurrentVideo();
-                }
-                else if(tutorialData != null && tutorialData.type == TutorialType.images)
-                {
-                    ShowImagesTutorial(tutorialData);
-                }
+                ShowTutorialData(_dataManager.TutorialData);
             }
             else
             {
-                _eventManager.InvokeTutorialFetchFailedEvent();
+#if UNITY_EDITOR
+                if (TryStartEditorTutorialLoad())
+                {
+                    return;
+                }
+#endif
             }
         }
 
@@ -99,11 +139,47 @@ namespace Hyper.Internal
 
         public void Show()
         {
+            isClosing = false;
+            isDirectContentOpen = false;
+            contentRevealScheduled = false;
+            CancelHiddenPreloadClose();
+            HideTutorialContent();
             tutorialCG.alpha = 1f;
             tutorialCG.interactable = true;
             tutorialCG.blocksRaycasts = true;
 
-            slideUp.SlideUpAnimation();
+            slideUp.SlideUpAnimation(SlideInDuration);
+
+            if (CanShowPreparedTutorialImmediately())
+            {
+                ShowPreparedTutorialImmediately();
+                return;
+            }
+
+            if (tutorialLoaderModal != null)
+            {
+                tutorialLoaderModal.gameObject.SetActive(true);
+            }
+
+            if (_dataManager != null && _dataManager.HasReferencedTutorialResources)
+            {
+                ShowTutorialData(_dataManager.TutorialData);
+            }
+#if UNITY_EDITOR
+            else
+            {
+                if (!TryStartEditorTutorialLoad())
+                {
+                    _eventManager.InvokeTutorialFetchFailedEvent();
+                }
+            }
+#endif
+#if !UNITY_EDITOR
+            else
+            {
+                HyperRuntime.BackendManager.GetTutorial(() => { });
+            }
+#endif
         }
 
         private void Hide()
@@ -111,6 +187,143 @@ namespace Hyper.Internal
             tutorialCG.alpha = 0f;
             tutorialCG.interactable = false;
             tutorialCG.blocksRaycasts = false;
+            // HideTutorialContent();
+        }
+
+        private bool CanShowPreparedTutorialImmediately()
+        {
+            return hasPreparedTutorialContent && tutorialData != null;
+        }
+
+        private void ShowPreparedTutorialImmediately()
+        {
+            isDirectContentOpen = true;
+
+            if (tutorialLoaderModal != null)
+            {
+                tutorialLoaderModal.gameObject.SetActive(false);
+            }
+
+            FadeTutorialContentIn(SlideInDuration);
+            ShowTutorialData(tutorialData);
+        }
+
+        private void ShowTutorialContentImmediate()
+        {
+            if (tutorialContentGroup == null) return;
+
+            tutorialContentGroup.DOKill();
+            tutorialContentGroup.gameObject.SetActive(true);
+            tutorialContentGroup.alpha = 1f;
+            tutorialContentGroup.interactable = true;
+            tutorialContentGroup.blocksRaycasts = true;
+        }
+
+        private void FadeTutorialContentIn(float delay = 0f)
+        {
+            if (tutorialContentGroup == null) return;
+
+            contentRevealScheduled = true;
+            contentRevealDelayTween?.Kill();
+            contentRevealDelayTween = null;
+            tutorialContentGroup.DOKill();
+            tutorialContentGroup.gameObject.SetActive(true);
+            tutorialContentGroup.alpha = 0f;
+            tutorialContentGroup.interactable = false;
+            tutorialContentGroup.blocksRaycasts = false;
+
+            if (delay > 0f)
+            {
+                contentRevealDelayTween = HyperTween.DelayedCall(delay, StartTutorialContentFade)
+                    .SetUpdate(true);
+                return;
+            }
+
+            StartTutorialContentFade();
+        }
+
+        private void StartTutorialContentFade()
+        {
+            if (tutorialContentGroup == null) return;
+
+            contentRevealDelayTween = null;
+            tutorialContentGroup.DOKill();
+            tutorialContentGroup.gameObject.SetActive(true);
+            tutorialContentGroup.interactable = true;
+            tutorialContentGroup.blocksRaycasts = true;
+            var fadeTween = tutorialContentGroup.DOFade(1f, ContentFadeInDuration)
+                .SetEase(HyperTween.Ease.OutQuad)
+                .SetUpdate(true);
+        }
+
+        private void HandleTutorialLoadingComplete()
+        {
+            if (!isActiveAndEnabled || isClosing) return;
+
+            hasPreparedTutorialContent = true;
+
+            if (IsHiddenPreload())
+            {
+                ScheduleHiddenPreloadClose();
+                return;
+            }
+
+            if (isDirectContentOpen)
+            {
+                if (!contentRevealScheduled)
+                {
+                    FadeTutorialContentIn(SlideInDuration);
+                }
+                return;
+            }
+
+            if (tutorialContentGroup == null) return;
+            if (contentRevealScheduled) return;
+
+            FadeTutorialContentIn(LoaderFadeOutDelay);
+        }
+
+        private void HideTutorialContent()
+        {
+            if (tutorialContentGroup == null) return;
+
+            contentRevealScheduled = false;
+            contentRevealDelayTween?.Kill();
+            contentRevealDelayTween = null;
+            tutorialContentGroup.DOKill();
+            tutorialContentGroup.alpha = 0f;
+            tutorialContentGroup.interactable = false;
+            tutorialContentGroup.blocksRaycasts = false;
+        }
+
+        private bool IsHiddenPreload()
+        {
+            return tutorialCG != null && tutorialCG.alpha <= 0.001f && !tutorialCG.blocksRaycasts && !tutorialCG.interactable;
+        }
+
+        private void ScheduleHiddenPreloadClose()
+        {
+            CancelHiddenPreloadClose();
+            hiddenPreloadCloseCo = StartCoroutine(CloseHiddenPreloadAfterPreview());
+        }
+
+        private IEnumerator CloseHiddenPreloadAfterPreview()
+        {
+            yield return new WaitForSecondsRealtime(HiddenPreloadPlayDuration);
+
+            hiddenPreloadCloseCo = null;
+
+            if (!isActiveAndEnabled || isClosing || !IsHiddenPreload()) yield break;
+
+            FinishClose();
+        }
+
+        private void CancelHiddenPreloadClose()
+        {
+            if (hiddenPreloadCloseCo == null) return;
+
+            StopCoroutine(hiddenPreloadCloseCo);
+            hiddenPreloadCloseCo = null;
         }
 
         private void SetupSliderControls()
@@ -119,19 +332,25 @@ namespace Hyper.Internal
 
             timeSlider.minValue = 0f;
             timeSlider.wholeNumbers = false;
-            timeSlider.onValueChanged.AddListener(OnTimeSliderChanged);
+            timeSlider.interactable = VideoSeekingEnabled;
+            timeSlider.onValueChanged.RemoveListener(OnTimeSliderChanged);
 
-            // Add event triggers for drag detection
             var eventTrigger = timeSlider.gameObject.GetComponent<UnityEngine.EventSystems.EventTrigger>();
+            if (eventTrigger != null)
+            {
+                eventTrigger.triggers.Clear();
+            }
+
+            if (!VideoSeekingEnabled) return;
+
+            timeSlider.onValueChanged.AddListener(OnTimeSliderChanged);
+
+            eventTrigger = timeSlider.gameObject.GetComponent<UnityEngine.EventSystems.EventTrigger>();
             if (eventTrigger == null)
             {
                 eventTrigger = timeSlider.gameObject.AddComponent<UnityEngine.EventSystems.EventTrigger>();
             }
 
-            // Clear existing triggers
-            eventTrigger.triggers.Clear();
-
-            // Pointer down (begin drag)
             var pointerDownEntry = new UnityEngine.EventSystems.EventTrigger.Entry
             {
                 eventID = UnityEngine.EventSystems.EventTriggerType.PointerDown
@@ -139,7 +358,6 @@ namespace Hyper.Internal
             pointerDownEntry.callback.AddListener((_) => OnSliderDragStart());
             eventTrigger.triggers.Add(pointerDownEntry);
 
-            // Pointer up (end drag)
             var pointerUpEntry = new UnityEngine.EventSystems.EventTrigger.Entry
             {
                 eventID = UnityEngine.EventSystems.EventTriggerType.PointerUp
@@ -150,11 +368,15 @@ namespace Hyper.Internal
 
         private void OnSliderDragStart()
         {
+            if (!VideoSeekingEnabled) return;
+
             isDraggingSlider = true;
         }
 
         private void OnSliderDragEnd()
         {
+            if (!VideoSeekingEnabled) return;
+
             isDraggingSlider = false;
 
             if (videoPlayer != null && videoPlayer.isPrepared)
@@ -171,8 +393,24 @@ namespace Hyper.Internal
         {
             //Debug.Log("Showing tutorial based on type");
             tutorialData = _dataManager.TutorialData;
+            ShowTutorialData(tutorialData);
+        }
 
-            if (tutorialData.type == TutorialType.video)
+        private void ShowTutorialData(TutorialData data)
+        {
+            if (data == null)
+            {
+                _eventManager.InvokeTutorialFetchFailedEvent();
+                return;
+            }
+
+            tutorialData = data;
+
+            if (tutorialData.cards != null && tutorialData.cards.Length > 0)
+            {
+                ShowMixedTutorial(tutorialData);
+            }
+            else if (tutorialData.type == TutorialType.video)
             {
                 ShowVideoTutorial(tutorialData);
             }
@@ -187,6 +425,74 @@ namespace Hyper.Internal
             }
         }
 
+#if UNITY_EDITOR
+        internal bool TryStartEditorTutorialLoad()
+        {
+            TutorialData editorData = CreateEditorTutorialData();
+            if (editorData == null) return false;
+
+            if (editorTutorialLoadCo != null)
+            {
+                StopCoroutine(editorTutorialLoadCo);
+            }
+
+            editorTutorialLoadCo = StartCoroutine(LoadEditorTutorialAfterDelay(editorData));
+            return true;
+        }
+
+        private TutorialData CreateEditorTutorialData()
+        {
+            if (editorTutorialCards == null || editorTutorialCards.Length == 0) return null;
+
+            List<TutorialCardData> editorCards = new List<TutorialCardData>();
+
+            for (int i = 0; i < editorTutorialCards.Length; i++)
+            {
+                EditorTutorialCard editorCard = editorTutorialCards[i];
+                if (editorCard == null || editorCard.type == TutorialType.None) continue;
+
+                if (editorCard.type == TutorialType.video && editorCard.videoClip == null) continue;
+                if (editorCard.type == TutorialType.images && editorCard.image == null) continue;
+
+                editorCards.Add(new TutorialCardData
+                {
+                    type = editorCard.type,
+                    videoClip = editorCard.videoClip,
+                    image = editorCard.image,
+                    description = editorCard.description,
+                    position = editorCard.position > 0 ? editorCard.position : i + 1
+                });
+            }
+
+            if (editorCards.Count == 0) return null;
+
+            editorCards.Sort((a, b) => a.position.CompareTo(b.position));
+
+            return new TutorialData
+            {
+                type = editorCards[0].type,
+                cards = editorCards.ToArray()
+            };
+        }
+
+        private IEnumerator LoadEditorTutorialAfterDelay(TutorialData editorData)
+        {
+            tutorialLoaderModal.gameObject.SetActive(true);
+            tutorialDisplayP.gameObject.SetActive(false);
+            tutorialDisplayL.gameObject.SetActive(false);
+            videoPlayer.enabled = false;
+
+            float minDelay = Mathf.Max(0f, Mathf.Min(editorLoadDelayRange.x, editorLoadDelayRange.y));
+            float maxDelay = Mathf.Max(minDelay, Mathf.Max(editorLoadDelayRange.x, editorLoadDelayRange.y));
+            float delay = UnityEngine.Random.Range(minDelay, maxDelay);
+
+            yield return new WaitForSecondsRealtime(delay);
+
+            editorTutorialLoadCo = null;
+            ShowTutorialData(editorData);
+        }
+#endif
+
         private RawImage SelectOptimalDisplay(float aspectRatio)
         {
             bool isLandscape = aspectRatio > 1.0f;
@@ -196,20 +502,393 @@ namespace Hyper.Internal
 
             if (isLandscape)
             {
-                //Debug.Log($"Content is landscape (aspect: {aspectRatio:F2}), using landscape display");
                 tutorialDisplayL.gameObject.SetActive(true);
                 return tutorialDisplayL;
             }
             else
             {
-                //Debug.Log($"Content is portrait (aspect: {aspectRatio:F2}), using portrait display");
                 tutorialDisplayP.gameObject.SetActive(true);
                 return tutorialDisplayP;
             }
         }
 
+        private void ShowMixedTutorial(TutorialData tutorialData)
+        {
+            if (tutorialData.cards == null || tutorialData.cards.Length == 0)
+            {
+                _eventManager.InvokeTutorialFetchFailedEvent();
+                return;
+            }
+
+            hasInvokedTutorialLoadComplete = false;
+            tutorialCards.Clear();
+            tutorialCards.AddRange(tutorialData.cards);
+            tutorialCards.Sort((a, b) => a.position.CompareTo(b.position));
+            currentCardIndex = 0;
+            currentImageIndex = 0;
+
+            if (tutorialDisplayP != null) tutorialDisplayP.gameObject.SetActive(false);
+            if (tutorialDisplayL != null) tutorialDisplayL.gameObject.SetActive(false);
+
+            if (TryLoadCardImagesFromUrls())
+            {
+                return;
+            }
+
+            SetupMixedTutorialCards();
+        }
+
+        private bool TryLoadCardImagesFromUrls()
+        {
+            bool hasRemoteImage = false;
+
+            for (int i = 0; i < tutorialCards.Count; i++)
+            {
+                TutorialCardData card = tutorialCards[i];
+                if (card.type == TutorialType.images && card.image == null && !string.IsNullOrEmpty(card.imageUrl))
+                {
+                    hasRemoteImage = true;
+                    break;
+                }
+            }
+
+            if (!hasRemoteImage) return false;
+
+            StartCoroutine(LoadCardImagesFromUrlsCoroutine(SetupMixedTutorialCards));
+            return true;
+        }
+
+        private IEnumerator LoadCardImagesFromUrlsCoroutine(Action onComplete)
+        {
+            for (int i = 0; i < tutorialCards.Count; i++)
+            {
+                TutorialCardData card = tutorialCards[i];
+                if (card.type != TutorialType.images || card.image != null || string.IsNullOrEmpty(card.imageUrl)) continue;
+
+                using (UnityWebRequest webRequest = UnityWebRequestTexture.GetTexture(card.imageUrl))
+                {
+                    yield return webRequest.SendWebRequest();
+
+                    if (webRequest.result == UnityWebRequest.Result.Success)
+                    {
+                        Texture2D texture = DownloadHandlerTexture.GetContent(webRequest);
+                        texture.filterMode = FilterMode.Bilinear;
+                        texture.Compress(false);
+
+                        card.image = Sprite.Create(
+                            texture,
+                            new Rect(0, 0, texture.width, texture.height),
+                            new Vector2(0.5f, 0.5f),
+                            100f,
+                            0,
+                            SpriteMeshType.Tight
+                        );
+                    }
+                }
+            }
+
+            onComplete?.Invoke();
+        }
+
+        private void SetupMixedTutorialCards()
+        {
+            RemoveInvalidTutorialCards();
+
+            if (tutorialCards.Count == 0)
+            {
+                _eventManager.InvokeTutorialFetchFailedEvent();
+                return;
+            }
+
+            backButton.gameObject.SetActive(true);
+            nextButton.gameObject.SetActive(true);
+            indicatorParent.gameObject.SetActive(true);
+
+            UpdateIndicators(tutorialCards.Count);
+            StartCoroutine(ApplyInitialIndicatorHighlightNextFrame());
+            DisplayCurrentCard(true);
+        }
+
+        private void RemoveInvalidTutorialCards()
+        {
+            for (int i = tutorialCards.Count - 1; i >= 0; i--)
+            {
+                TutorialCardData card = tutorialCards[i];
+                bool hasVideo = card.type == TutorialType.video && (card.videoClip != null || !string.IsNullOrEmpty(card.videoUrl));
+                bool hasImage = card.type == TutorialType.images && card.image != null;
+
+                if (!hasVideo && !hasImage)
+                {
+                    tutorialCards.RemoveAt(i);
+                }
+            }
+        }
+
+        private void ResetCardMediaState()
+        {
+            StopMediaDisplayFade();
+            ResetVideoProgressState();
+            HideMediaDisplay(tutorialDisplayP);
+            HideMediaDisplay(tutorialDisplayL);
+            HideMediaDisplay(tutorialImageDisplay);
+        }
+
+        private void ResetVideoProgressState()
+        {
+            cachedVideoLength = 0f;
+            isDraggingSlider = false;
+
+            if (timeSlider == null) return;
+
+            timeSlider.minValue = 0f;
+            timeSlider.maxValue = 1f;
+            timeSlider.value = 0f;
+        }
+
+        private void HideMediaDisplay(RawImage display)
+        {
+            if (display == null) return;
+
+            SetMediaDisplayAlpha(display, 0f);
+            display.gameObject.SetActive(false);
+        }
+
+        private void SetMediaDisplayAlpha(RawImage display, float alpha)
+        {
+            if (display == null) return;
+
+            Color color = display.color;
+            color.a = alpha;
+            display.color = color;
+        }
+
+        private void StopMediaDisplayFade()
+        {
+            if (mediaDisplayFadeCo == null) return;
+
+            StopCoroutine(mediaDisplayFadeCo);
+            mediaDisplayFadeCo = null;
+        }
+
+        private void FadeInMediaDisplay(RawImage display, float delay = 0f)
+        {
+            if (display == null) return;
+
+            StopMediaDisplayFade();
+            mediaDisplayFadeCo = StartCoroutine(FadeInMediaDisplayCoroutine(display, delay));
+        }
+
+        private IEnumerator FadeInMediaDisplayCoroutine(RawImage display, float delay)
+        {
+            display.gameObject.SetActive(true);
+            SetMediaDisplayAlpha(display, 0f);
+
+            if (delay > 0f)
+            {
+                yield return new WaitForSecondsRealtime(delay);
+            }
+
+            float elapsed = 0f;
+
+            while (elapsed < MediaFadeInDuration)
+            {
+                if (display == null) yield break;
+
+                elapsed += Time.unscaledDeltaTime;
+                float t = Mathf.Clamp01(elapsed / MediaFadeInDuration);
+                SetMediaDisplayAlpha(display, Mathf.SmoothStep(0f, 1f, t));
+                yield return null;
+            }
+
+            if (display != null)
+            {
+                SetMediaDisplayAlpha(display, 1f);
+            }
+
+            mediaDisplayFadeCo = null;
+        }
+
+
+
+        private void DisplayCurrentCard(bool isInitialDisplay)
+        {
+            if (currentCardIndex < 0 || currentCardIndex >= tutorialCards.Count) return;
+
+            StopVideoPlayback();
+            ResetCardMediaState();
+            TutorialCardData card = tutorialCards[currentCardIndex];
+
+            if (descriptionText != null)
+            {
+                descriptionText.text = card.description ?? string.Empty;
+            }
+
+            if (card.type == TutorialType.video)
+            {
+                DisplayVideoCard(card, isInitialDisplay);
+            }
+            else
+            {
+                DisplayImageCard(card, isInitialDisplay);
+            }
+
+            HighlightIndicator(currentCardIndex);
+            UpdateNavigationButtons(tutorialCards.Count, currentCardIndex);
+        }
+
+        private void DisplayVideoCard(TutorialCardData card, bool isInitialDisplay)
+        {
+            if (videoPlayer == null)
+            {
+                _eventManager.InvokeTutorialFetchFailedEvent();
+                return;
+            }
+
+            // Keep the media surface hidden while VideoPlayer prepares the next source.
+            currentDisplay = tutorialDisplayP;
+
+            videoPlayer.enabled = true;
+            videoPlayer.isLooping = true;
+            videoPlayer.prepareCompleted -= OnVideoPrepared;
+            videoPlayer.prepareCompleted -= OnCardVideoPrepared;
+            videoPlayer.loopPointReached -= OnLoopPointReached;
+            videoPlayer.loopPointReached += OnLoopPointReached;
+
+            if (card.videoClip != null)
+            {
+                videoPlayer.source = VideoSource.VideoClip;
+                videoPlayer.clip = card.videoClip;
+            }
+            else if (!string.IsNullOrEmpty(card.videoUrl))
+            {
+                videoPlayer.source = VideoSource.Url;
+                videoPlayer.url = card.videoUrl;
+            }
+            else
+            {
+                _eventManager.InvokeTutorialFetchFailedEvent();
+                return;
+            }
+
+            videoPlayer.prepareCompleted += OnCardVideoPrepared;
+            videoPlayer.Prepare();
+
+            timeSlider.gameObject.SetActive(true);
+            timeSlider.interactable = VideoSeekingEnabled;
+        }
+
+        private void OnCardVideoPrepared(VideoPlayer vp)
+        {
+            vp.prepareCompleted -= OnCardVideoPrepared;
+            PreventIOSFullscreen();
+
+            if (currentDisplay == null)
+            {
+                _eventManager.InvokeTutorialFetchFailedEvent();
+                return;
+            }
+
+            bool isLandscape = vp.width > vp.height;
+            RawImage targetDisplay = isLandscape ? tutorialDisplayL : tutorialDisplayP;
+            RenderTexture targetTexture = isLandscape ? tutorialVideoTextureL : tutorialVideoTextureP;
+            if (targetTexture == null) targetTexture = isLandscape ? tutorialVideoTextureP : tutorialVideoTextureL;
+
+            // Switch to the correct display
+            tutorialDisplayP.gameObject.SetActive(targetDisplay == tutorialDisplayP);
+            tutorialDisplayL.gameObject.SetActive(targetDisplay == tutorialDisplayL);
+            currentDisplay = targetDisplay;
+            SetMediaDisplayAlpha(currentDisplay, 0f);
+
+            if (targetTexture != null)
+            {
+                currentDisplay.texture = targetTexture;
+                videoPlayer.targetTexture = targetTexture;
+            }
+
+            double len = videoPlayer.length;
+            if (len <= 0 && videoPlayer.clip != null) len = videoPlayer.clip.length;
+            cachedVideoLength = (float)Mathf.Max(0f, (float)len);
+
+            timeSlider.minValue = 0f;
+            timeSlider.maxValue = cachedVideoLength;
+            timeSlider.value = 0f;
+
+            if (updateVideoTimeCo != null) StopCoroutine(updateVideoTimeCo);
+            updateVideoTimeCo = StartCoroutine(UpdateVideoTime());
+
+            InvokeTutorialLoadingCompleteOnce();
+            videoPlayer.time = 0;
+            videoPlayer.Play();
+            FadeInMediaDisplay(currentDisplay, VideoRevealDelay);
+        }
+
+        private void DisplayImageCard(TutorialCardData card, bool isInitialDisplay)
+        {
+            videoPlayer.enabled = false;
+            timeSlider.gameObject.SetActive(false);
+
+            if (tutorialDisplayP != null)
+                tutorialDisplayP.gameObject.SetActive(false);
+            if (tutorialDisplayL != null)
+                tutorialDisplayL.gameObject.SetActive(false);
+
+            if (tutorialImageDisplay == null || card.image == null)
+            {
+                _eventManager.InvokeTutorialFetchFailedEvent();
+                return;
+            }
+
+            tutorialImageDisplay.gameObject.SetActive(true);
+            tutorialImageDisplay.texture = card.image.texture;
+            FadeInMediaDisplay(tutorialImageDisplay);
+
+            if (isInitialDisplay)
+            {
+                InvokeTutorialLoadingCompleteOnce();
+            }
+        }
+
+        private void InvokeTutorialLoadingCompleteOnce()
+        {
+            if (hasInvokedTutorialLoadComplete) return;
+
+            hasPreparedTutorialContent = true;
+            hasInvokedTutorialLoadComplete = true;
+            _eventManager.InvokeTutorialLoadingCompleteEvent();
+        }
+
+        private void StopVideoPlayback()
+        {
+            if (updateVideoTimeCo != null)
+            {
+                StopCoroutine(updateVideoTimeCo);
+                updateVideoTimeCo = null;
+            }
+
+            if (videoPlayer == null) return;
+
+            videoPlayer.prepareCompleted -= OnCardVideoPrepared;
+            videoPlayer.loopPointReached -= OnLoopPointReached;
+            if (videoPlayer.isPrepared)
+            {
+                videoPlayer.time = 0;
+            }
+            videoPlayer.Stop();
+            videoPlayer.targetTexture = null;
+        }
+
+
+
         private void ShowVideoTutorial(TutorialData tutorialData)
         {
+            if (videoPlayer == null)
+            {
+                _eventManager.InvokeTutorialFetchFailedEvent();
+                return;
+            }
+
+            videoPlayer.enabled = true;
+
             bool videoFound = false;
 
             if (tutorialData.videoClip != null)
@@ -234,6 +913,7 @@ namespace Hyper.Internal
 
             else
             {
+                videoPlayer.prepareCompleted -= OnCardVideoPrepared;
                 videoPlayer.prepareCompleted += OnVideoPrepared;
                 videoPlayer.loopPointReached += OnLoopPointReached;
             }
@@ -258,15 +938,6 @@ namespace Hyper.Internal
             currentDisplay.texture = targetTexture;
             videoPlayer.targetTexture = targetTexture;
 
-            AspectRatioFitter fitter = (currentDisplay == tutorialDisplayL) ?
-                aspectRatioFitterL : aspectRatioFitterP;
-
-            if (fitter != null)
-            {
-                fitter.aspectRatio = Mathf.Max(0.01f, videoAspectRatio);
-                fitter.aspectMode = AspectRatioFitter.AspectMode.FitInParent;
-            }
-
             timeSlider.gameObject.SetActive(true);
             backButton.gameObject.SetActive(false);
             nextButton.gameObject.SetActive(false);
@@ -278,6 +949,7 @@ namespace Hyper.Internal
             timeSlider.minValue = 0f;
             timeSlider.maxValue = cachedVideoLength;
             timeSlider.value = 0f;
+            timeSlider.interactable = VideoSeekingEnabled;
 
             if (updateVideoTimeCo != null) StopCoroutine(updateVideoTimeCo);
             updateVideoTimeCo = StartCoroutine(UpdateVideoTime());
@@ -324,6 +996,7 @@ namespace Hyper.Internal
             {
                 tutorialImages = tutorialData.images;
                 SetupImageTutorial();
+                _eventManager.InvokeTutorialLoadingCompleteEvent();
             }
             else if (tutorialData.imageUrls != null && tutorialData.imageUrls.Length > 0)
             {
@@ -377,15 +1050,6 @@ namespace Hyper.Internal
             float aspectRatio = (float)texture.width / texture.height;
 
             currentDisplay = SelectOptimalDisplay(aspectRatio);
-
-            AspectRatioFitter fitter = (currentDisplay == tutorialDisplayL) ?
-                aspectRatioFitterL : aspectRatioFitterP;
-
-            if (fitter != null)
-            {
-                fitter.aspectRatio = Mathf.Max(0.01f, aspectRatio);
-                fitter.aspectMode = AspectRatioFitter.AspectMode.FitInParent;
-            }
         }
 
         private IEnumerator LoadImagesFromUrlsCoroutine(string[] urls, Action<Sprite[]> onComplete)
@@ -407,7 +1071,7 @@ namespace Hyper.Internal
                     if (webRequest.result == UnityWebRequest.Result.Success)
                     {
                         Texture2D texture = DownloadHandlerTexture.GetContent(webRequest);
-                        texture.filterMode = FilterMode.Point;
+                        texture.filterMode = FilterMode.Bilinear;
                         texture.Compress(false);
 
                         Sprite sprite = Sprite.Create(
@@ -447,6 +1111,21 @@ namespace Hyper.Internal
 
         private void OnDisable()
         {
+            isDirectContentOpen = false;
+            contentRevealScheduled = false;
+            isClosing = false;
+            CancelHiddenPreloadClose();
+            StopMediaDisplayFade();
+            HideTutorialContent();
+
+#if UNITY_EDITOR
+            if (editorTutorialLoadCo != null)
+            {
+                StopCoroutine(editorTutorialLoadCo);
+                editorTutorialLoadCo = null;
+            }
+#endif
+
             if (updateVideoTimeCo != null)
             {
                 StopCoroutine(updateVideoTimeCo);
@@ -454,6 +1133,14 @@ namespace Hyper.Internal
             }
         }
 
+        private void OnDestroy()
+        {
+            if (_eventManager == null) return;
+
+            _eventManager.OnTutorialResourcesReferenced -= ShowTutorialBasedOnType;
+            _eventManager.OnTutorialLoadingComplete -= HandleTutorialLoadingComplete;
+        }
+
         private void DisplayImage(int index)
         {
             if (tutorialImages == null || index < 0 || index >= tutorialImages.Length)
@@ -471,6 +1158,12 @@ namespace Hyper.Internal
 
         public void NextImage()
         {
+            if (tutorialCards.Count > 0)
+            {
+                NextContent();
+                return;
+            }
+
             if (currentImageIndex < tutorialImages.Length - 1)
             {
                 currentImageIndex++;
@@ -480,6 +1173,12 @@ namespace Hyper.Internal
 
         public void PreviousImage()
         {
+            if (tutorialCards.Count > 0)
+            {
+                PreviousContent();
+                return;
+            }
+
             if (currentImageIndex > 0)
             {
                 currentImageIndex--;
@@ -487,19 +1186,77 @@ namespace Hyper.Internal
             }
         }
 
+        public void NextContent()
+        {
+            if (currentCardIndex >= tutorialCards.Count - 1) return;
+
+            currentCardIndex++;
+            DisplayCurrentCard(false);
+        }
+
+        public void PreviousContent()
+        {
+            if (currentCardIndex <= 0) return;
+
+            currentCardIndex--;
+            DisplayCurrentCard(false);
+        }
+
         public void Close()
         {
+            if (isClosing) return;
+
+            isClosing = true;
+            CancelHiddenPreloadClose();
+            tutorialCG.interactable = false;
+            tutorialCG.blocksRaycasts = false;
+
+            if (tutorialContentGroup == null || tutorialContentGroup.alpha <= 0.001f)
+            {
+                FinishClose();
+                return;
+            }
+
+            tutorialContentGroup.DOKill();
+            tutorialContentGroup.interactable = false;
+            tutorialContentGroup.blocksRaycasts = false;
+            tutorialContentGroup.DOFade(0f, ContentFadeOutDuration)
+                .SetEase(HyperTween.Ease.InQuad)
+                .SetUpdate(true)
+                .OnComplete(FinishClose);
+        }
+
+        private void FinishClose()
+        {
+            if (tutorialContentGroup != null)
+            {
+                tutorialContentGroup.alpha = 0f;
+            }
+
             if (videoPlayer != null) videoPlayer.enabled = false;
             slideUp.SlideDownAnimation();
         }
 
         private void UpdateNavigationButtons()
         {
-            nextButton.interactable = currentImageIndex < tutorialImages.Length - 1;
-            backButton.interactable = currentImageIndex > 0;
+            UpdateNavigationButtons(tutorialImages != null ? tutorialImages.Length : 0, currentImageIndex);
+        }
+
+        private void UpdateNavigationButtons(int totalCount, int currentIndex)
+        {
+            bool hasMultipleCards = totalCount > 1;
+            nextButton.gameObject.SetActive(hasMultipleCards);
+            backButton.gameObject.SetActive(hasMultipleCards);
+            nextButton.interactable = currentIndex < totalCount - 1;
+            backButton.interactable = currentIndex > 0;
         }
 
         private void UpdateIndicators()
+        {
+            UpdateIndicators(tutorialImages != null ? tutorialImages.Length : 0);
+        }
+
+        private void UpdateIndicators(int totalCount)
         {
 
             foreach (Transform child in indicatorParent)
@@ -507,10 +1264,18 @@ namespace Hyper.Internal
                 Destroy(child.gameObject);
             }
 
-            for (int i = 0; i < tutorialImages.Length; i++)
+            for (int i = 0; i < totalCount; i++)
             {
                 Instantiate(indicatorPrefab, indicatorParent);
             }
+
+            indicatorParent.gameObject.SetActive(totalCount > 1);
+        }
+
+        private IEnumerator ApplyInitialIndicatorHighlightNextFrame()
+        {
+            yield return null;
+            HighlightIndicator(currentCardIndex);
         }
 
         private void HighlightIndicator(int index)
@@ -559,6 +1324,8 @@ namespace Hyper.Internal
 
         private void OnTimeSliderChanged(float value)
         {
+            if (!VideoSeekingEnabled) return;
+
             // var tutorialData = HyperRuntime.GameManager.IsPortrait()
             //     ? HyperRuntime.DataManager.tutorialData
             //     : HyperRuntime.DataManager.landscapeTutorial;