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

package/Runtime/Public/Replay/ReplayPlaybackEngine.cs

@@ -0,0 +1,555 @@
+using System;
+using Hyper.Shared;
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+
+namespace Hyper
+{
+    /// <summary>
+    /// Internal fixed-step scheduler for compact NDJSON replay activities.
+    /// </summary>
+    internal sealed class ReplayPlaybackEngine : IReplayPlaybackEngine
+    {
+        private const string GameStarted = "GS";
+        private const string GamePaused = "GP";
+        private const string GameResumed = "GR";
+        private const string GameEnded = "GE";
+        private const int MaxActivitiesPerTick = 4096;
+
+        private string _ndjson;
+        private int _cursor;
+        private ReplayActivity _next;
+        private bool _hasNext;
+        private bool _endedRaised;
+        private bool _nextActionPrepared;
+        private double _sourceStartTime;
+        private double _elapsedSeconds;
+        private double _removedPauseDuration;
+        private double _stoppedElapsed;
+        private bool _isSuspended;
+        private bool _completionPending;
+
+        public event Action<float, float> OnValues2;
+        public event Action<float> OnValue;
+        public event Action<float, float, float> OnValues;
+        public event Action<string> OnAction;
+        public event Action<string, string> OnActions;
+        public event Action<string, float, float> OnActionValues;
+        public event Action<float, float, string> OnValuesAction;
+        public event Action<string, float> OnActionValue;
+        public event Action<float, string> OnValueAction;
+        /// <summary>
+        /// Invoked shortly before an ordinary string action when
+        /// <see cref="ActionPreparationLeadSeconds"/> is greater than zero.
+        /// Use this for presentation only; gameplay belongs in <see cref="OnAction"/>.
+        /// </summary>
+        public event Action<string> OnActionPreparing;
+        public event Action OnGameStarted;
+        public event Action OnGameEnded;
+
+        public bool IsPlaying { get; private set; }
+        public double DurationSeconds { get; private set; }
+        public double ElapsedSeconds => GetElapsedSeconds();
+        /// <summary>
+        /// Optional lead time for preparing visual feedback before an ordinary string action.
+        /// The action itself is still dispatched at its recorded timestamp.
+        /// </summary>
+        public double ActionPreparationLeadSeconds { get; set; }
+        public float Progress01 => DurationSeconds <= 0d
+            ? (IsPlaying ? 0f : 1f)
+            : Mathf.Clamp01((float)(ElapsedSeconds / DurationSeconds));
+
+        public void Begin(string ndjson)
+        {
+            Stop();
+
+            _ndjson = ndjson ?? string.Empty;
+            _cursor = 0;
+            _removedPauseDuration = 0d;
+            _elapsedSeconds = 0d;
+            _stoppedElapsed = 0d;
+            _isSuspended = false;
+            _endedRaised = false;
+            _completionPending = false;
+            _nextActionPrepared = false;
+            DurationSeconds = CalculateDuration(_ndjson);
+            _hasNext = TryReadNext(out _next);
+
+            if (!_hasNext)
+            {
+                Complete();
+                return;
+            }
+
+            _sourceStartTime = _next.Time;
+            IsPlaying = true;
+        }
+
+        /// <summary>
+        /// Advances replay by one Unity fixed step. Call this from FixedUpdate.
+        /// Playback speed comes from Unity's fixed-step frequency through Time.timeScale.
+        /// </summary>
+        public void Tick()
+        {
+            Tick(Time.fixedDeltaTime);
+        }
+
+        /// <summary>
+        /// Advances replay using an explicit simulation-step duration.
+        /// </summary>
+        public void Tick(double fixedSimulationDeltaSeconds)
+        {
+            if (!IsPlaying || _isSuspended) return;
+
+            // GE becomes observable on the next fixed tick. The simulation step
+            // containing GE can therefore complete before game-end callbacks run.
+            if (_completionPending)
+            {
+                Complete();
+                return;
+            }
+
+            double delta = double.IsNaN(fixedSimulationDeltaSeconds) ||
+                           double.IsInfinity(fixedSimulationDeltaSeconds)
+                ? 0d
+                : Math.Max(0d, fixedSimulationDeltaSeconds);
+            _elapsedSeconds += delta;
+
+            int processed = 0;
+            while (IsPlaying && !_completionPending && _hasNext && processed++ < MaxActivitiesPerTick)
+            {
+                double elapsed = GetElapsedSeconds();
+                double dueTime = _next.Time - _sourceStartTime - _removedPauseDuration;
+                PrepareNextActionIfDue(elapsed, dueTime);
+                if (elapsed + 0.000001d < dueTime) return;
+
+                ReplayActivity activity = _next;
+                _hasNext = TryReadNext(out _next);
+                _nextActionPrepared = false;
+                Dispatch(activity);
+            }
+
+            if (IsPlaying && !_completionPending && !_hasNext)
+            {
+                ScheduleCompletion();
+            }
+        }
+
+        public void Stop()
+        {
+            _stoppedElapsed = IsPlaying ? _elapsedSeconds : _stoppedElapsed;
+            IsPlaying = false;
+            _ndjson = null;
+            _cursor = 0;
+            _hasNext = false;
+            _isSuspended = false;
+            _completionPending = false;
+            _nextActionPrepared = false;
+        }
+
+        public void Suspend()
+        {
+            if (!IsPlaying || _isSuspended) return;
+            _isSuspended = true;
+        }
+
+        public void Resume()
+        {
+            if (!IsPlaying || !_isSuspended) return;
+            _isSuspended = false;
+        }
+
+        private void Dispatch(ReplayActivity activity)
+        {
+            if (activity.Kind == ReplayActivityKind.Values2)
+            {
+                OnValues2?.Invoke(activity.X, activity.Y);
+                return;
+            }
+
+            if (activity.Kind == ReplayActivityKind.Value)
+            {
+                OnValue?.Invoke(activity.X);
+                return;
+            }
+
+            if (activity.Kind == ReplayActivityKind.Values)
+            {
+                OnValues?.Invoke(activity.X, activity.Y, activity.Z);
+                return;
+            }
+
+            if (activity.Kind == ReplayActivityKind.Actions)
+            {
+                OnActions?.Invoke(activity.Action, activity.SecondAction);
+                return;
+            }
+
+            if (activity.Kind == ReplayActivityKind.ActionValues)
+            {
+                OnActionValues?.Invoke(activity.Action, activity.X, activity.Y);
+                return;
+            }
+
+            if (activity.Kind == ReplayActivityKind.ValuesAction)
+            {
+                OnValuesAction?.Invoke(activity.X, activity.Y, activity.Action);
+                return;
+            }
+
+            if (activity.Kind == ReplayActivityKind.ActionValue)
+            {
+                OnActionValue?.Invoke(activity.Action, activity.X);
+                return;
+            }
+
+            if (activity.Kind == ReplayActivityKind.ValueAction)
+            {
+                OnValueAction?.Invoke(activity.X, activity.Action);
+                return;
+            }
+
+            switch (activity.Action)
+            {
+                case GameStarted:
+                    OnGameStarted?.Invoke();
+                    break;
+                case GamePaused:
+                    SkipRecordedPause(activity.Time);
+                    break;
+                case GameResumed:
+                    break;
+                case GameEnded:
+                    ScheduleCompletion();
+                    break;
+                default:
+                    OnAction?.Invoke(activity.Action);
+                    break;
+            }
+        }
+
+        private void PrepareNextActionIfDue(double elapsed, double dueTime)
+        {
+            if (_nextActionPrepared || ActionPreparationLeadSeconds <= 0d ||
+                _next.Kind != ReplayActivityKind.Action || IsLifecycleAction(_next.Action))
+            {
+                return;
+            }
+
+            double preparationTime = dueTime - ActionPreparationLeadSeconds;
+            if (elapsed + 0.000001d < preparationTime) return;
+
+            _nextActionPrepared = true;
+            OnActionPreparing?.Invoke(_next.Action);
+        }
+
+        private static bool IsLifecycleAction(string action)
+        {
+            return action == GameStarted || action == GamePaused ||
+                   action == GameResumed || action == GameEnded;
+        }
+
+        private void SkipRecordedPause(double pauseStartedAt)
+        {
+            _nextActionPrepared = false;
+            while (_hasNext)
+            {
+                ReplayActivity activity = _next;
+                _hasNext = TryReadNext(out _next);
+
+                if (activity.Kind != ReplayActivityKind.Action) continue;
+
+                if (activity.Action == GameResumed)
+                {
+                    _removedPauseDuration += Math.Max(0d, activity.Time - pauseStartedAt);
+                    return;
+                }
+
+                if (activity.Action == GameEnded)
+                {
+                    ScheduleCompletion();
+                    return;
+                }
+            }
+
+            ScheduleCompletion();
+        }
+
+        private void ScheduleCompletion()
+        {
+            _stoppedElapsed = DurationSeconds;
+            _completionPending = true;
+            _hasNext = false;
+            _nextActionPrepared = false;
+        }
+
+        private void Complete()
+        {
+            _stoppedElapsed = DurationSeconds;
+            IsPlaying = false;
+            _completionPending = false;
+            _ndjson = null;
+            _hasNext = false;
+            if (_endedRaised) return;
+
+            _endedRaised = true;
+            OnGameEnded?.Invoke();
+        }
+
+        private double GetElapsedSeconds()
+        {
+            if (!IsPlaying) return Math.Max(0d, _stoppedElapsed);
+            return Math.Max(0d, _elapsedSeconds);
+        }
+
+        private static double CalculateDuration(string ndjson)
+        {
+            if (string.IsNullOrWhiteSpace(ndjson)) return 0d;
+
+            int cursor = 0;
+            bool hasFirst = false;
+            double firstTime = 0d;
+            double lastEffectiveTime = 0d;
+            double removedPauses = 0d;
+            double? pauseStartedAt = null;
+
+            while (TryReadLine(ndjson, ref cursor, out string line))
+            {
+                if (!TryParse(line, out ReplayActivity activity)) continue;
+                if (!hasFirst)
+                {
+                    hasFirst = true;
+                    firstTime = activity.Time;
+                }
+
+                if (activity.Kind == ReplayActivityKind.Action && activity.Action == GamePaused)
+                {
+                    pauseStartedAt ??= activity.Time;
+                    lastEffectiveTime = Math.Max(0d, activity.Time - firstTime - removedPauses);
+                    continue;
+                }
+
+                if (activity.Kind == ReplayActivityKind.Action && activity.Action == GameResumed && pauseStartedAt.HasValue)
+                {
+                    removedPauses += Math.Max(0d, activity.Time - pauseStartedAt.Value);
+                    pauseStartedAt = null;
+                    continue;
+                }
+
+                if (pauseStartedAt.HasValue)
+                {
+                    if (activity.Kind == ReplayActivityKind.Action && activity.Action == GameEnded) break;
+                    continue;
+                }
+
+                lastEffectiveTime = Math.Max(0d, activity.Time - firstTime - removedPauses);
+                if (activity.Kind == ReplayActivityKind.Action && activity.Action == GameEnded) break;
+            }
+
+            return hasFirst ? lastEffectiveTime : 0d;
+        }
+
+        private bool TryReadNext(out ReplayActivity activity)
+        {
+            while (TryReadLine(out string line))
+            {
+                if (TryParse(line, out activity)) return true;
+                if (IsMetadataRecord(line)) continue;
+                Debug.LogWarning($"[Hyper Replay] Skipping malformed activity: {line}");
+            }
+
+            activity = default;
+            return false;
+        }
+
+        private bool TryReadLine(out string line)
+        {
+            return TryReadLine(_ndjson, ref _cursor, out line);
+        }
+
+        private static bool TryReadLine(string ndjson, ref int cursor, out string line)
+        {
+            line = null;
+            if (string.IsNullOrEmpty(ndjson) || cursor >= ndjson.Length) return false;
+
+            int start = cursor;
+            while (cursor < ndjson.Length && ndjson[cursor] != '\n' && ndjson[cursor] != '\r') cursor++;
+            line = ndjson.Substring(start, cursor - start).Trim();
+            while (cursor < ndjson.Length && (ndjson[cursor] == '\n' || ndjson[cursor] == '\r')) cursor++;
+            return true;
+        }
+
+        private static bool TryParse(string line, out ReplayActivity activity)
+        {
+            activity = default;
+            if (string.IsNullOrWhiteSpace(line)) return false;
+
+            try
+            {
+                var values = JArray.Parse(line);
+                if (values.Count < 2 || values.Count > 4 || values[0].Type != JTokenType.Integer && values[0].Type != JTokenType.Float)
+                {
+                    return false;
+                }
+
+                double time = values[0].Value<double>();
+                if (values.Count == 3 && IsNumber(values[1]) && IsNumber(values[2]))
+                {
+                    activity = ReplayActivity.Values2(time, values[1].Value<float>(), values[2].Value<float>());
+                    return true;
+                }
+
+                if (values.Count == 2 && IsNumber(values[1]))
+                {
+                    activity = ReplayActivity.Value(time, values[1].Value<float>());
+                    return true;
+                }
+
+                if (values.Count == 2 && values[1].Type == JTokenType.String)
+                {
+                    string action = values[1].Value<string>();
+                    if (string.IsNullOrWhiteSpace(action)) return false;
+                    activity = ReplayActivity.NamedAction(time, action);
+                    return true;
+                }
+
+
+                if (values.Count == 3 && values[1].Type == JTokenType.String && values[2].Type == JTokenType.String)
+                {
+                    string firstAction = values[1].Value<string>();
+                    string secondAction = values[2].Value<string>();
+                    if (string.IsNullOrWhiteSpace(firstAction) || string.IsNullOrWhiteSpace(secondAction)) return false;
+                    activity = ReplayActivity.NamedActions(time, firstAction, secondAction);
+                    return true;
+                }
+
+                if (values.Count == 3 && values[1].Type == JTokenType.String && IsNumber(values[2]))
+                {
+                    string action = values[1].Value<string>();
+                    if (string.IsNullOrWhiteSpace(action)) return false;
+                    activity = ReplayActivity.ActionValue(time, action, values[2].Value<float>());
+                    return true;
+                }
+
+                if (values.Count == 3 && IsNumber(values[1]) && values[2].Type == JTokenType.String)
+                {
+                    string action = values[2].Value<string>();
+                    if (string.IsNullOrWhiteSpace(action)) return false;
+                    activity = ReplayActivity.ValueAction(time, values[1].Value<float>(), action);
+                    return true;
+                }
+
+                if (values.Count == 4 && IsNumber(values[1]) && IsNumber(values[2]) && IsNumber(values[3]))
+                {
+                    activity = ReplayActivity.Values(time, values[1].Value<float>(), values[2].Value<float>(), values[3].Value<float>());
+                    return true;
+                }
+
+                if (values.Count == 4 && values[1].Type == JTokenType.String && IsNumber(values[2]) && IsNumber(values[3]))
+                {
+                    string action = values[1].Value<string>();
+                    if (string.IsNullOrWhiteSpace(action)) return false;
+                    activity = ReplayActivity.ActionValues(time, action, values[2].Value<float>(), values[3].Value<float>());
+                    return true;
+                }
+
+                if (values.Count == 4 && IsNumber(values[1]) && IsNumber(values[2]) && values[3].Type == JTokenType.String)
+                {
+                    string action = values[3].Value<string>();
+                    if (string.IsNullOrWhiteSpace(action)) return false;
+                    activity = ReplayActivity.ValuesAction(time, values[1].Value<float>(), values[2].Value<float>(), action);
+                    return true;
+                }
+            }
+            catch
+            {
+                return false;
+            }
+
+            return false;
+        }
+
+        private static bool IsNumber(JToken value)
+        {
+            return value.Type == JTokenType.Integer || value.Type == JTokenType.Float;
+        }
+
+        private static bool IsMetadataRecord(string line)
+        {
+            try
+            {
+                var values = JArray.Parse(line);
+                if (values.Count != 2 || values[0].Type != JTokenType.String) return false;
+
+                string key = values[0].Value<string>();
+                return key == "seed" || key == "name" || key == "url";
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        private enum ReplayActivityKind
+        {
+            Values2,
+            Value,
+            Values,
+            Actions,
+            ActionValues,
+            ValuesAction,
+            ActionValue,
+            ValueAction,
+            Action
+        }
+
+        private readonly struct ReplayActivity
+        {
+            internal readonly double Time;
+            internal readonly ReplayActivityKind Kind;
+            internal readonly float X;
+            internal readonly float Y;
+            internal readonly float Z;
+            internal readonly string Action;
+            internal readonly string SecondAction;
+
+            private ReplayActivity(double time, ReplayActivityKind kind, float x, float y, float z, string action, string secondAction)
+            {
+                Time = time;
+                Kind = kind;
+                X = x;
+                Y = y;
+                Z = z;
+                Action = action;
+                SecondAction = secondAction;
+            }
+
+            internal static ReplayActivity Values2(double time, float first, float second) =>
+                new ReplayActivity(time, ReplayActivityKind.Values2, first, second, 0f, null, null);
+
+            internal static ReplayActivity Value(double time, float value) =>
+                new ReplayActivity(time, ReplayActivityKind.Value, value, 0f, 0f, null, null);
+
+            internal static ReplayActivity Values(double time, float first, float second, float third) =>
+                new ReplayActivity(time, ReplayActivityKind.Values, first, second, third, null, null);
+
+            internal static ReplayActivity NamedAction(double time, string action) =>
+                new ReplayActivity(time, ReplayActivityKind.Action, 0f, 0f, 0f, action, null);
+
+            internal static ReplayActivity NamedActions(double time, string firstAction, string secondAction) =>
+                new ReplayActivity(time, ReplayActivityKind.Actions, 0f, 0f, 0f, firstAction, secondAction);
+
+            internal static ReplayActivity ActionValues(double time, string action, float first, float second) =>
+                new ReplayActivity(time, ReplayActivityKind.ActionValues, first, second, 0f, action, null);
+
+            internal static ReplayActivity ValuesAction(double time, float first, float second, string action) =>
+                new ReplayActivity(time, ReplayActivityKind.ValuesAction, first, second, 0f, action, null);
+
+            internal static ReplayActivity ActionValue(double time, string action, float value) =>
+                new ReplayActivity(time, ReplayActivityKind.ActionValue, value, 0f, 0f, action, null);
+
+            internal static ReplayActivity ValueAction(double time, float value, string action) =>
+                new ReplayActivity(time, ReplayActivityKind.ValueAction, value, 0f, 0f, action, null);
+        }
+    }
+}

package/Runtime/Public/Replay/ReplayPlaybackEngine.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 09fd814441e21384fae42ef4a5132512

package/Runtime/Public/Replay.meta

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