app.hypergames.hypersdk 1.4.13 → 1.4.14

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [1.4.14](https://github.com/mvmhyper/hyper-sdk/compare/v1.4.13...v1.4.14) (2026-01-06)
+
+
+### Bug Fixes
+
+* migrate final submit to websockets; refresh CSRF on freeze-resume ([8b445e7](https://github.com/mvmhyper/hyper-sdk/commit/8b445e78d677507cc2ef7bce54d815df0ee0f58b))
+* Minor Bug fixes and improvements. ([a5004b5](https://github.com/mvmhyper/hyper-sdk/commit/a5004b5d054be4e5a432f30a6abcfad4287f70b7))
+
 ## [1.4.13](https://github.com/mvmhyper/hyper-sdk/compare/v1.4.12...v1.4.13) (2026-01-01)
 
 

package/Editor/Scripts/Setup/HyperSDKInstaller.cs

@@ -55,35 +55,58 @@ namespace Hyper.Editor
                 return;
             }
 
+            var currentVersion = packageInfo.version;
             var previousVersion = EditorPrefs.GetString(InstallerPrefsKey, string.Empty);
             var sceneExists = File.Exists(HyperLoaderSceneDestination);
             var templateExists = Directory.Exists(WebGLTemplateDestination);
             var configExists = File.Exists(HyperGameContentConfigDestination);
             var settingsExists = File.Exists(HyperSDKSettingsDestination);
 
-            // Only run if version changed or files are missing
-            if (previousVersion == packageInfo.version &&
-                sceneExists &&
-                templateExists &&
-                configExists &&
-                settingsExists)
-            {
-                return;
-            }
-
+            // Check what kind of version change we are dealing with
+            bool isMajorVersionChange = HasMajorVersionChanged(previousVersion, currentVersion);
+            bool isMajorOrMinorVersionChange = HasMajorOrMinorVersionChanged(previousVersion, currentVersion);
+            
             var packageRoot = packageInfo.resolvedPath;
             var hyperLoaderSource = Path.Combine(packageRoot, HyperLoaderSceneRelativePath);
             var templateSource = Path.Combine(packageRoot, WebGLTemplateRelativePath);
             var hyperGameContentConfigSource = Path.Combine(packageRoot, HyperGameContentConfigRelativePath);
             var hyperSDKSettingsSource = Path.Combine(packageRoot, HyperSDKSettingsRelativePath);
 
-            CopyFileWithoutMeta(hyperLoaderSource, HyperLoaderSceneDestination);
-            CopyTemplate(templateSource);
-            CopyFileWithoutMeta(hyperGameContentConfigSource, HyperGameContentConfigDestination);
-            CopyFileWithoutMeta(hyperSDKSettingsSource, HyperSDKSettingsDestination);
+            bool anyFileCopied = false;
+
+            if (!sceneExists || isMajorVersionChange)
+            {
+                CopyFileWithoutMeta(hyperLoaderSource, HyperLoaderSceneDestination);
+                anyFileCopied = true;
+            }
+
+            if (!templateExists || isMajorOrMinorVersionChange)
+            {
+                CopyTemplate(templateSource);
+                anyFileCopied = true;
+            }
+
+            if (!configExists || isMajorOrMinorVersionChange)
+            {
+                CopyFileWithoutMeta(hyperGameContentConfigSource, HyperGameContentConfigDestination);
+                anyFileCopied = true;
+            }
 
-            EditorPrefs.SetString(InstallerPrefsKey, packageInfo.version);
-            AssetDatabase.Refresh();
+            if (!settingsExists || isMajorOrMinorVersionChange)
+            {
+                CopyFileWithoutMeta(hyperSDKSettingsSource, HyperSDKSettingsDestination);
+                anyFileCopied = true;
+            }
+
+            // Always update the stored version, even if no files were copied
+            if (previousVersion != currentVersion)
+            {
+                EditorPrefs.SetString(InstallerPrefsKey, currentVersion);
+                if (anyFileCopied)
+                {
+                    AssetDatabase.Refresh();
+                }
+            }
         }
 
         private static void CopyFileWithoutMeta(string sourcePath, string destinationPath)
@@ -143,6 +166,82 @@ namespace Hyper.Editor
                 FileUtil.DeleteFileOrDirectory(meta);
             }
         }
+
+        /// <summary>
+        /// Parses a semantic version string (e.g., "1.4.5") and returns major, minor, patch components.
+        /// Returns (0, 0, 0) if version string is invalid or empty.
+        /// </summary>
+        private static (int major, int minor, int patch) ParseVersion(string version)
+        {
+            if (string.IsNullOrEmpty(version))
+            {
+                return (0, 0, 0);
+            }
+
+            // Remove any pre-release or build metadata (e.g., "1.4.5-preview.1" -> "1.4.5")
+            var cleanVersion = version.Split('-')[0].Split('+')[0];
+
+            var parts = cleanVersion.Split('.');
+            if (parts.Length < 2)
+            {
+                return (0, 0, 0);
+            }
+
+            int major = int.TryParse(parts[0], out int m) ? m : 0;
+            int minor = int.TryParse(parts[1], out int mi) ? mi : 0;
+            int patch = parts.Length > 2 && int.TryParse(parts[2], out int p) ? p : 0;
+
+            return (major, minor, patch);
+        }
+
+        /// <summary>
+        /// Returns true if the version change represents a major or minor version change (not just patch).
+        /// Examples:
+        /// - 1.4.5 -> 1.4.6: false (patch change)
+        /// - 1.4.5 -> 1.5.0: true (minor change)
+        /// - 1.4.5 -> 2.0.0: true (major change)
+        /// - Empty -> 1.0.0: true (first install)
+        /// </summary>
+        private static bool HasMajorOrMinorVersionChanged(string previousVersion, string currentVersion)
+        {
+            // First install or version is empty
+            if (string.IsNullOrEmpty(previousVersion))
+            {
+                return true;
+            }
+
+            var (prevMajor, prevMinor, _) = ParseVersion(previousVersion);
+            var (currMajor, currMinor, _) = ParseVersion(currentVersion);
+
+            // Major version changed
+            if (currMajor != prevMajor)
+            {
+                return true;
+            }
+
+            // Minor version changed
+            if (currMinor != prevMinor)
+            {
+                return true;
+            }
+
+            // Only patch version changed (or no change)
+            return false;
+        }
+
+        private static bool HasMajorVersionChanged(string previousVersion, string currentVersion)
+        {
+            if(string.IsNullOrEmpty(previousVersion))
+            {
+                return true;
+            }
+
+            var (prevMajor, _, _) = ParseVersion(previousVersion);
+            var (currMajor, _, _) = ParseVersion(currentVersion);
+
+            // Only major version
+            return currMajor != prevMajor;
+        }
     }
 }
 

