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

package/Runtime/Internal/Managers/ReplayManager.cs

@@ -0,0 +1,117 @@
+using Hyper.Shared;
+
+namespace Hyper.Internal.Managers
+{
+    /// <summary>
+    /// Owns replay playback for the active SDK session. Games only subscribe to
+    /// typed activity callbacks; loading, timing, progress, suspension and ending
+    /// are handled here.
+    /// </summary>
+    internal sealed class ReplayManager
+    {
+        private IReplayPlaybackEngine _playback;
+        private EventManager _eventManager;
+        private bool _endingGame;
+
+        internal void Initialize(EventManager eventManager)
+        {
+            _eventManager = eventManager;
+            _eventManager.OnGameStart += HandleGameStart;
+            _eventManager.OnGameEnded += HandleGameEnded;
+            _eventManager.OnTimeScaleFrozen += HandleTimeScaleFrozen;
+            _eventManager.OnTimeScaleResumed += HandleTimeScaleResumed;
+        }
+
+        internal void AttachPlayback(IReplayPlaybackEngine playback)
+        {
+            if (ReferenceEquals(_playback, playback)) return;
+            DetachPlayback();
+            _playback = playback;
+            if (_playback == null) return;
+
+            _playback.OnGameEnded += HandlePlaybackEnded;
+        }
+
+        internal void FixedTick()
+        {
+            if (_playback == null || !_playback.IsPlaying) return;
+            _playback.Tick();
+            ReplaySessionState.SetProgress(_playback.Progress01);
+        }
+
+        internal void PrepareForRestart()
+        {
+            _endingGame = false;
+            _playback?.Stop();
+        }
+
+        internal void Cleanup()
+        {
+            if (_eventManager != null)
+            {
+                _eventManager.OnGameStart -= HandleGameStart;
+                _eventManager.OnGameEnded -= HandleGameEnded;
+                _eventManager.OnTimeScaleFrozen -= HandleTimeScaleFrozen;
+                _eventManager.OnTimeScaleResumed -= HandleTimeScaleResumed;
+            }
+
+            DetachPlayback();
+            _eventManager = null;
+        }
+
+        private void HandleGameStart()
+        {
+            if (HyperRuntime.GameManager == null || !HyperRuntime.GameManager.IsReplayMode ||
+                !ReplaySessionState.HasReplayData || _playback == null)
+            {
+                return;
+            }
+
+            if (ReplaySessionState.IsSeeking)
+            {
+                ReplaySessionState.NotifySeekPlaybackStarted();
+                UnityEngine.Time.timeScale = ReplaySessionState.PlaybackSpeed;
+            }
+
+            _playback.Begin(ReplaySessionState.ReplayNdjson);
+        }
+
+        private void HandleGameEnded()
+        {
+            if (_endingGame) return;
+            _playback?.Stop();
+        }
+
+        private void HandleTimeScaleFrozen()
+        {
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode)
+                _playback?.Suspend();
+        }
+
+        private void HandleTimeScaleResumed()
+        {
+            if (HyperRuntime.GameManager != null && HyperRuntime.GameManager.IsReplayMode)
+                _playback?.Resume();
+        }
+
+        private void HandlePlaybackEnded()
+        {
+            ReplaySessionState.MarkEnded();
+
+            GameManager gameManager = HyperRuntime.GameManager;
+            if (gameManager == null || gameManager.HasGameEnded) return;
+
+            _endingGame = true;
+            gameManager.EndGame();
+            _endingGame = false;
+        }
+
+        private void DetachPlayback()
+        {
+            if (_playback == null) return;
+            _playback.Stop();
+            _playback.OnGameEnded -= HandlePlaybackEnded;
+            _playback = null;
+        }
+    }
+}

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 _timeUpPending;
 
         private float _lastUnscaledTime;
         private bool _hasGameEnded;
@@ -64,13 +65,14 @@ namespace Hyper.Internal.Managers
             _hasBackendSessionDuration = false;
             _lastUnscaledTime = Time.unscaledTime;
             _timeUpTriggered = false;
+            _timeUpPending = 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,21 @@ namespace Hyper.Internal.Managers
             float unscaledDelta = Time.unscaledTime - _lastUnscaledTime;
             _lastUnscaledTime = Time.unscaledTime;
 
-            float gameTimerDelta = Mathf.Approximately(Time.timeScale, 0f) ? 0f : unscaledDelta;
+            UpdateSessionTimer(unscaledDelta);
+            DispatchPendingTimeUp();
+        }
+
+        internal void FixedTick()
+        {
+            if (Mathf.Approximately(Time.timeScale, 0f))
+                return;
+
+            float gameTimerDelta = _gameManager != null && _gameManager.IsReplayMode
+                ? Time.fixedDeltaTime
+                : Time.fixedUnscaledDeltaTime;
 
             UpdatePracticeTimer(gameTimerDelta);
             UpdateBattleTimer(gameTimerDelta);
-            UpdateSessionTimer(unscaledDelta);
         }
 
         public void Reset()
@@ -102,9 +114,22 @@ namespace Hyper.Internal.Managers
             _lastUnscaledTime = Time.unscaledTime;
         }
 
+        internal void ResetForGameRestart()
+        {
+            _practiceTimer = 0f;
+            _battleTimer = _gameManager != null ? _gameManager.Config.TimeLimit : 0f;
+            _isPracticeRunning = false;
+            _isBattleRunning = false;
+            _timeUpTriggered = false;
+            _timeUpPending = false;
+            _hasGameEnded = false;
+            _hasGameStarted = false;
+            _lastUnscaledTime = Time.unscaledTime;
+        }
+
         public void ResumeGameTimersAfterPause()
         {
-            if (_gameManager.Config.GameMode == GameMode.Battle)
+            if (_gameManager.IsBattleMode)
             {
                 StartBattle();
             }
@@ -116,7 +141,7 @@ namespace Hyper.Internal.Managers
 
         public void StartActiveGameTimer()
         {
-            if (_gameManager.Config.GameMode == GameMode.Battle)
+            if (_gameManager.IsBattleMode)
             {
                 StartSessionTimer();
                 StartBattle();
@@ -132,6 +157,7 @@ namespace Hyper.Internal.Managers
         public void StopAllTimers()
         {
             _hasGameEnded = true;
+            _timeUpPending = false;
             StopBattle();
             StopPractice();
         }
@@ -247,7 +273,7 @@ namespace Hyper.Internal.Managers
         {
             if (_isBattleRunning)
             {
-                if (_gameManager.Config.GameMode == GameMode.Battle &&
+                if (_gameManager.IsBattleMode &&
                     _hasGameStarted &&
                     _isPreSessionRunning &&
                     _sessionTimer <= _battleTimer)
@@ -261,8 +287,7 @@ namespace Hyper.Internal.Managers
                     _battleTimer = 0;
                     if (!_timeUpTriggered)
                     {
-                        _timeUpTriggered = true;
-                        _eventManager?.InvokeTimeUpEvent();
+                        QueueTimeUp();
                     }
                 }
             }
@@ -274,13 +299,30 @@ namespace Hyper.Internal.Managers
 
                     if (_battleTimer <= 0 && !_timeUpTriggered)
                     {
-                        _timeUpTriggered = true;
-                        _eventManager?.InvokeTimeUpEvent();
+                        QueueTimeUp();
                     }
                 }
             }
         }
 
+        private void QueueTimeUp()
+        {
+            _timeUpPending = true;
+        }
+
+        private void DispatchPendingTimeUp()
+        {
+            if (!_timeUpPending)
+                return;
+
+            _timeUpPending = 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
     }
 }