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

package/CHANGELOG.md

@@ -1,3 +1,37 @@
+# [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)

package/Runtime/Internal/Core/HyperRuntime.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 using Hyper.Internal.Managers;
+using Hyper.Shared;
 
 namespace Hyper.Internal
 {
@@ -30,6 +31,7 @@ namespace Hyper.Internal
         private static DataManager _dataManager;
         private static EventManager _eventManager;
         private static TimerManager _timerManager;
+        private static ReplayManager _replayManager;
 
         internal static bool IsInitialized => _isInitialized;
         internal static bool IsSoftRestarting
@@ -55,6 +57,7 @@ namespace Hyper.Internal
         internal static DataManager DataManager => _dataManager;
         internal static EventManager EventManager => _eventManager;
         internal static TimerManager Timer => _timerManager;
+        internal static ReplayManager ReplayManager => _replayManager;
 
         internal static event Action CustomLoadingStarted
         {
@@ -114,6 +117,65 @@ namespace Hyper.Internal
             }
         }
 
+        /// <summary>
+        /// Restarts replay playback while preserving its downloaded data and original seed.
+        /// Uses the configured custom restart flow when available, otherwise reloads HyperLoader.
+        /// </summary>
+        internal static void RestartReplaySession()
+        {
+            ReplaySessionState.ResetForWatchAgain();
+            RestartReplay();
+        }
+
+        internal static void SeekReplaySession(float targetProgress, float resumeSpeed, float seekSpeed)
+        {
+            if (!ReplaySessionState.IsActive || ReplaySessionState.HasEnded) return;
+
+            ReplaySessionState.RequestSeek(targetProgress, resumeSpeed, seekSpeed);
+            ReplaySessionState.ResetForSeekRestart();
+            RestartReplay();
+        }
+
+        private static void RestartReplay()
+        {
+            _isSoftRestarting = true;
+            Time.timeScale = 1f;
+
+            if (_settings != null && _settings.useCustomRestartFlow &&
+                _gameManager != null && _eventManager != null)
+            {
+                _replayManager?.PrepareForRestart();
+                ResetReplayRandomState();
+                _gameManager.ResetUIStateForCustomRestart();
+                _eventManager.InvokeCustomRestartEvent();
+                _isSoftRestarting = false;
+                return;
+            }
+
+            if (_host != null)
+            {
+                _host.StartCoroutine(RestartSessionCoroutine());
+            }
+            else
+            {
+                ClearAllDontDestroyOnLoadObjects();
+                SceneManager.LoadScene("HyperLoader");
+            }
+        }
+
+        internal static void ResetReplayRandomState()
+        {
+            int originalSeed = unchecked((int)ReplaySessionState.OriginalRandomSeed);
+            if (HyperRandom.CurrentSeed == originalSeed)
+            {
+                // Preserve references held by game code while rewinding every stream.
+                HyperRandom.ResetAll();
+                return;
+            }
+
+            HyperRandom.Init(ReplaySessionState.OriginalRandomSeed);
+        }
+
         /// <summary>
         /// Coroutine-based restart that properly unloads all scenes before reloading.
         /// Handles async scene operations and ensures clean state before restart.
@@ -302,6 +364,9 @@ namespace Hyper.Internal
             _gameManager = _singletonObject.AddComponent<GameManager>();
             _gameManager.Initialize();
 
+            _replayManager = new ReplayManager();
+            _replayManager.Initialize(_eventManager);
+
             _timerManager = new TimerManager();
             _timerManager.Initialize();
             _timerManager.InjectEventHooks();
@@ -313,6 +378,13 @@ namespace Hyper.Internal
             _timerManager?.Update();
         }
 
+        internal static void FixedTick()
+        {
+            if (!_isInitialized) return;
+            _replayManager?.FixedTick();
+            _timerManager?.FixedTick();
+        }
+
         internal static void Clear()
         {
             if (_host == null)
@@ -323,6 +395,9 @@ namespace Hyper.Internal
 
             _timerManager = null;
 
+            _replayManager?.Cleanup();
+            _replayManager = null;
+
             _dataManager?.Cleanup();
             _dataManager = null;
 
@@ -364,6 +439,11 @@ namespace Hyper.Internal
             {
                 if (obj.scene.name == "DontDestroyOnLoad" && obj.transform.parent == null)
                 {
+                    if (ReplaySessionState.IsSeeking && ReplayPresentationCanvas.IsPresentationRoot(obj))
+                    {
+                        continue;
+                    }
+
                     UnityEngine.Object.Destroy(obj);
                 }
             }
@@ -372,6 +452,7 @@ namespace Hyper.Internal
         internal static void OnHostDestroyed(HyperRuntimeHost host)
         {
             if (_host != host) return;
+            _replayManager?.Cleanup();
             ResetStaticState();
         }
 
@@ -385,6 +466,7 @@ namespace Hyper.Internal
             _gameManager = null;
             _backendManager = null;
             _dataManager = null;
+            _replayManager = null;
             _gameContent = null;
             _isInitialized = false;
             _customLoadingComplete = false;

package/Runtime/Internal/Core/HyperRuntimeHost.cs

@@ -6,6 +6,7 @@ namespace Hyper.Internal
     /// Lightweight MonoBehaviour that allows the internal runtime to participate in
     /// Unity's update loop without exposing managed objects to public assemblies.
     /// </summary>
+    [DefaultExecutionOrder(-10000)]
     internal sealed class HyperRuntimeHost : MonoBehaviour
     {
         private void Awake()
@@ -18,6 +19,11 @@ namespace Hyper.Internal
             HyperRuntime.Tick();
         }
 
+        private void FixedUpdate()
+        {
+            HyperRuntime.FixedTick();
+        }
+
         private void OnDestroy()
         {
             HyperRuntime.OnHostDestroyed(this);

package/Runtime/Internal/Data/URLData.cs

@@ -27,6 +27,11 @@ namespace Hyper.Internal
         /// </summary>
         public bool isPVP => GameMode == GameMode.Battle;
 
+        /// <summary>
+        /// Returns true for modes that use battle gameplay, scenes, and timers.
+        /// </summary>
+        public bool IsBattleGameplay => GameMode == GameMode.Battle || GameMode == GameMode.Replay;
+
         #endregion
 
         #region Internal Fields
@@ -114,5 +119,17 @@ namespace Hyper.Internal
         {
             GameMode = GameMode.Practice;
         }
+
+        public void SetModeAsReplay()
+        {
+            GameMode = GameMode.Replay;
+        }
+
+        internal void SetModeFromLaunchFlags(bool isPVP, bool isReplay)
+        {
+            GameMode = isReplay
+                ? GameMode.Replay
+                : isPVP ? GameMode.Battle : GameMode.Practice;
+        }
     }
-}
+}