package/Editor/Scripts/Tools/HyperBuildAssistant.cs

@@ -563,7 +563,7 @@ namespace Hyper.Editor
                 isOptimal = status.hyperLoaderAtIndex0,
                 current = $"• Current: {(status.hyperLoaderAtIndex0 ? "HyperLoader at index 0" : "HyperLoader not at index 0")}",
                 recommended = "• Recommended: HyperLoader at build index 0",
-                description = "HyperLoader scene must be at build index 0 in Build Settings. This ensures proper SDK initialization before your game starts.",
+                description = "HyperLoader scene must be at build index 0 in Build Settings (from Assets/HyperSDK/HyperLoader.unity). This ensures proper SDK initialization before your game starts.",
                 priority = SettingPriority.Critical,
                 type = SettingType.HyperLoaderSceneIndex
             };
@@ -2743,7 +2743,7 @@ namespace Hyper.Editor
                 // Property may not exist in this Unity version
             }
 
-            // Check if HyperLoader is at build index 0
+            // Check if HyperLoader is at build index 0 (must be from Assets/HyperSDK/, not Packages/)
             bool hyperLoaderAt0 = false;
             try
             {
@@ -2751,8 +2751,8 @@ namespace Hyper.Editor
                 if (scenes != null && scenes.Length > 0 && scenes[0].enabled)
                 {
                     string firstScenePath = scenes[0].path;
-                    hyperLoaderAt0 = firstScenePath.Contains("HyperLoader") ||
-                                     firstScenePath.EndsWith("HyperLoader.unity", System.StringComparison.OrdinalIgnoreCase);
+                    // Only accept the HyperLoader scene from Assets/HyperSDK/, not from Packages/
+                    hyperLoaderAt0 = string.Equals(firstScenePath, HyperConstants.HYPER_LOADER_SCENE_PATH, StringComparison.OrdinalIgnoreCase);
                 }
             }
             catch (System.Exception)

