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

package/Runtime/Internal/Managers/ReplayManager.cs.meta

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

package/Runtime/Internal/Managers/TimeManager.cs

@@ -43,6 +43,7 @@ namespace Hyper.Internal.Managers
         private bool _isSessionRunning;
         private bool _sessionWarningTriggered;
         private bool _timeUpTriggered;
+        private bool _replayTimeUpPending;
 
         private float _lastUnscaledTime;
         private bool _hasGameEnded;
@@ -64,13 +65,14 @@ namespace Hyper.Internal.Managers
             _hasBackendSessionDuration = false;
             _lastUnscaledTime = Time.unscaledTime;
             _timeUpTriggered = false;
+            _replayTimeUpPending = false;
         }
 
         #endregion
 
         #region Public API Implementation (ITimerAPI)
 
-        public int CurrentTime => _gameManager.Config.GameMode == GameMode.Battle
+        public int CurrentTime => _gameManager.IsBattleMode
             ? (int)_battleTimer
             : (int)_practiceTimer;
 
@@ -89,11 +91,27 @@ namespace Hyper.Internal.Managers
             float unscaledDelta = Time.unscaledTime - _lastUnscaledTime;
             _lastUnscaledTime = Time.unscaledTime;
 
-            float gameTimerDelta = Mathf.Approximately(Time.timeScale, 0f) ? 0f : unscaledDelta;
+            if (!_gameManager.IsReplayMode)
+            {
+                float gameTimerDelta = Mathf.Approximately(Time.timeScale, 0f)
+                    ? 0f
+                    : unscaledDelta;
+
+                UpdatePracticeTimer(gameTimerDelta);
+                UpdateBattleTimer(gameTimerDelta);
+            }
 
-            UpdatePracticeTimer(gameTimerDelta);
-            UpdateBattleTimer(gameTimerDelta);
             UpdateSessionTimer(unscaledDelta);
+            DispatchPendingReplayTimeUp();
+        }
+
+        internal void FixedTick()
+        {
+            if (!_gameManager.IsReplayMode || Mathf.Approximately(Time.timeScale, 0f))
+                return;
+
+            UpdatePracticeTimer(Time.fixedDeltaTime);
+            UpdateBattleTimer(Time.fixedDeltaTime, true);
         }
 
         public void Reset()
@@ -104,7 +122,7 @@ namespace Hyper.Internal.Managers
 
         public void ResumeGameTimersAfterPause()
         {
-            if (_gameManager.Config.GameMode == GameMode.Battle)
+            if (_gameManager.IsBattleMode)
             {
                 StartBattle();
             }
@@ -116,7 +134,7 @@ namespace Hyper.Internal.Managers
 
         public void StartActiveGameTimer()
         {
-            if (_gameManager.Config.GameMode == GameMode.Battle)
+            if (_gameManager.IsBattleMode)
             {
                 StartSessionTimer();
                 StartBattle();
@@ -132,6 +150,7 @@ namespace Hyper.Internal.Managers
         public void StopAllTimers()
         {
             _hasGameEnded = true;
+            _replayTimeUpPending = false;
             StopBattle();
             StopPractice();
         }
@@ -243,11 +262,11 @@ namespace Hyper.Internal.Managers
             }
         }
 
-        private void UpdateBattleTimer(float delta)
+        private void UpdateBattleTimer(float delta, bool deferTimeUp = false)
         {
             if (_isBattleRunning)
             {
-                if (_gameManager.Config.GameMode == GameMode.Battle &&
+                if (_gameManager.IsBattleMode &&
                     _hasGameStarted &&
                     _isPreSessionRunning &&
                     _sessionTimer <= _battleTimer)
@@ -261,8 +280,7 @@ namespace Hyper.Internal.Managers
                     _battleTimer = 0;
                     if (!_timeUpTriggered)
                     {
-                        _timeUpTriggered = true;
-                        _eventManager?.InvokeTimeUpEvent();
+                        TriggerTimeUp(deferTimeUp);
                     }
                 }
             }
@@ -274,13 +292,37 @@ namespace Hyper.Internal.Managers
 
                     if (_battleTimer <= 0 && !_timeUpTriggered)
                     {
-                        _timeUpTriggered = true;
-                        _eventManager?.InvokeTimeUpEvent();
+                        TriggerTimeUp(deferTimeUp);
                     }
                 }
             }
         }
 
