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

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

@@ -0,0 +1,501 @@
+using System;
+using System.Collections;
+using Hyper.Shared;
+using TMPro;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    internal sealed class ReplayController : MonoBehaviour
+    {
+        internal const int AvatarTextureSize = 128;
+
+        [SerializeField] private Slider progressSlider;
+        [SerializeField] private TextMeshProUGUI replayLabel;
+        [SerializeField] private RawImage playerAvatar;
+        [SerializeField] private Button exitButton;
+        [SerializeField] private Button playbackSpeedButton;
+        [SerializeField] private TextMeshProUGUI playbackSpeedLabel;
+        [SerializeField] private float[] playbackSpeeds = { 1.5f, 2f, 3f, 4f, 5f, 1f };
+        [SerializeField, Min(1f)] private float seekPlaybackSpeed = 30f;
+        [SerializeField, Range(0.25f, 1f)] private float seekSnapshotScale = 0.55f;
+        [SerializeField] private GameObject seekLoadingOverlay;
+        [SerializeField] private RawImage seekSnapshotImage;
+
+        private int playbackSpeedIndex;
+        private ReplaySeekInput seekInput;
+        private bool wasSeeking;
+        private bool isCapturingSeek;
+        private float pendingSeekTarget;
+        private Texture2D seekSnapshotTexture;
+        private Image seekOverlayBackground;
+        private Color seekOverlayBackgroundColor;
+
+        private void Awake()
+        {
+            AutoBindReferences();
+            ConfigureProgressSlider();
+            ConfigureSeekOverlay();
+            ConfigureSeekSnapshot();
+            ApplyInitialPlaybackSpeed();
+            ReplaySessionState.SeekCompleted += RestorePlaybackAfterSeek;
+            if (exitButton != null) exitButton.onClick.AddListener(ExitReplay);
+            if (playbackSpeedButton != null) playbackSpeedButton.onClick.AddListener(CyclePlaybackSpeed);
+        }
+
+        private void Start()
+        {
+            string playerName = ReplaySessionState.PlayerName ?? string.Empty;
+            playerName = playerName.TrimStart('@');
+            if (replayLabel != null) replayLabel.text = $"Replay of @{playerName}";
+            if (progressSlider != null)
+            {
+                float displayedProgress = ReplaySessionState.IsSeeking
+                    ? ReplaySessionState.SeekTarget01
+                    : ReplaySessionState.Progress01;
+                progressSlider.SetValueWithoutNotify(displayedProgress);
+            }
+            UpdatePlaybackSpeedLabel(ReplaySessionState.UserPlaybackSpeed);
+            SetSeekingPresentation(ReplaySessionState.IsSeeking);
+
+            if (playerAvatar != null && ReplaySessionState.AvatarTexture != null)
+            {
+                playerAvatar.texture = ReplaySessionState.AvatarTexture;
+            }
+        }
+
+        private void Update()
+        {
+            bool isSeeking = ReplaySessionState.IsSeeking;
+            if (wasSeeking && !isSeeking && !ReplaySessionState.HasEnded)
+            {
+                RestorePlaybackAfterSeek(ReplaySessionState.PlaybackSpeed);
+            }
+
+            if (wasSeeking != isSeeking)
+            {
+                SetSeekingPresentation(isSeeking);
+            }
+
+            if (progressSlider != null && (seekInput == null || !seekInput.IsDragging))
+            {
+                float displayedProgress = isCapturingSeek
+                    ? pendingSeekTarget
+                    : isSeeking
+                        ? ReplaySessionState.SeekTarget01
+                        : ReplaySessionState.Progress01;
+                progressSlider.SetValueWithoutNotify(displayedProgress);
+            }
+
+            wasSeeking = isSeeking;
+        }
+
+        private void OnDestroy()
+        {
+            if (exitButton != null) exitButton.onClick.RemoveListener(ExitReplay);
+            if (playbackSpeedButton != null) playbackSpeedButton.onClick.RemoveListener(CyclePlaybackSpeed);
+            ReplaySessionState.SeekCompleted -= RestorePlaybackAfterSeek;
+            seekInput?.Clear();
+            ClearSeekSnapshot();
+        }
+
+        private void ApplyInitialPlaybackSpeed()
+        {
+            if (!ReplaySessionState.IsActive || playbackSpeeds == null || playbackSpeeds.Length == 0)
+            {
+                return;
+            }
+
+            float speed = ReplaySessionState.IsSeeking
+                ? ReplaySessionState.UserPlaybackSpeed
+                : SanitizePlaybackSpeed(playbackSpeeds[0]);
+            if (!ReplaySessionState.IsSeeking)
+            {
+                ReplaySessionState.SetPlaybackSpeed(speed);
+                Time.timeScale = speed;
+            }
+
+            playbackSpeedIndex = playbackSpeeds.Length > 1 ? 1 : 0;
+            AlignPlaybackSpeedIndex(speed);
+            UpdatePlaybackSpeedLabel(speed);
+        }
+
+        internal void SetReplayEnded()
+        {
+            if (exitButton != null) exitButton.interactable = false;
+            if (playbackSpeedButton != null) playbackSpeedButton.interactable = false;
+            if (progressSlider != null) progressSlider.interactable = false;
+            if (seekLoadingOverlay != null) seekLoadingOverlay.SetActive(false);
+            ClearSeekSnapshot();
+            if (progressSlider != null) progressSlider.SetValueWithoutNotify(1f);
+        }
+
+        private void ExitReplay()
+        {
+            if (exitButton != null) exitButton.interactable = false;
+            HyperRuntime.GameManager?.ExitReplayEarly();
+        }
+
+        private void CyclePlaybackSpeed()
+        {
+            if (!ReplaySessionState.IsActive || ReplaySessionState.HasEnded ||
+                playbackSpeeds == null || playbackSpeeds.Length == 0)
+            {
+                return;
+            }
+
+            float speed = SanitizePlaybackSpeed(playbackSpeeds[playbackSpeedIndex]);
+            playbackSpeedIndex = (playbackSpeedIndex + 1) % playbackSpeeds.Length;
+
+            ReplaySessionState.SetPlaybackSpeed(speed);
+            Time.timeScale = speed;
+            UpdatePlaybackSpeedLabel(speed);
+        }
+
+        private void SeekTo(float targetProgress)
+        {
+            if (!ReplaySessionState.IsActive || ReplaySessionState.HasEnded ||
+                ReplaySessionState.IsSeeking || isCapturingSeek)
+            {
+                return;
+            }
+
+            float resumeSpeed = SanitizePlaybackSpeed(ReplaySessionState.UserPlaybackSpeed);
+            float fastForwardSpeed = SanitizePlaybackSpeed(seekPlaybackSpeed);
+            StartCoroutine(CaptureAndSeek(targetProgress, resumeSpeed, fastForwardSpeed));
+        }
+
+        private IEnumerator CaptureAndSeek(float targetProgress, float resumeSpeed, float fastForwardSpeed)
+        {
+            isCapturingSeek = true;
+            pendingSeekTarget = Mathf.Clamp01(targetProgress);
+
+            yield return new WaitForEndOfFrame();
+
+            Texture2D capturedFrame = null;
+            try
+            {
+                capturedFrame = ScreenCapture.CaptureScreenshotAsTexture();
+                if (capturedFrame != null)
+                {
+                    seekSnapshotTexture = CreateScaledSnapshot(capturedFrame, seekSnapshotScale);
+                }
+            }
+            catch (Exception exception)
+            {
+                HyperDebug.LogWarning($"[Replay] Unable to capture seek snapshot: {exception.Message}");
+            }
+            finally
+            {
+                if (capturedFrame != null) Destroy(capturedFrame);
+            }
+
+            if (seekSnapshotImage != null && seekSnapshotTexture != null)
+            {
+                seekSnapshotImage.texture = seekSnapshotTexture;
+                seekSnapshotImage.gameObject.SetActive(true);
+                SetSeekOverlayBackgroundVisible(false);
+            }
+
+            try
+            {
+                SetSeekingPresentation(true);
+                HyperRuntime.SeekReplaySession(pendingSeekTarget, resumeSpeed, fastForwardSpeed);
+            }
+            finally
+            {
+                isCapturingSeek = false;
+            }
+        }
+
+        private void RestorePlaybackAfterSeek(float playbackSpeed)
+        {
+            float speed = SanitizePlaybackSpeed(playbackSpeed);
+            Time.timeScale = speed;
+            AlignPlaybackSpeedIndex(speed);
+            UpdatePlaybackSpeedLabel(speed);
+            SetSeekingPresentation(false);
+            wasSeeking = false;
+        }
+
+        private void AlignPlaybackSpeedIndex(float speed)
+        {
+            if (playbackSpeeds == null || playbackSpeeds.Length == 0) return;
+
+            for (int i = 0; i < playbackSpeeds.Length; i++)
+            {
+                if (!Mathf.Approximately(SanitizePlaybackSpeed(playbackSpeeds[i]), speed)) continue;
+                playbackSpeedIndex = (i + 1) % playbackSpeeds.Length;
+                return;
+            }
+        }
+
+        private void SetSeekingPresentation(bool isSeeking)
+        {
+            ReplayPresentationCanvas.SetSeekingLayer(isSeeking);
+            if (seekLoadingOverlay != null) seekLoadingOverlay.SetActive(isSeeking);
+            if (progressSlider != null) progressSlider.interactable = !isSeeking && !ReplaySessionState.HasEnded;
+            if (playbackSpeedButton != null)
+            {
+                playbackSpeedButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
+            }
+
+            if (exitButton != null) exitButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
+            if (!isSeeking) ClearSeekSnapshot();
+        }
+
+        private static float SanitizePlaybackSpeed(float speed)
+        {
+            return float.IsNaN(speed) || float.IsInfinity(speed) || speed <= 0f ? 1f : speed;
+        }
+
+        private void UpdatePlaybackSpeedLabel(float speed)
+        {
+            if (playbackSpeedLabel == null && playbackSpeedButton != null)
+            {
+                playbackSpeedLabel = playbackSpeedButton.GetComponentInChildren<TextMeshProUGUI>(true);
+            }
+
+            if (playbackSpeedLabel != null)
+            {
+                playbackSpeedLabel.text = $"{speed:0.#}x";
+            }
+        }
+
+        internal static Texture2D CreateCircularAvatar(Texture2D source, int size)
+        {
+            var result = new Texture2D(size, size, TextureFormat.RGBA32, false)
+            {
+                name = "Replay Avatar (Circular)",
+                filterMode = FilterMode.Bilinear,
+                wrapMode = TextureWrapMode.Clamp
+            };
+
+            Color[] pixels = new Color[size * size];
+            float sourceAspect = source.width / (float)source.height;
+            float edgeFeather = 2.5f / size;
+
+            for (int y = 0; y < size; y++)
+            {
+                float v = (y + 0.5f) / size;
+                for (int x = 0; x < size; x++)
+                {
+                    float u = (x + 0.5f) / size;
+                    float centeredX = u - 0.5f;
+                    float centeredY = v - 0.5f;
+                    float distanceFromCenter = Mathf.Sqrt(centeredX * centeredX + centeredY * centeredY);
+                    float edgeCoverage = Mathf.Clamp01((0.5f - distanceFromCenter) / edgeFeather);
+                    edgeCoverage = edgeCoverage * edgeCoverage * (3f - 2f * edgeCoverage);
+
+                    if (edgeCoverage <= 0f)
+                    {
+                        pixels[y * size + x] = Color.clear;
+                        continue;
+                    }
+
+                    float sampleU = sourceAspect > 1f
+                        ? 0.5f + centeredX / sourceAspect
+                        : u;
+                    float sampleV = sourceAspect < 1f
+                        ? 0.5f + centeredY * sourceAspect
+                        : v;
+                    Color color = source.GetPixelBilinear(sampleU, sampleV);
+                    color.a *= edgeCoverage;
+                    pixels[y * size + x] = color;
+                }
+            }
+
+            result.SetPixels(pixels);
+            result.Apply(false, true);
+            return result;
+        }
+
+        private void AutoBindReferences()
+        {
+            if (progressSlider == null) progressSlider = GetComponentInChildren<Slider>(true);
+            if (exitButton == null) exitButton = GetComponentInChildren<Button>(true);
+
+            TextMeshProUGUI[] labels = GetComponentsInChildren<TextMeshProUGUI>(true);
+            for (int i = 0; replayLabel == null && i < labels.Length; i++)
+            {
+                if (labels[i].name == "Subtext") replayLabel = labels[i];
+            }
+
+            RawImage[] images = GetComponentsInChildren<RawImage>(true);
+            for (int i = 0; playerAvatar == null && i < images.Length; i++)
+            {
+                if (images[i].name == "Player Avatar") playerAvatar = images[i];
+            }
+        }
+
+        private void ConfigureProgressSlider()
+        {
+            if (progressSlider == null) return;
+
+            progressSlider.minValue = 0f;
+            progressSlider.maxValue = 1f;
+            progressSlider.wholeNumbers = false;
+            progressSlider.interactable = true;
+            float displayedProgress = ReplaySessionState.IsSeeking
+                ? ReplaySessionState.SeekTarget01
+                : ReplaySessionState.Progress01;
+            progressSlider.SetValueWithoutNotify(displayedProgress);
+
+            seekInput = progressSlider.GetComponent<ReplaySeekInput>();
+            if (seekInput == null) seekInput = progressSlider.gameObject.AddComponent<ReplaySeekInput>();
+            seekInput.Initialize(progressSlider, SeekTo);
+        }
+
+        private void ConfigureSeekOverlay()
+        {
+            if (seekLoadingOverlay == null)
+            {
+                Transform existing = transform.Find("ReplaySeekOverlay");
+                if (existing != null) seekLoadingOverlay = existing.gameObject;
+            }
+
+            if (seekLoadingOverlay == null)
+            {
+                GameObject prefab = Resources.Load<GameObject>("UIPrefabs/ReplaySeekOverlay");
+                seekLoadingOverlay = Instantiate(prefab, transform, false);
+            }
+
+            RectTransform rect = seekLoadingOverlay.GetComponent<RectTransform>();
+            if (rect != null)
+            {
+                rect.anchorMin = Vector2.zero;
+                rect.anchorMax = Vector2.one;
+                rect.offsetMin = Vector2.zero;
+                rect.offsetMax = Vector2.zero;
+            }
+
+            seekLoadingOverlay.transform.SetAsFirstSibling();
+            seekOverlayBackground = seekLoadingOverlay.GetComponent<Image>();
+            if (seekOverlayBackground != null) seekOverlayBackgroundColor = seekOverlayBackground.color;
+            seekLoadingOverlay.SetActive(ReplaySessionState.IsSeeking);
+            wasSeeking = ReplaySessionState.IsSeeking;
+        }
+
+        private void ConfigureSeekSnapshot()
+        {
+            if (seekSnapshotImage == null)
+            {
+                Transform existing = transform.Find("ReplaySeekSnapshot");
+                if (existing != null) seekSnapshotImage = existing.GetComponent<RawImage>();
+            }
+
+            if (seekSnapshotImage == null)
+            {
+                var snapshot = new GameObject(
+                    "ReplaySeekSnapshot",
+                    typeof(RectTransform),
+                    typeof(CanvasRenderer),
+                    typeof(RawImage));
+                snapshot.transform.SetParent(transform, false);
+                seekSnapshotImage = snapshot.GetComponent<RawImage>();
+            }
+
+            RectTransform rect = seekSnapshotImage.rectTransform;
+            rect.anchorMin = Vector2.zero;
+            rect.anchorMax = Vector2.one;
+            rect.offsetMin = Vector2.zero;
+            rect.offsetMax = Vector2.zero;
+            seekSnapshotImage.raycastTarget = false;
+            seekSnapshotImage.transform.SetAsFirstSibling();
+            if (seekLoadingOverlay != null) seekLoadingOverlay.transform.SetSiblingIndex(1);
+            seekSnapshotImage.gameObject.SetActive(false);
+        }
+
+        private static Texture2D CreateScaledSnapshot(Texture2D source, float scale)
+        {
+            float sanitizedScale = Mathf.Clamp(scale, 0.25f, 1f);
+            int width = Mathf.Max(1, Mathf.RoundToInt(source.width * sanitizedScale));
+            int height = Mathf.Max(1, Mathf.RoundToInt(source.height * sanitizedScale));
+            RenderTexture temporary = RenderTexture.GetTemporary(width, height, 0, RenderTextureFormat.ARGB32);
+            RenderTexture previous = RenderTexture.active;
+            Texture2D result = null;
+
+            try
+            {
+                Graphics.Blit(source, temporary);
+                RenderTexture.active = temporary;
+                result = new Texture2D(width, height, TextureFormat.RGB24, false)
+                {
+                    name = "Replay Seek Snapshot",
+                    filterMode = FilterMode.Bilinear,
+                    wrapMode = TextureWrapMode.Clamp
+                };
+                result.ReadPixels(new Rect(0f, 0f, width, height), 0, 0, false);
+                result.Apply(false, true);
+                return result;
+            }
+            catch
+            {
+                if (result != null) Destroy(result);
+                throw;
+            }
+            finally
+            {
+                RenderTexture.active = previous;
+                RenderTexture.ReleaseTemporary(temporary);
+            }
+        }
+
+        private void ClearSeekSnapshot()
+        {
+            SetSeekOverlayBackgroundVisible(true);
+            if (seekSnapshotImage != null)
+            {
+                seekSnapshotImage.texture = null;
+                seekSnapshotImage.gameObject.SetActive(false);
+            }
+
+            if (seekSnapshotTexture == null) return;
+            Destroy(seekSnapshotTexture);
+            seekSnapshotTexture = null;
+        }
+
+        private void SetSeekOverlayBackgroundVisible(bool isVisible)
+        {
+            if (seekOverlayBackground == null) return;
+            Color color = seekOverlayBackgroundColor;
+            if (!isVisible) color.a = 0.5f;
+            seekOverlayBackground.color = color;
+        }
+    }
+
+    internal sealed class ReplaySeekInput : MonoBehaviour, IPointerDownHandler, IPointerUpHandler
+    {
+        private Slider slider;
+        private Action<float> onSeekRequested;
+
+        internal bool IsDragging { get; private set; }
+
+        internal void Initialize(Slider targetSlider, Action<float> callback)
+        {
+            slider = targetSlider;
+            onSeekRequested = callback;
+        }
+
+        internal void Clear()
+        {
+            IsDragging = false;
+            onSeekRequested = null;
+        }
+
+        public void OnPointerDown(PointerEventData eventData)
+        {
+            if (slider == null || !slider.interactable) return;
+            IsDragging = true;
+        }
+
+        public void OnPointerUp(PointerEventData eventData)
+        {
+            if (!IsDragging) return;
+            IsDragging = false;
+            onSeekRequested?.Invoke(slider.normalizedValue);
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 488ba0c343178684c9e74294492a1fa1

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