package/HyperLoader.unity

@@ -304,7 +304,7 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 489.1766, y: -280.1698}
+  m_AnchoredPosition: {x: 489.20746, y: -280.1698}
   m_SizeDelta: {x: 1044.9, y: 239.347}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &751153944
@@ -840,7 +840,7 @@ GameObject:
   m_Component:
   - component: {fileID: 1064166296}
   m_Layer: 0
-  m_Name: __HyperSDK_BuildMarker_639020542296075009
+  m_Name: __HyperSDK_BuildMarker_639030030877789930
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
@@ -1092,7 +1092,7 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 489.1766, y: -133.2274}
+  m_AnchoredPosition: {x: 489.20746, y: -133.2274}
   m_SizeDelta: {x: 875, y: 54.5378}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!1 &2874543288936963705

package/Runtime/Internal/Managers/BackendManager.cs

@@ -42,7 +42,7 @@ namespace Hyper.Internal.Managers
 
         #region Public Properties (Internal API)
 
-        public int scoreSubmissionTimeout { get; private set; } = 3;
+        public int scoreSubmissionTimeout { get; private set; } = 4;
         public int CurrentRetryCount => _currentRetryCount;
         public bool isSocketConnected { get; private set; }
         public bool tutorialFetchSuccess { get; private set; }
@@ -373,6 +373,7 @@ namespace Hyper.Internal.Managers
                     };
 
                     string json = JsonConvert.SerializeObject(message);
+                    HyperDebug.Log($"Sending game resumed message: {json}");
                     SendWebSocketMessage(json);
                 }
                 catch (Exception ex)
@@ -381,7 +382,7 @@ namespace Hyper.Internal.Managers
                 }
 
                 float elapsed = 0f;
-                const float timeout = 2f;
+                const float timeout = 1f;
 
                 while (!_gameResumed && elapsed < timeout)
                 {
@@ -390,7 +391,7 @@ namespace Hyper.Internal.Managers
                 }
             }
 
-            yield return new WaitForSecondsRealtime(2f);
+            yield return new WaitForSecondsRealtime(1.5f);
 
             _sendGameResumedCoroutine = null;
         }
@@ -529,6 +530,12 @@ namespace Hyper.Internal.Managers
                 _eventManager?.InvokeWebSocketScoreSubmitted(_lastScoreData);
             }
 
+            if (_isFinalScoreSubmission)
+            {
+                _finalScoreSubmitted = true;
+                _isFinalScoreSubmission = false;
+            }
+
             TryUpdateCSRFToken(message);
         }
 
@@ -621,22 +628,22 @@ namespace Hyper.Internal.Managers
 
         #endregion
 
-        #region Score Submission (HTTPS)
+        #region Final Score Submission
 
-        private Coroutine _endGameCoroutine;
+        private Coroutine _finalScoreSubmissionCoroutine;
 
         public void SubmitScore()
         {
-            if (_endGameCoroutine != null)
+            if (_finalScoreSubmissionCoroutine != null)
             {
                 HyperDebug.LogError("Score submission already in progress");
                 return;
             }
 
 #if UNITY_WEBGL && !UNITY_EDITOR
-            _endGameCoroutine = StartCoroutine(SubmitScoreCoroutine());
+            _finalScoreSubmissionCoroutine = StartCoroutine(FinalScoreSubmissionCoroutine());
 #else
-            _endGameCoroutine = StartCoroutine(SubmitScoreCoroutineDemo());
+            _finalScoreSubmissionCoroutine = StartCoroutine(FinalScoreSubmissionCoroutineDemo());
 #endif
         }
 
@@ -649,27 +656,34 @@ namespace Hyper.Internal.Managers
                 return;
             }
 
-            if (_endGameCoroutine != null)
+            if (_finalScoreSubmissionCoroutine != null)
             {
-                StopCoroutine(_endGameCoroutine);
+                StopCoroutine(_finalScoreSubmissionCoroutine);
             }
 
