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

package/CHANGELOG.md

@@ -1,3 +1,100 @@
+# [1.11.0-beta.10](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.9...v1.11.0-beta.10) (2026-08-30)
+
+
+### Bug Fixes
+
+* **replay:** reduce default seek speed ([f70551a](https://github.com/mvmhyper/hyper-sdk/commit/f70551aea942274ace1cb952ddae4e9edb0c1c12))
+
+# [1.11.0-beta.9](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.8...v1.11.0-beta.9) (2026-08-30)
+
+
+### Bug Fixes
+
+* **replay:** show loader while exiting paused replay ([4a2e7a6](https://github.com/mvmhyper/hyper-sdk/commit/4a2e7a6045017ea8ed3ae3525271440dbf013e6c))
+
+# [1.11.0-beta.8](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.7...v1.11.0-beta.8) (2026-08-30)
+
+
+### Bug Fixes
+
+* **replay:** mute audio while seeking ([5ab8cd1](https://github.com/mvmhyper/hyper-sdk/commit/5ab8cd1411493cb5add07b51dc190c85251f99d2))
+
+# [1.11.0-beta.7](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.6...v1.11.0-beta.7) (2026-08-30)
+
+
+### Bug Fixes
+
+* **replay:** stabilize scene reload seeking ([dd9ac63](https://github.com/mvmhyper/hyper-sdk/commit/dd9ac632d08349d9578f64ae0b2dc2ab905a26af))
+
+# [1.11.0-beta.6](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.5...v1.11.0-beta.6) (2026-08-29)
+
+
+### Bug Fixes
+
+* **timer:** restore gameplay timers after pause ([ca82d57](https://github.com/mvmhyper/hyper-sdk/commit/ca82d57df87618807cbae611c0a9d6acc14f8470))
+
+# [1.11.0-beta.5](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.4...v1.11.0-beta.5) (2026-08-28)
+
+
+### Bug Fixes
+
+* **replay:** wait for custom restart readiness ([43f1aeb](https://github.com/mvmhyper/hyper-sdk/commit/43f1aeb6a127c8c12dbb8379e7230d64ef5e0763))
+
+
+### Features
+
+* **replay:** add replay pause controls ([b9fb470](https://github.com/mvmhyper/hyper-sdk/commit/b9fb470e65c69e66a8a9611b0caa7e5417b1e4bf))
+* **replay:** update replay control bar assets ([79ce8c0](https://github.com/mvmhyper/hyper-sdk/commit/79ce8c0f1b68129ae5b8bcf18a302117cf11c885))
+
+# [1.11.0-beta.4](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.3...v1.11.0-beta.4) (2026-08-28)
+
+
+### Bug Fixes
+
+* **replay:** align recording with fixed simulation ([ae2b322](https://github.com/mvmhyper/hyper-sdk/commit/ae2b32216a0a9ea125572d788eee3bfd846414b0))
+
+# [1.11.0-beta.3](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.2...v1.11.0-beta.3) (2026-08-28)
+
+
+### Bug Fixes
+
+* **replay:** reset random state before playback restart ([526a4d9](https://github.com/mvmhyper/hyper-sdk/commit/526a4d98c9b22241e3c52bb6837145bad999fb2b))
+* **sample:** support lane runner custom restart ([49da385](https://github.com/mvmhyper/hyper-sdk/commit/49da385aaa917de438672a8630d4fe7927741b2a))
+
+# [1.11.0-beta.2](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.1...v1.11.0-beta.2) (2026-08-27)
+
+
+### Bug Fixes
+
+* **replay:** respect custom restart flows ([7470a17](https://github.com/mvmhyper/hyper-sdk/commit/7470a17c60534465500a202c24b0e360f61850fc))
+* **replay:** shorten automatic replay start ([d05dc92](https://github.com/mvmhyper/hyper-sdk/commit/d05dc9267fbf05d392135eac3bb7c4f69b786eff))
+* **timer:** align game time with fixed simulation ([b690d86](https://github.com/mvmhyper/hyper-sdk/commit/b690d861e178f05b21f1a7fbd87e255d97008a8b))
+
+# [1.11.0-beta.1](https://github.com/mvmhyper/hyper-sdk/compare/v1.10.0...v1.11.0-beta.1) (2026-08-26)
+
+
+### Bug Fixes
+
+* **replay:** add player handle font glyph ([5ba9f0d](https://github.com/mvmhyper/hyper-sdk/commit/5ba9f0d0c3e207b4ff0a4b4f16ffe53bd215ea14))
+* **replay:** handle backend loading failures ([1d299cf](https://github.com/mvmhyper/hyper-sdk/commit/1d299cf7d1002d5632cd0b1da2c928405b50e56a))
+* **replay:** harden web replay playback ([96f0521](https://github.com/mvmhyper/hyper-sdk/commit/96f05215f6a483306622b632366de20b58ede6e9))
+* **replay:** preserve recorded action timing ([48ff268](https://github.com/mvmhyper/hyper-sdk/commit/48ff268c16b0ddd5fd4e81e0903d4b54b05d4a1c))
+* **replay:** refine replay ui behavior ([8a9364f](https://github.com/mvmhyper/hyper-sdk/commit/8a9364fb19f6ccd6df31a396bf7fef30c5f66040))
+* **score:** preserve latest final snapshot time ([b9242cd](https://github.com/mvmhyper/hyper-sdk/commit/b9242cd5478702621fbc30a1bd21a972bbf9fb4c))
+
+
+### Features
+
+* **replay:** add math rush replay integration ([394e8b0](https://github.com/mvmhyper/hyper-sdk/commit/394e8b0591c99899b5f2433bbadf159aa4631d47))
+* **replay:** add replay activity recording ([8b87b42](https://github.com/mvmhyper/hyper-sdk/commit/8b87b425440ebfa4d08fcc9d62586afde58fda33))
+* **replay:** add replay playback scheduling ([40c9c83](https://github.com/mvmhyper/hyper-sdk/commit/40c9c83a886b06434ee886fa85f490ca74710ac6))
+* **replay:** add replay ui flows ([e287986](https://github.com/mvmhyper/hyper-sdk/commit/e287986222763c814a299cfcb81d1cd14bcf49e9))
+* **replay:** add replay visual assets ([4c61645](https://github.com/mvmhyper/hyper-sdk/commit/4c616458155e04444feac9fb187b63f646035f7a))
+* **replay:** add stable replay launch mode ([fbfd8fc](https://github.com/mvmhyper/hyper-sdk/commit/fbfd8fcdc5a7119f7c3655f1a033705ccd47608f))
+* **replay:** align playback with fixed simulation ([8e4051d](https://github.com/mvmhyper/hyper-sdk/commit/8e4051d5d41fe3dbc4d050ee4f961ae6d690d1bd))
+* **replay:** finalize playback simulation and seeking ([de3b6e7](https://github.com/mvmhyper/hyper-sdk/commit/de3b6e79be4ecde5abc4bb20190e80f12fbe3598))
+* **replay:** load replay data from backend ([f89c067](https://github.com/mvmhyper/hyper-sdk/commit/f89c067b6e55074c08f75e34c0d378af969b60c5))
+
 # [1.10.0](https://github.com/mvmhyper/hyper-sdk/compare/v1.9.1...v1.10.0) (2026-08-10)
 
 

package/Editor/Scripts/Setup/HyperSDKInstaller.cs

@@ -20,9 +20,51 @@ namespace Hyper.Editor
         private const string HyperSDKSettingsRelativePath = "Runtime/Resources/HyperSDKSettings.asset";
         private const string HyperGameContentConfigDestination = "Assets/HyperSDK/Runtime/Resources/HyperGameContentConfig.asset";
         private const string HyperSDKSettingsDestination = "Assets/HyperSDK/Runtime/Resources/HyperSDKSettings.asset";
+        private const string LaneRunnerSampleRelativePath = "Samples~/LaneRunner";
+        private const string LaneRunnerSampleDestination = "Assets/Samples/HyperSDK/Lane Runner";
 
         private static bool _hasChecked = false;
 
+        [MenuItem("Hyper/Samples/Import Lane Runner", priority = 100)]
+        private static void ImportLaneRunnerSample()
+        {
+            var packageInfo = UnityEditor.PackageManager.PackageInfo.FindForAssembly(typeof(HyperSDKInstaller).Assembly);
+            if (packageInfo == null || string.IsNullOrEmpty(packageInfo.resolvedPath) ||
+                packageInfo.resolvedPath.Replace('\\', '/').Contains("/Assets/"))
+            {
+                var developmentSample = AssetDatabase.LoadAssetAtPath<SceneAsset>(
+                    "Assets/SampleGame (Lane Runner)/LaneRunnerSample.unity");
+                Selection.activeObject = developmentSample;
+                EditorGUIUtility.PingObject(developmentSample);
+                return;
+            }
+
+            string sourcePath = Path.Combine(packageInfo.resolvedPath, LaneRunnerSampleRelativePath);
+
+            if (!Directory.Exists(sourcePath))
+            {
+                EditorUtility.DisplayDialog("Lane Runner Sample",
+                    "The Lane Runner sample was not found in this HyperSDK installation.", "OK");
+                return;
+            }
+
+            if (Directory.Exists(LaneRunnerSampleDestination))
+            {
+                EditorUtility.DisplayDialog("Lane Runner Sample",
+                    "Lane Runner is already imported at Assets/Samples/HyperSDK/Lane Runner.", "OK");
+                return;
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(LaneRunnerSampleDestination));
+            FileUtil.CopyFileOrDirectory(sourcePath, LaneRunnerSampleDestination);
+            AssetDatabase.Refresh();
+
+            var scene = AssetDatabase.LoadAssetAtPath<SceneAsset>(
+                LaneRunnerSampleDestination + "/LaneRunnerSample.unity");
+            Selection.activeObject = scene;
+            EditorGUIUtility.PingObject(scene);
+        }
+
         static HyperSDKInstaller()
         {
             // Only register delayCall once per domain reload

package/Editor/Scripts/Tools/HyperGameModeMenu.cs

@@ -8,11 +8,12 @@ namespace Hyper.Editor
 {
     static class HyperGameModeMenu
     {
-        private enum DevMode { Practice = 0, Battle = 1 }
+        private enum DevMode { Practice = 0, Battle = 1, Replay = 2 }
         private const string PrefKey = "Hyper.DevMode";
 
         private const string BattlePath   = "Hyper/Battle Game Mode";
         private const string PracticePath = "Hyper/Practice Game Mode";
+        private const string ReplayPath   = "Hyper/Replay Game Mode";
 
         private static HyperSDKSettings _settings;
 
@@ -26,10 +27,14 @@ namespace Hyper.Editor
         }
 
         private static DevMode FromSettings(GameMode gm)
-            => gm == GameMode.Battle ? DevMode.Battle : DevMode.Practice;
-
-        private static GameMode ToSettings(DevMode dm)
-            => dm == DevMode.Battle ? GameMode.Battle : GameMode.Practice;
+        {
+            switch (gm)
+            {
+                case GameMode.Battle: return DevMode.Battle;
+                case GameMode.Replay: return DevMode.Replay;
+                default: return DevMode.Practice;
+            }
+        }
 
         private static DevMode Current
         {
@@ -44,8 +49,12 @@ namespace Hyper.Editor
             {
                 if (TryLoadSettings(out var s))
                 {
-                    if (value == DevMode.Battle) s.SetModeAsBattle();
-                    else s.SetModeAsPractice();
+                    switch (value)
+                    {
+                        case DevMode.Battle: s.SetModeAsBattle(); break;
+                        case DevMode.Replay: s.SetModeAsReplay(); break;
+                        default: s.SetModeAsPractice(); break;
+                    }
 
                     EditorUtility.SetDirty(s);
                     AssetDatabase.SaveAssets();
@@ -84,6 +93,16 @@ namespace Hyper.Editor
             return !EditorApplication.isPlaying;
         }
 
+        [MenuItem(ReplayPath, priority = 300)]
+        private static void SetReplay() => SetMode(DevMode.Replay);
+
+        [MenuItem(ReplayPath, validate = true)]
+        private static bool ValidateReplay()
+        {
+            Menu.SetChecked(ReplayPath, Current == DevMode.Replay);
+            return !EditorApplication.isPlaying;
+        }
+
         #endregion
 
         private static void SetMode(DevMode mode)
@@ -94,6 +113,7 @@ namespace Hyper.Editor
 
             Menu.SetChecked(BattlePath,   mode == DevMode.Battle);
             Menu.SetChecked(PracticePath, mode == DevMode.Practice);
+            Menu.SetChecked(ReplayPath,   mode == DevMode.Replay);
 
             HyperDebug.LogSuccess($"Game Mode set to: {mode}");
         }

package/Runtime/Internal/AssemblyInfo.cs

@@ -2,4 +2,5 @@ using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("Hyper")]
 [assembly: InternalsVisibleTo("Hyper.Editor")]
+[assembly: InternalsVisibleTo("Hyper.Tests.EditMode")]
 

package/Runtime/Internal/Bootstrap/HyperLoader.cs

@@ -1,6 +1,9 @@
 using Hyper.Internal.Managers;
 using System;
 using System.Collections;
+#if UNITY_EDITOR
+using System.IO;
+#endif
 using TMPro;
 using UnityEngine;
 using UnityEngine.SceneManagement;
@@ -60,6 +63,11 @@ namespace Hyper.Internal
             InitializeComponents();
             LoadConfiguration();
             SetupSplashScreen();
+
+            if (ReplaySessionState.IsSeeking)
+            {
+                SetLoaderCanvasVisible(false);
+            }
         }
 
         private void Start()
@@ -74,6 +82,15 @@ namespace Hyper.Internal
 
         #endregion
 
+        private void SetLoaderCanvasVisible(bool isVisible)
+        {
+            Canvas[] canvases = GetComponentsInChildren<Canvas>(true);
+            for (int i = 0; i < canvases.Length; i++)
+            {
+                canvases[i].enabled = isVisible;
+            }
+        }
+
         #region Initialization
 
         private void InitializeComponents()
@@ -115,7 +132,7 @@ namespace Hyper.Internal
         private static T LoadResourceFromAssets<T>(string resourceName) where T : UnityEngine.Object
         {
             T[] allResources = Resources.LoadAll<T>(string.Empty);
-            
+
             if (allResources == null || allResources.Length == 0)
             {
                 return Resources.Load<T>(resourceName);
@@ -247,9 +264,13 @@ namespace Hyper.Internal
             {
                 sdkInitialized = true;
 
-                if (_eventManager == null) _eventManager = HyperRuntime.EventManager;
-                if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
-                if (_backendManager == null) _backendManager = HyperRuntime.BackendManager;
+                // Bootstrap retries recreate the runtime managers. Always bind the
+                // current instances rather than retaining objects queued for destruction.
+                _eventManager = HyperRuntime.EventManager;
+                _gameManager = HyperRuntime.GameManager;
+                _backendManager = HyperRuntime.BackendManager;
+                UpdateLoadingTextForMode();
+                UpdateHintVisibilityForMode();
                 SubscribeToEvents();
             });
 
@@ -264,14 +285,23 @@ namespace Hyper.Internal
             _loadingBarSlider.value = _bootstrapProgress;
 
             // Start tutorial discovery early, but never wait for it before loading gameplay.
-            HyperRuntime.BackendManager.GetTutorial(null);
+            if (!_gameManager.IsReplayMode)
+            {
+                HyperRuntime.BackendManager.GetTutorial(null);
+            }
 
             // Step 2: Handle Backend/PVP or Practice mode initialization
-            if (_gameManager.Config.IsBackendGame && _gameManager.Config.isPVP)
+            if (_gameManager.IsReplayMode)
+            {
+                bool replayInitialized = false;
+                yield return InitializeReplay(success => replayInitialized = success);
+                if (!replayInitialized) yield break;
+            }
+            else if (_gameManager.Config.IsBackendGame && _gameManager.Config.isPVP)
             {
                 yield return InitializeBackendGame();
             }
-            else if (_gameManager.Config.GameMode == GameMode.Battle)
+            else if (_gameManager.IsBattleMode)
             {
                 InitializeNonBackendBattle();
             }
@@ -328,6 +358,117 @@ namespace Hyper.Internal
             _loadingBarSlider.value = _bootstrapProgress;
         }
 
+        private IEnumerator InitializeReplay(Action<bool> onComplete)
+        {
+            _targetSceneName = _gameContentConfig.GameScene?.SceneName;
+
+            if (!ReplaySessionState.HasReplayData)
+            {
+#if UNITY_EDITOR
+                if (string.IsNullOrWhiteSpace(_gameManager.Config.EntryId))
+                {
+                    if (TryLoadEditorReplay(out string editorReplayError))
+                    {
+                        _backendManager.RegisterSeed(GetRandomSeed());
+                        onComplete?.Invoke(true);
+                        yield break;
+                    }
+
+                    HandleReplayLoadingFailure(editorReplayError, onComplete);
+                    yield break;
+                }
+#endif
+                bool replayDownloaded = false;
+                string replayError = null;
+                yield return _backendManager.FetchReplay(
+                    _gameManager.Config.EntryId,
+                    () => replayDownloaded = true,
+                    error => replayError = error);
+
+                if (!replayDownloaded || !ReplaySessionState.HasReplayData)
+                {
+                    HandleReplayLoadingFailure($"Unable to load replay: {replayError}", onComplete);
+                    yield break;
+                }
+
+            }
+
+            if (ReplaySessionState.AvatarTexture == null &&
+                !string.IsNullOrWhiteSpace(ReplaySessionState.AvatarUrl))
+            {
+                Texture2D downloadedAvatar = null;
+                string avatarError = null;
+
+                yield return _backendManager.FetchReplayAvatar(
+                    ReplaySessionState.AvatarUrl,
+                    texture => downloadedAvatar = texture,
+                    error => avatarError = error);
+
+                if (downloadedAvatar != null)
+                {
+                    Texture2D circularAvatar = ReplayController.CreateCircularAvatar(
+                        downloadedAvatar,
+                        ReplayController.AvatarTextureSize);
+
+                    Destroy(downloadedAvatar);
+                    ReplaySessionState.SetAvatarTexture(circularAvatar);
+                }
+                else
+                {
+                    HyperDebug.LogWarning(
+                        $"Unable to load replay avatar. Using fallback avatar. Error: {avatarError}");
+                }
+            }
+
+            _backendManager.RegisterSeed(GetRandomSeed());
+            _bootstrapProgress = _progressAfterBackend;
+            _loadingBarSlider.value = _bootstrapProgress;
+            onComplete?.Invoke(true);
+        }
+
+#if UNITY_EDITOR
+        private bool TryLoadEditorReplay(out string error)
+        {
+            error = null;
+            string path = ReplaySessionState.EditorReplayFilePath;
+            if (!File.Exists(path))
+            {
+                error = $"No Editor replay has been recorded at {path}.";
+                return false;
+            }
+
+            try
+            {
+                string ndjson = File.ReadAllText(path);
+                if (!BackendManager.TryParseReplayResponse(
+                        ndjson,
+                        out BackendManager.ReplayResponse replay,
+                        out error))
+                {
+                    return false;
+                }
+
+                ReplaySessionState.SetMetadata(replay.PlayerName, replay.AvatarUrl, replay.Seed);
+                ReplaySessionState.SetReplayData(replay.ActivityNdjson);
+                HyperDebug.Log($"Replay loaded from {path}");
+                return true;
+            }
+            catch (Exception exception)
+            {
+                error = $"Unable to load Editor replay: {exception.Message}";
+                return false;
+            }
+        }
+#endif
+
+        private void HandleReplayLoadingFailure(string error, Action<bool> onComplete)
+        {
+            HyperDebug.LogError(error);
+            onComplete?.Invoke(false);
+            _gameManager.ShowLoadingFailedModal(true);
+            _gameManager.LoadingFailedModalComponent?.AllAttemptsHaveFailed();
+        }
+
         private void InitializeNonBackendBattle()
         {
             _targetSceneName = _gameContentConfig.GameScene?.SceneName;
@@ -377,8 +518,21 @@ namespace Hyper.Internal
 
         private long GetRandomSeed()
         {
+            if (_gameManager.IsReplayMode)
+            {
+                if (ReplaySessionState.OriginalRandomSeed != 0)
+                {
+                    return ReplaySessionState.OriginalRandomSeed;
+                }
+
+                if (HyperRuntime.Settings != null && HyperRuntime.Settings._settings != null)
+                {
+                    return HyperRuntime.Settings._settings.RandomSeed;
+                }
+            }
+
 #if UNITY_EDITOR
-            // In editor, use the seed from editor simulation settings if available
+            // In editor, use the seed from editor simulation settings if available.
             if (HyperRuntime.Settings != null && HyperRuntime.Settings._settings != null)
             {
                 return HyperRuntime.Settings._settings.RandomSeed;
@@ -464,6 +618,30 @@ namespace Hyper.Internal
 
         #region UI Control
 
+        private void UpdateLoadingTextForMode()
+        {
+            if (_gameManager == null) return;
+
+            SetLoadingText(_gameManager.IsReplayMode ? "LOADING REPLAY" : "LAUNCHING GAME");
+        }
+
+        private void SetLoadingText(string text)
+        {
+            if (launchingGameAnimation == null) return;
+
+            LoadingTextAnimation animation =
+                launchingGameAnimation.GetComponentInChildren<LoadingTextAnimation>(true);
+            animation?.SetBaseText(text);
+        }
+
+        private void UpdateHintVisibilityForMode()
+        {
+            if (hintContainer != null && _gameManager != null && _gameManager.IsReplayMode)
+            {
+                hintContainer.SetActive(false);
+            }
+        }
+
         private void ShowLoadingScreenElements(bool show)
         {
             if (launchingGameAnimation != null)