+        private void TriggerTimeUp(bool defer)
+        {
+            if (defer)
+            {
+                _replayTimeUpPending = true;
+                return;
+            }
+
+            _timeUpTriggered = true;
+            _eventManager?.InvokeTimeUpEvent();
+        }
+
+        private void DispatchPendingReplayTimeUp()
+        {
+            if (!_replayTimeUpPending)
+                return;
+
+            _replayTimeUpPending = false;
+            if (_hasGameEnded || _timeUpTriggered)
+                return;
+
+            _timeUpTriggered = true;
+            _eventManager?.InvokeTimeUpEvent();
+        }
+
         private void UpdateSessionTimer(float unscaledDelta)
         {
             if (!_isPreSessionRunning) return;
@@ -311,7 +353,7 @@ namespace Hyper.Internal.Managers
                 _isSessionRunning = false;
                 _isPreSessionRunning = false;
 
-                if (_hasGameStarted && _gameManager.Config.GameMode == GameMode.Battle)
+                if (_hasGameStarted && _gameManager.IsBattleMode)
                 {
                     _battleTimer = 0;
                     if (!_timeUpTriggered)
@@ -341,7 +383,7 @@ namespace Hyper.Internal.Managers
                 }
             };
 
-            if (_gameManager.Config.GameMode == GameMode.Battle)
+            if (_gameManager.IsBattleMode)
             {
                 _eventManager.OnStartDeadlineReached += () =>
                 {

package/Runtime/Internal/Replay/ReplayActivityRecorder.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Collections.Generic;
+
+namespace Hyper.Internal.Replay
+{
+    internal sealed class ReplayActivityRecorder
+    {
+        internal const string GameStarted = "GS";
+        internal const string GamePaused = "GP";
+        internal const string GameResumed = "GR";
+        internal const string GameEnded = "GE";
+
+        private readonly Func<double> _utcNow;
+        private readonly Func<double> _simulationNow;
+        private List<object[]> _activities;
+        private bool _hasStarted;
+        private bool _isPaused;
+        private bool _hasEnded;
+        private double _sessionStartUtc;
+        private double _sessionStartSimulation;
+        private double _pauseStartedUtc;
+        private double _pauseStartedReplayTime;
+        private double _recordedPauseDuration;
+
+        internal event Action<object[]> ActivityRecorded;
+
+        internal ReplayActivityRecorder(Func<double> utcNow) : this(utcNow, utcNow)
+        {
+        }
+
+        internal ReplayActivityRecorder(Func<double> utcNow, Func<double> simulationNow)
+        {
+            _utcNow = utcNow ?? throw new ArgumentNullException(nameof(utcNow));
+            _simulationNow = simulationNow ?? throw new ArgumentNullException(nameof(simulationNow));
+        }
+
+        internal void StartSession()
+        {
+            if (_hasStarted && !_hasEnded) return;
+
+            _activities?.Clear();
+            _hasStarted = true;
+            _isPaused = false;
+            _hasEnded = false;
+            _recordedPauseDuration = 0d;
+            _sessionStartUtc = _utcNow();
+            _sessionStartSimulation = _simulationNow();
+            AddAction(GameStarted, _sessionStartUtc);
+        }
+
+        internal void PauseSession()
+        {
+            if (!_hasStarted || _hasEnded || _isPaused) return;
+
+            _pauseStartedReplayTime = GetReplayTime();
+            _pauseStartedUtc = _utcNow();
+            _isPaused = true;
+            AddAction(GamePaused, _pauseStartedReplayTime);
+        }
+
+        internal void ResumeSession()
+        {
+            if (!_hasStarted || _hasEnded || !_isPaused) return;
+
+            double pauseDuration = Math.Max(0d, _utcNow() - _pauseStartedUtc);
+            _recordedPauseDuration += pauseDuration;
+            _isPaused = false;
+            AddAction(GameResumed, _pauseStartedReplayTime + pauseDuration);
+        }
+
+        internal void EndSession()
+        {
+            if (!_hasStarted || _hasEnded) return;
+
+            _hasEnded = true;
+            AddAction(GameEnded);
+        }
+
+        internal void RecordValues(float first, float second)
+        {
+            if (!CanRecordGameplay()) return;
+            AddActivity(new object[] { GetReplayTime(), first, second });
+        }
+
+        internal void RecordValue(float value)
+        {
+            if (!CanRecordGameplay()) return;
+            AddActivity(new object[] { GetReplayTime(), value });
+        }
+
+        internal void RecordValues(float first, float second, float third)
+        {
+            if (!CanRecordGameplay()) return;
+            AddActivity(new object[] { GetReplayTime(), first, second, third });
+        }
+
+        internal void RecordAction(string actionName)
+        {
+            if (!CanRecordGameplay() || string.IsNullOrWhiteSpace(actionName) || IsLifecycleAction(actionName)) return;
+            AddAction(actionName);
+        }
+
+        internal void RecordActions(string firstAction, string secondAction)
+        {
+            if (!CanRecordGameplay() || !IsValidAction(firstAction) || !IsValidAction(secondAction)) return;
+            AddActivity(new object[] { GetReplayTime(), firstAction, secondAction });
+        }
+
+        internal void RecordActionValues(string actionName, float first, float second)
+        {
+            if (!CanRecordGameplay() || !IsValidAction(actionName)) return;
+            AddActivity(new object[] { GetReplayTime(), actionName, first, second });
+        }
+
+        internal void RecordActionValue(string actionName, float value)
+        {
+            if (!CanRecordGameplay() || !IsValidAction(actionName)) return;
+            AddActivity(new object[] { GetReplayTime(), actionName, value });
+        }
+
+        internal void RecordValuesAction(float first, float second, string actionName)
+        {
+            if (!CanRecordGameplay() || !IsValidAction(actionName)) return;
+            AddActivity(new object[] { GetReplayTime(), first, second, actionName });
+        }
+
+        internal void RecordValueAction(float value, string actionName)
+        {
+            if (!CanRecordGameplay() || !IsValidAction(actionName)) return;
+            AddActivity(new object[] { GetReplayTime(), value, actionName });
+        }
+
+        internal List<object[]> Drain()
+        {
+            if (_activities == null || _activities.Count == 0) return null;
+
+            var drained = _activities;
+            _activities = null;
+            return drained;
+        }
+
+        private List<object[]> Activities => _activities ??= new List<object[]>(32);
+
+        private bool CanRecordGameplay()
+        {
+            return _hasStarted && !_isPaused && !_hasEnded;
+        }
+
+        private void AddAction(string actionName)
+        {
+            AddAction(actionName, GetReplayTime());
+        }
+
+        private void AddAction(string actionName, double replayTime)
+        {
+            AddActivity(new object[] { replayTime, actionName });
+        }
+
+        private void AddActivity(object[] activity)
+        {
+            Activities.Add(activity);
+            ActivityRecorded?.Invoke(activity);
+        }
+
+        private double GetReplayTime()
+        {
+            double simulationElapsed = Math.Max(0d, _simulationNow() - _sessionStartSimulation);
+            return _sessionStartUtc + simulationElapsed + _recordedPauseDuration;
+        }
+
+        private static bool IsValidAction(string actionName)
+        {
+            return !string.IsNullOrWhiteSpace(actionName) && !IsLifecycleAction(actionName);
+        }
+
+        internal static bool IsLifecycleAction(string actionName)
+        {
+            return actionName == GameStarted || actionName == GamePaused ||
+                   actionName == GameResumed || actionName == GameEnded;
+        }
+    }
+}

package/Runtime/Internal/Replay/ReplayActivityRecorder.cs.meta

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

package/Runtime/Internal/Replay/ReplaySessionState.cs

@@ -0,0 +1,181 @@
+using System;
+using System.IO;
+using UnityEngine;
+
+namespace Hyper.Internal
+{
+    /// <summary>
+    /// Holds replay metadata and presentation state across scene reloads and seeks.
+    /// </summary>
+    internal static class ReplaySessionState
+    {
+        public static bool IsActive { get; private set; }
+        public static string PlayerName { get; private set; }
+        public static string AvatarUrl { get; private set; }
+        public static string EntryId { get; private set; }
+        public static string ReplayNdjson { get; private set; }
+        public static Texture2D AvatarTexture { get; private set; }
+        public static bool HasReplayData => !string.IsNullOrWhiteSpace(ReplayNdjson);
+        public static long OriginalRandomSeed { get; private set; }
+        public static float Progress01 { get; private set; }
+        public static float PlaybackSpeed { get; private set; } = 1f;
+        public static float UserPlaybackSpeed { get; private set; } = 1f;
+        public static bool IsSeeking { get; private set; }
+        public static bool IsSeekRestartPending => IsSeeking && !_seekPlaybackReady;
+        public static float SeekTarget01 { get; private set; }
+        public static bool HasEnded { get; private set; }
+
+        internal static string EditorReplayFilePath =>
+            Path.Combine(Application.persistentDataPath, "hyper-replay.ndjson");
+
+        public static event Action<float> SeekCompleted;
+
+        private static bool _seekPlaybackReady;
+
+        public static void Configure(
+            string playerName,
+            string avatarUrl,
+            long originalRandomSeed,
+            string entryId = null)
+        {
+            IsActive = true;
+            PlayerName = playerName ?? string.Empty;
+            AvatarUrl = avatarUrl ?? string.Empty;
+            EntryId = entryId ?? string.Empty;
+            ReplayNdjson = string.Empty;
+            ReleaseAvatarTexture();
+            OriginalRandomSeed = originalRandomSeed;
+            Progress01 = 0f;
+            PlaybackSpeed = 1f;
+            UserPlaybackSpeed = 1f;
+            IsSeeking = false;
+            SeekTarget01 = 0f;
+            _seekPlaybackReady = false;
+            HasEnded = false;
+        }
+
+        public static void SetMetadata(string playerName, string avatarUrl, long originalRandomSeed)
+        {
+            if (!IsActive) return;
+
+            PlayerName = playerName ?? string.Empty;
+            AvatarUrl = avatarUrl ?? string.Empty;
+            OriginalRandomSeed = originalRandomSeed;
+        }
+
+        public static void SetReplayData(string ndjson)
+        {
+            if (!IsActive) return;
+            ReplayNdjson = ndjson ?? string.Empty;
+        }
+
+        public static void SetAvatarTexture(Texture2D texture)
+        {
+            if (!IsActive || AvatarTexture == texture) return;
+            ReleaseAvatarTexture();
+            AvatarTexture = texture;
+        }
+
+        public static void SetProgress(float progress)
+        {
+            if (!IsActive) return;
+            if (IsSeeking && !_seekPlaybackReady) return;
+            Progress01 = Math.Max(0f, Math.Min(1f, progress));
+
+            if (IsSeeking && Progress01 >= SeekTarget01)
+            {
+                IsSeeking = false;
+                _seekPlaybackReady = false;
+                PlaybackSpeed = UserPlaybackSpeed;
+                SeekCompleted?.Invoke(PlaybackSpeed);
+            }
+        }
+
+        public static void SetPlaybackSpeed(float speed)
+        {
+            if (!IsActive) return;
+            PlaybackSpeed = SanitizeSpeed(speed);
+            if (!IsSeeking) UserPlaybackSpeed = PlaybackSpeed;
+        }
+
+        public static void MarkEnded()
+        {
+            if (!IsActive) return;
+            if (IsSeeking && !_seekPlaybackReady) return;
+            Progress01 = 1f;
+            if (IsSeeking) PlaybackSpeed = UserPlaybackSpeed;
+            IsSeeking = false;
+            HasEnded = true;
+        }
+
+        public static void RequestSeek(float targetProgress, float resumeSpeed, float seekSpeed)
+        {
+            if (!IsActive || HasEnded) return;
+
+            SeekTarget01 = Math.Max(0f, Math.Min(1f, targetProgress));
+            UserPlaybackSpeed = SanitizeSpeed(resumeSpeed);
+            PlaybackSpeed = SanitizeSpeed(seekSpeed);
+            IsSeeking = true;
+            _seekPlaybackReady = false;
+        }
+
+        public static void ResetForSeekRestart()
+        {
+            if (!IsActive || !IsSeeking) return;
+            Progress01 = 0f;
+            _seekPlaybackReady = false;
+            HasEnded = false;
+        }
+
+        public static void NotifySeekPlaybackStarted()
+        {
+            if (!IsActive || !IsSeeking) return;
+            _seekPlaybackReady = true;
+        }
+
+        public static void ResetForWatchAgain()
+        {
+            if (!IsActive) return;
+            Progress01 = 0f;
+            PlaybackSpeed = 1f;
+            UserPlaybackSpeed = 1f;
+            IsSeeking = false;
+            SeekTarget01 = 0f;
+            _seekPlaybackReady = false;
+            HasEnded = false;
+        }
+
+        public static void Clear()
+        {
+            IsActive = false;
+            PlayerName = string.Empty;
+            AvatarUrl = string.Empty;
+            EntryId = string.Empty;
+            ReplayNdjson = string.Empty;
+            ReleaseAvatarTexture();
+            OriginalRandomSeed = 0;
+            Progress01 = 0f;
+            PlaybackSpeed = 1f;
+            UserPlaybackSpeed = 1f;
+            IsSeeking = false;
+            SeekTarget01 = 0f;
+            _seekPlaybackReady = false;
+            HasEnded = false;
+            SeekCompleted = null;
+        }
+
+        private static float SanitizeSpeed(float speed)
+        {
+            return float.IsNaN(speed) || float.IsInfinity(speed) || speed <= 0f ? 1f : speed;
+        }
+
+        private static void ReleaseAvatarTexture()
+        {
+            if (AvatarTexture != null)
+            {
+                UnityEngine.Object.Destroy(AvatarTexture);
+                AvatarTexture = null;
+            }
+        }
+    }
+}

package/Runtime/Internal/Replay/ReplaySessionState.cs.meta

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

package/Runtime/Internal/Replay.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e33926a8ee756c34e92345e72c0c8e17
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/ScriptableObjects/HyperSDKSettings.cs

@@ -93,6 +93,11 @@ namespace Hyper.Internal
             _settings.SetModeAsPractice();
         }
 
+        public void SetModeAsReplay()
+        {
+            _settings.SetModeAsReplay();
+        }
+
         #endregion
     }
 }

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

@@ -16,13 +16,27 @@ namespace Hyper.Internal
         {
             StartCoroutine(AnimateLoadingText());
         }
+
+        internal void SetBaseText(string value)
+        {
+            if (string.IsNullOrWhiteSpace(value)) return;
+
+            loadingBaseText = value;
+            if (loadingText != null)
+            {
+                loadingText.text = loadingBaseText;
+            }
+        }
         
         private IEnumerator AnimateLoadingText()
         {
             int i = 0;
             while (true)
             {
-                loadingText.text = loadingBaseText + loadingStates[i];
+                if (loadingText != null)
+                {
+                    loadingText.text = loadingBaseText + loadingStates[i];
+                }
                 i = (i + 1) % loadingStates.Length;
                 yield return new WaitForSecondsRealtime(dotInterval);
             }