-            _endGameCoroutine = null;
+            _finalScoreSubmissionCoroutine = null;
 
 #if UNITY_WEBGL && !UNITY_EDITOR
-            _endGameCoroutine = StartCoroutine(SubmitScoreCoroutine());
+            _finalScoreSubmissionCoroutine = StartCoroutine(FinalScoreSubmissionCoroutine());
 #else
-            _endGameCoroutine = StartCoroutine(SubmitScoreCoroutineDemo());
+            _finalScoreSubmissionCoroutine = StartCoroutine(FinalScoreSubmissionCoroutineDemo());
 #endif
         }
 
-        private IEnumerator SubmitScoreCoroutine()
+        private IEnumerator FinalScoreSubmissionCoroutine()
         {
             _gameManager?.GameOverModalComponent?.Init();
             _currentRetryCount = 0;
 
             while (_currentRetryCount < MAX_RETRY_COUNT)
             {
+                if (_hasSessionEnded)
+                {
+                    _gameManager?.ShowRetryTimeExpiredModal();
+                    _finalScoreSubmissionCoroutine = null;
+                    yield break;
+                }
+
                 var finalScoreData = _dataManager?.CurrentScoreData;
                 finalScoreData.isFinal = true;
 
@@ -698,55 +712,100 @@ namespace Hyper.Internal.Managers
                     yield return _sendGameResumedCoroutine;
                 }
 
-                object encryptedObject = JsonConvert.DeserializeObject(encryptedScoreData);
-                var payload = new { encryptedData = encryptedObject };
-                string jsonData = JsonConvert.SerializeObject(payload);
+                if (!isSocketConnected)
+                {
+                    HyperDebug.LogError("WebSocket not connected - cannot submit final score");
+                    _currentRetryCount++;
+                    _gameManager?.GameOverModalComponent?.UpdateAttemptCount(_currentRetryCount, MAX_RETRY_COUNT);
 
-                string url = GetServerURL($"sessions/{_cachedSessionId}/scores");
+                    if (_currentRetryCount < MAX_RETRY_COUNT)
+                    {
+                        yield return new WaitForSecondsRealtime(1f);
+                    }
+                    continue;
+                }
 
-                using (UnityWebRequest request = new UnityWebRequest(url, "POST"))
+                // Sending final score via WebSocket
+                _finalScoreSubmitted = false;
+                _isFinalScoreSubmission = true;
+                _lastSentBatch = new List<ScoreData> { finalScoreData };
+
+                bool sendFailed = false;
+                try
                 {
-                    byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonData);
-                    request.uploadHandler = new UploadHandlerRaw(bodyRaw);
-                    request.downloadHandler = new DownloadHandlerBuffer();
-                    request.SetRequestHeader("Content-Type", "application/json");
-                    request.SetRequestHeader("x-csrf-token", _csrfToken);
-                    request.timeout = scoreSubmissionTimeout;
+                    var message = new WebSocketScoreMessage(_cachedSessionId, _csrfToken, encryptedScoreData);
+                    string json = JsonConvert.SerializeObject(message);
+                    SendWebSocketMessage(json);
+                }
+                catch (Exception ex)
+                {
+                    HyperDebug.LogError($"Failed to send final score via WebSocket: {ex.Message}");
+                    _isFinalScoreSubmission = false;
+                    sendFailed = true;
+                }
 
