app.hypergames.hypersdk 1.10.0 → 1.11.0-beta.2

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

@@ -0,0 +1,89 @@
+using System.Collections;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    [RequireComponent(typeof(Graphic))]
+    internal sealed class ReplayMarkerPulse : MonoBehaviour
+    {
+        [SerializeField, Range(0f, 1f)] private float minimumAlpha = 0.3f;
+        [SerializeField] private float fadeDuration = 0.8f;
+
+        private Graphic _graphic;
+        private Coroutine _pulseCoroutine;
+
+        private void Awake()
+        {
+            _graphic = GetComponent<Graphic>();
+        }
+
+        private void OnEnable()
+        {
+            HyperRuntime.EventManager.OnGameStart += StartPulsing;
+            HyperRuntime.EventManager.OnGameEnded += StopPulsing;
+            SetAlpha(minimumAlpha);
+
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.HasGameStarted)
+            {
+                StartPulsing();
+            }
+        }
+
+        private void OnDisable()
+        {
+            if (HyperRuntime.EventManager != null)
+            {
+                HyperRuntime.EventManager.OnGameStart -= StartPulsing;
+                HyperRuntime.EventManager.OnGameEnded -= StopPulsing;
+            }
+            StopPulsing();
+        }
+
+        private void StartPulsing()
+        {
+            if (_pulseCoroutine != null) StopCoroutine(_pulseCoroutine);
+            _pulseCoroutine = StartCoroutine(Pulse());
+        }
+
+        private void StopPulsing()
+        {
+            if (_pulseCoroutine != null)
+            {
+                StopCoroutine(_pulseCoroutine);
+                _pulseCoroutine = null;
+            }
+            SetAlpha(1f);
+        }
+
+        private IEnumerator Pulse()
+        {
+            float duration = Mathf.Max(0.05f, fadeDuration);
+            while (true)
+            {
+                yield return Fade(minimumAlpha, 1f, duration);
+                yield return Fade(1f, minimumAlpha, duration);
+            }
+        }
+
+        private IEnumerator Fade(float from, float to, float duration)
+        {
+            float elapsed = 0f;
+            while (elapsed < duration)
+            {
+                elapsed += Time.unscaledDeltaTime;
+                SetAlpha(Mathf.Lerp(from, to, elapsed / duration));
+                yield return null;
+            }
+            SetAlpha(to);
+        }
+
+        private void SetAlpha(float alpha)
+        {
+            if (_graphic == null) return;
+            Color color = _graphic.color;
+            color.a = alpha;
+            _graphic.color = color;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 361528b20842ffc4ead65b0e23d7cc78

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

@@ -0,0 +1,183 @@
+using Hyper.Shared;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    /// <summary>
+    /// Owns replay-only UI independently from the session-scoped HyperCanvas.
+    /// The root survives only while a seek restart is in progress.
+    /// </summary>
+    internal sealed class ReplayPresentationCanvas : MonoBehaviour
+    {
+        private const int NormalSortingOrder = 9999;
+        private const int SeekingSortingOrder = 10001;
+
+        private static ReplayPresentationCanvas instance;
+
+        internal GameObject InputBlocker { get; private set; }
+        internal GameObject ControllerObject { get; private set; }
+        internal ReplayController Controller { get; private set; }
+
+        internal static ReplayPresentationCanvas GetOrCreate(bool isPortrait)
+        {
+            if (instance == null)
+            {
+                instance = FindFirstObjectByType<ReplayPresentationCanvas>();
+            }
+
+            if (instance == null)
+            {
+                var root = new GameObject(
+                    "ReplayPresentationCanvas",
+                    typeof(RectTransform),
+                    typeof(Canvas),
+                    typeof(CanvasScaler),
+                    typeof(GraphicRaycaster));
+                instance = root.AddComponent<ReplayPresentationCanvas>();
+                DontDestroyOnLoad(root);
+                instance.Build(isPortrait);
+            }
+            else
+            {
+                instance.ConfigureCanvas(isPortrait);
+                instance.EnsurePresentationObjects();
+            }
+
+            instance.gameObject.SetActive(true);
+            instance.ControllerObject?.transform.SetAsLastSibling();
+            return instance;
+        }
+
+        internal static bool IsPresentationRoot(GameObject root)
+        {
+            return instance != null && root == instance.gameObject;
+        }
+
+        internal static void SetSeekingLayer(bool isSeeking)
+        {
+            if (instance == null) return;
+            Canvas canvas = instance.GetComponent<Canvas>();
+            if (canvas != null) canvas.sortingOrder = isSeeking ? SeekingSortingOrder : NormalSortingOrder;
+        }
+
+        internal static void DestroyCurrent()
+        {
+            if (instance == null) return;
+            Destroy(instance.gameObject);
+            instance = null;
+        }
+
+        private void Awake()
+        {
+            if (instance != null && instance != this)
+            {
+                Destroy(gameObject);
+                return;
+            }
+
+            instance = this;
+        }
+
+        private void OnDestroy()
+        {
+            if (instance == this) instance = null;
+        }
+
+        private void Build(bool isPortrait)
+        {
+            ConfigureCanvas(isPortrait);
+
+            var safeArea = new GameObject("SafeArea", typeof(RectTransform));
+            RectTransform safeAreaRect = safeArea.GetComponent<RectTransform>();
+            safeAreaRect.SetParent(transform, false);
+            StretchToParent(safeAreaRect);
+            if (isPortrait) safeArea.AddComponent<SafeArea>();
+
+            CreateInputBlocker(safeAreaRect);
+            CreateController(safeAreaRect);
+        }
+
+        private void ConfigureCanvas(bool isPortrait)
+        {
+            Canvas canvas = GetComponent<Canvas>();
+            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+            canvas.overrideSorting = true;
+            canvas.sortingOrder = ReplaySessionState.IsSeeking
+                ? SeekingSortingOrder
+                : NormalSortingOrder;
+
+            CanvasScaler scaler = GetComponent<CanvasScaler>();
+            scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
+            scaler.referenceResolution = new Vector2(1080f, 2160f);
+            scaler.matchWidthOrHeight = isPortrait ? 1f : 0.593f;
+        }
+
+        private void EnsurePresentationObjects()
+        {
+            Transform safeArea = transform.Find("SafeArea");
+            if (safeArea == null)
+            {
+                Build(Screen.height > Screen.width);
+                return;
+            }
+
+            if (InputBlocker == null)
+            {
+                Transform blocker = safeArea.Find("ReplayInputBlocker");
+                InputBlocker = blocker != null ? blocker.gameObject : null;
+                if (InputBlocker == null) CreateInputBlocker((RectTransform)safeArea);
+            }
+
+            if (ControllerObject == null)
+            {
+                Transform controller = safeArea.Find("ReplayController");
+                ControllerObject = controller != null ? controller.gameObject : null;
+                Controller = ControllerObject != null ? ControllerObject.GetComponent<ReplayController>() : null;
+                if (ControllerObject == null) CreateController((RectTransform)safeArea);
+            }
+        }
+
+        private void CreateInputBlocker(RectTransform parent)
+        {
+            GameObject prefab = Resources.Load<GameObject>("UIPrefabs/ReplayInputBlocker");
+            InputBlocker = prefab != null
+                ? Instantiate(prefab, parent, false)
+                : new GameObject("ReplayInputBlocker", typeof(RectTransform), typeof(CanvasRenderer), typeof(Image));
+
+            RectTransform rect = InputBlocker.GetComponent<RectTransform>();
+            if (rect.parent == null) rect.SetParent(parent, false);
+            StretchToParent(rect);
+
+            Image image = InputBlocker.GetComponent<Image>();
+            if (image != null)
+            {
+                image.raycastTarget = true;
+                if (prefab == null) image.color = Color.clear;
+            }
+        }
+
+        private void CreateController(RectTransform parent)
+        {
+            GameObject prefab = Resources.Load<GameObject>("UIPrefabs/ReplayController");
+            if (prefab == null)
+            {
+                Debug.LogWarning("[ReplayPresentationCanvas] ReplayController prefab not found.");
+                return;
+            }
+
+            ControllerObject = Instantiate(prefab, parent, false);
+            ControllerObject.transform.SetAsLastSibling();
+            Controller = ControllerObject.GetComponent<ReplayController>();
+            if (Controller == null) Controller = ControllerObject.AddComponent<ReplayController>();
+        }
+
+        private static void StretchToParent(RectTransform rect)
+        {
+            rect.anchorMin = Vector2.zero;
+            rect.anchorMax = Vector2.one;
+            rect.offsetMin = Vector2.zero;
+            rect.offsetMax = Vector2.zero;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 01a4ad28a491451587a73a62982beef7

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

@@ -90,6 +90,12 @@ namespace Hyper.Internal
             retryTimerText.text = $"00:0{5 - HyperRuntime.BackendManager.CurrentRetryCount}";
         }
 
+        internal void ShowRetryCountdown(int secondsRemaining)
+        {
+            DisableAllCTAButtons();
+            retryTimerText.text = $"00:{Mathf.Max(0, secondsRemaining):00}";
+        }
+
         private void EnableRetryLaterButton()
         {
             ctaButtonsHolder.interactable = true;
@@ -115,6 +121,12 @@ namespace Hyper.Internal
 
         public void Retry() // On Retry Button Clicked
         {
+            if (_gameManager.IsReplayMode)
+            {
+                _gameManager.RetryReplayLoading();
+                return;
+            }
+
             StartReconnectionCoroutine();
         }
 

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

@@ -0,0 +1,61 @@
+using Hyper.Shared;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    internal sealed class ReplayOverModal : MonoBehaviour
+    {
+        [SerializeField] private Button watchAgainButton;
+        [SerializeField] private Button exitButton;
+        private bool _handled;
+
+        private void Awake()
+        {
+            Button[] buttons = GetComponentsInChildren<Button>(true);
+            for (int i = 0; i < buttons.Length; i++)
+            {
+                if (buttons[i].name == "Watch Again") watchAgainButton = buttons[i];
+                else if (buttons[i].name == "Exit") exitButton = buttons[i];
+            }
+
+            if (watchAgainButton != null) watchAgainButton.onClick.AddListener(WatchAgain);
+            if (exitButton != null) exitButton.onClick.AddListener(Exit);
+        }
+
+        private void OnEnable()
+        {
+            _handled = false;
+            if (watchAgainButton != null) watchAgainButton.interactable = true;
+            if (exitButton != null) exitButton.interactable = true;
+        }
+
+        private void OnDestroy()
+        {
+            if (watchAgainButton != null) watchAgainButton.onClick.RemoveListener(WatchAgain);
+            if (exitButton != null) exitButton.onClick.RemoveListener(Exit);
+        }
+
+        private void WatchAgain()
+        {
+            if (_handled) return;
+            _handled = true;
+            DisableButtons();
+            HyperRuntime.RestartReplaySession();
+        }
+
+        private void Exit()
+        {
+            if (_handled) return;
+            _handled = true;
+            DisableButtons();
+            HyperRuntime.GameManager?.ExitCompletedReplay();
+        }
+
+        private void DisableButtons()
+        {
+            if (watchAgainButton != null) watchAgainButton.interactable = false;
+            if (exitButton != null) exitButton.interactable = false;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8841f748a9924814cbb010c54be7916e

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

@@ -1,10 +1,8 @@
 using System.Collections;
-using System.Runtime.InteropServices;
 using Hyper.Internal.Managers;
 using Hyper.Shared;
 using TMPro;
 using UnityEngine;
-using UnityEngine.SceneManagement;
 using UnityEngine.UI;
 
 namespace Hyper.Internal
@@ -12,38 +10,61 @@ namespace Hyper.Internal
     internal class StartingInstructionModal : MonoBehaviour
     {
 
-#if UNITY_WEBGL
-        [DllImport("__Internal")]
-        private static extern void MarkGameStartedOnHTML();
-#endif
         [SerializeField] private TextMeshProUGUI startCtaLabel;
         [SerializeField] private BlinkingText blinkingText;
         [SerializeField] private RectTransform swipeGif;
         [SerializeField] private RectTransform handSpriteInGif;
-        private EventManager _eventManager;
-        private DataManager _dataManager;
+        [SerializeField] private float replayAutoStartDelay = 1f;
         private GameManager _gameManager;
-        private BackendManager _backendManager;
         private StartCTA _currentCTA;
         private SwipeDirection _swipeDirection;
 
         private bool _canAcceptInput = false;
         private Vector2 _swipeStartPosition;
         private bool _isTrackingSwipe;
+        private bool _hasStarted;
+        private Coroutine _replayAutoStartCoroutine;
         private const float SWIPE_THRESHOLD = 50f;
 
         void Awake()
         {
-            _dataManager = HyperRuntime.DataManager;
-            _eventManager = HyperRuntime.EventManager;
             _gameManager = HyperRuntime.GameManager;
-            _backendManager = HyperRuntime.BackendManager;
         }
 
         void OnEnable()
         {
             _canAcceptInput = false;
-            StartCoroutine(EnableInputAfterDelay());
+            _hasStarted = false;
+
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode)
+            {
+                _replayAutoStartCoroutine = StartCoroutine(AutoStartReplay());
+            }
+            else
+            {
+                StartCoroutine(EnableInputAfterDelay());
+            }
+        }
+
+        private void OnDisable()
+        {
+            if (_replayAutoStartCoroutine != null)
+            {
+                StopCoroutine(_replayAutoStartCoroutine);
+                _replayAutoStartCoroutine = null;
+            }
+        }
+
+        private IEnumerator AutoStartReplay()
+        {
+            float elapsed = 0f;
+            float delay = Mathf.Max(0f, replayAutoStartDelay);
+            while (elapsed < delay)
+            {
+                if (Application.isFocused) elapsed += Time.unscaledDeltaTime;
+                yield return null;
+            }
+            StartGame();
         }
 
         private IEnumerator EnableInputAfterDelay()
@@ -59,6 +80,7 @@ namespace Hyper.Internal
 
         void Update()
         {
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode) return;
             if (!gameObject.activeSelf || !_canAcceptInput) return;
 
             if (_currentCTA == StartCTA.TapToPlay)
@@ -279,23 +301,10 @@ namespace Hyper.Internal
         /// </summary>
         private void StartGame()
         {
-            _gameManager.HideStartGameDeadlineSnackBar();
-            _dataManager.UpdateScore(0);
-            HyperRuntime.Timer.StartActiveGameTimer();
+            if (_hasStarted) return;
+            _hasStarted = true;
 
-            _dataManager.StartCapturingScores(); // Start capture/sender immediately so offline starts still buffer score samples.
-            _backendManager.StartSendingScores(); // Sender loop already pauses actual submissions while disconnected or token-gated.
-
-            // startGame handshake can only be emitted when socket is connected.
-            if (_backendManager.isSocketConnected)
-            {
-                _backendManager.SendGameStarted();
-            }
-
-#if UNITY_WEBGL && !UNITY_EDITOR
-            MarkGameStartedOnHTML();
-#endif
-            _eventManager.InvokeGameStartEvent();
+            _gameManager.StartGameplay();
             gameObject.SetActive(false);
         }
 

package/Runtime/Public/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Hyper.Tests.EditMode")]

package/Runtime/Public/AssemblyInfo.cs.meta

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