-                    yield return request.SendWebRequest();
+                if (sendFailed)
+                {
+                    _currentRetryCount++;
+                    _gameManager?.GameOverModalComponent?.UpdateAttemptCount(_currentRetryCount, MAX_RETRY_COUNT);
 
-                    if (request.result == UnityWebRequest.Result.Success)
+                    if (_currentRetryCount < MAX_RETRY_COUNT)
                     {
-                        _gameManager?.GameOverModalComponent?.ScoreHasBeenSubmitted();
-                        // TryUpdateCSRFToken(request.downloadHandler.text);
-                        StopWebSocket();
-                        _endGameCoroutine = null;
-                        yield break;
+                        yield return new WaitForSecondsRealtime(1f);
                     }
-                    else if (_hasSessionEnded)
+                    continue;
+                }
+
+                // Waiting for WebSocket response
+                float elapsed = 0f;
+                float timeout = scoreSubmissionTimeout;
+
+                while (!_finalScoreSubmitted && elapsed < timeout)
+                {
+                    if (_hasSessionEnded)
                     {
                         _gameManager?.ShowRetryTimeExpiredModal();
-                        _endGameCoroutine = null;
+                        _isFinalScoreSubmission = false;
+                        _finalScoreSubmissionCoroutine = null;
                         yield break;
                     }
-                    else
-                    {
-                        _currentRetryCount++;
-                        _gameManager?.GameOverModalComponent?.UpdateAttemptCount(_currentRetryCount, MAX_RETRY_COUNT);
+                    yield return null;
+                    elapsed += Time.unscaledDeltaTime;
+                }
 
-                        if (_currentRetryCount < MAX_RETRY_COUNT)
-                        {
-                            yield return new WaitForSecondsRealtime(1f);
-                        }
+                if (_finalScoreSubmitted)
+                {
+                    _gameManager?.GameOverModalComponent?.ScoreHasBeenSubmitted();
+                    StopWebSocket();
+                    _finalScoreSubmissionCoroutine = null;
+                    yield break;
+                }
+                else if (_hasSessionEnded)
+                {
+                    _gameManager?.ShowRetryTimeExpiredModal();
+                    _isFinalScoreSubmission = false;
+                    _finalScoreSubmissionCoroutine = null;
+                    yield break;
+                }
+                else
+                {
+                    _isFinalScoreSubmission = false;
+                    _currentRetryCount++;
+                    _gameManager?.GameOverModalComponent?.UpdateAttemptCount(_currentRetryCount, MAX_RETRY_COUNT);
+
+                    if (_currentRetryCount < MAX_RETRY_COUNT)
+                    {
+                        yield return new WaitForSecondsRealtime(1f);
                     }
                 }
             }
 
+            _isFinalScoreSubmission = false;
             _gameManager?.GameOverModalComponent?.AllAttemptsHaveFailed();
-            _endGameCoroutine = null;
+            _finalScoreSubmissionCoroutine = null;
         }
 
-        private IEnumerator SubmitScoreCoroutineDemo()
+        private IEnumerator FinalScoreSubmissionCoroutineDemo()
         {
             if (_dataManager == null) _dataManager = HyperRuntime.DataManager;
             if (_eventManager == null) _eventManager = HyperRuntime.EventManager;
@@ -761,7 +820,7 @@ namespace Hyper.Internal.Managers
 
             _gameManager.GameOverModalComponent.ScoreHasBeenSubmitted();
             StopWebSocket();
-            _endGameCoroutine = null;
+            _finalScoreSubmissionCoroutine = null;
         }
 
         #endregion
@@ -772,6 +831,8 @@ namespace Hyper.Internal.Managers
         private List<ScoreData> _lastSentBatch = new List<ScoreData>();
         private ScoreData _lastScoreData;
         private readonly WaitForSeconds _scoreSendInterval = new WaitForSeconds(1f);
+        private bool _isFinalScoreSubmission;
+        private bool _finalScoreSubmitted;
 
         public void StartSendingScores()
         {

package/Runtime/Internal/Managers/EventManager.cs

@@ -45,6 +45,8 @@ namespace Hyper.Internal.Managers
         internal event Action OnTutorialFetchFailed;
         internal event Action OnTutorialDoesNotExist;
         internal event Action<ScoreData> OnLastSubmittedScoreReceived;
+        internal event Action OnTimeScaleFrozen; // Fired when Time.timeScale becomes 0
+        internal event Action OnTimeScaleResumed; // Fired when Time.timeScale becomes 1 (from any value)
 
         #endregion
 
@@ -68,6 +70,8 @@ namespace Hyper.Internal.Managers
         internal void InvokeTutorialFetchFailedEvent() => OnTutorialFetchFailed?.Invoke();
         internal void InvokeTutorialNotExistsEvent() => OnTutorialDoesNotExist?.Invoke();
         internal void InvokeWebSocketScoreSubmitted(ScoreData scoreData) => OnLastSubmittedScoreReceived?.Invoke(scoreData);
+        internal void InvokeTimeScaleFrozenEvent() => OnTimeScaleFrozen?.Invoke();
+        internal void InvokeTimeScaleResumedEvent() => OnTimeScaleResumed?.Invoke();
 
         #endregion
     }

package/Runtime/Internal/Managers/GameManager.cs

@@ -158,12 +158,6 @@ namespace Hyper.Internal.Managers
         {
             if (!_hasGameStarted || _isPaused || _hasGameEnded) return;
 
-            if (_backendManager.isSocketConnected)
-            {
-                _dataManager.StopCapturingScores();
-                _backendManager.StopSendingScores();
-            }
-
             _isPaused = true;
             _isFrozenBeforePause = Time.timeScale == 0;
             Time.timeScale = 0;
@@ -177,11 +171,6 @@ namespace Hyper.Internal.Managers
 
         internal void ResumeGame()
         {
-            if (_backendManager.isSocketConnected)
-            {
-                _backendManager.SendGameResumed();
-            }
-
             _isPaused = false;
 
             if (!_isFrozenBeforePause)
@@ -212,9 +201,37 @@ namespace Hyper.Internal.Managers
             {
                 PauseGame();
             }
-            else if (!shouldPause && _isPaused)
+        }
+
+        void Update()
+        {
+            float currentTimeScale = Time.timeScale;
+            if (currentTimeScale != _previousTimeScale)
             {
-                // ResumeGame();
+                // detect intentional game-freeze states
+                if (currentTimeScale == 0f && _previousTimeScale != 0f)
+                {
+                    _eventManager.InvokeTimeScaleFrozenEvent();
+                    HyperDebug.Log("Time scale frozen event invoked");
+
+                    if (_backendManager.isSocketConnected)
+                    {
+                        _dataManager.StopCapturingScores();
+                        _backendManager.StopSendingScores();
+                    }
+                }
+                else if (currentTimeScale == 1f && _previousTimeScale != 1f)
+                {
+                    _eventManager.InvokeTimeScaleResumedEvent();
+                    HyperDebug.Log("Time scale resumed event invoked");
+
+                    if (_backendManager.isSocketConnected && !_hasGameEnded && _hasGameStarted)
+                    {
+                        _backendManager.SendGameResumed();
+                    }
+                }
+
+                _previousTimeScale = currentTimeScale;
             }
         }
 
@@ -459,6 +476,8 @@ namespace Hyper.Internal.Managers
 
         internal void ShowGameOverModal()
         {
+            HidePauseModals();
+
             if (IsBattleMode)
             {
                 EnsureBattleGameOverModal();
@@ -469,7 +488,7 @@ namespace Hyper.Internal.Managers
                 EnsurePracticeGameOverModal();
                 _practiceGameOverModal.SetActive(true);
             }
-
+            
             SetBlockerActive(true);
         }
 
@@ -558,6 +577,7 @@ namespace Hyper.Internal.Managers
         private bool _hasGameEnded;
         private bool _isFrozenBeforePause;
         private bool _isPortrait;
+        private float _previousTimeScale = 1f;
 
         #endregion
 
@@ -769,6 +789,7 @@ namespace Hyper.Internal.Managers
         private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
         {
             Time.timeScale = 1;
+            _previousTimeScale = 1f; // Sync tracking on scene load
             _dataManager.ConfigurePlayerSoundSetting();
 
             string menuSceneName = HyperRuntime.GameContent.IsPracticeMenu ?
@@ -808,6 +829,7 @@ namespace Hyper.Internal.Managers
             _hasGameEnded = false;
             _isPaused = false;
             _isFrozenBeforePause = false;
+            _previousTimeScale = Time.timeScale; // Sync with actual time scale on scene load
         }
 
         private void InitializeSceneUI()

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

@@ -83,7 +83,7 @@ namespace Hyper.Internal
 
             // Animate to original position
             rectTransform.DOAnchorPosY(originalAnchoredPosition.y, 0.5f)
-                .SetEase(Animation.HyperTween.Ease.OutQuad)
+                .SetEase(HyperTween.Ease.OutQuad)
                 .SetUpdate(true);
         }
 
@@ -103,7 +103,7 @@ namespace Hyper.Internal
 
             // Animate to off-screen position
             rectTransform.DOAnchorPosY(offScreenY, 0.5f)
-                .SetEase(Animation.HyperTween.Ease.InQuad)
+                .SetEase(HyperTween.Ease.InQuad)
                 .SetUpdate(true)
                 .OnComplete(() =>
                 {