app.hypergames.hypersdk 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.2.2](https://github.com/mvmhyper/hyper-sdk/compare/v1.2.1...v1.2.2) (2025-11-26)
+
+
+### Bug Fixes
+
+* auto-manage HyperLoader scene and constants ([050567a](https://github.com/mvmhyper/hyper-sdk/commit/050567a44c0d78b4eed9ae31b19ba1fcbd8a986f))
+
+## [1.2.1](https://github.com/mvmhyper/hyper-sdk/compare/v1.2.0...v1.2.1) (2025-11-26)
+
+
+### Bug Fixes
+
+* stabilize scene references, installer overwrite, and resources path helper ([c27499e](https://github.com/mvmhyper/hyper-sdk/commit/c27499e525712d1fcf2f42e30813013e9610e254))
+
 # [1.2.0](https://github.com/mvmhyper/hyper-sdk/compare/v1.1.11...v1.2.0) (2025-11-26)
 
 

package/Editor/Scripts/Tools/HyperBuildAssistant.cs

@@ -4,6 +4,7 @@ using UnityEditor;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using UnityEditor.Build;
 using UnityEditor.Build.Reporting;
@@ -1010,61 +1011,25 @@ namespace Hyper.Editor
                     break;
 
                 case SettingType.HyperLoaderSceneIndex:
-                    try
                     {
-                        var scenes = new List<EditorBuildSettingsScene>(EditorBuildSettings.scenes);
-                        int hyperLoaderIndex = -1;
-
-                        for (int i = 0; i < scenes.Count; i++)
+                        if (TryEnsureSceneAtIndex(HyperConstants.HYPER_LOADER_SCENE_PATH, 0, out var sceneError))
                         {
-                            if (scenes[i].path.Contains("HyperLoader") ||
-                                scenes[i].path.EndsWith("HyperLoader.unity", System.StringComparison.OrdinalIgnoreCase))
-                            {
-                                hyperLoaderIndex = i;
-                                break;
-                            }
+                            if (IsSDKDeveloper()) HyperDebug.LogSuccess("Applied: HyperLoader scene moved to build index 0");
                         }
-
-                        if (hyperLoaderIndex == -1)
+                        else
                         {
                             EditorUtility.DisplayDialog(
                                 "HyperLoader Scene Not Found",
-                                "HyperLoader scene not found in Build Settings.\n\n" +
-                                "Please add it manually:\n" +
-                                "1. File > Build Settings\n" +
-                                "2. Add Open Scenes or drag HyperLoader.unity\n" +
-                                "3. Move it to index 0",
+                                $"Could not locate the HyperLoader scene at:\n{HyperConstants.HYPER_LOADER_SCENE_PATH}\n\n" +
+                                "Please ensure the SDK is installed and the scene exists, then run this fix again.",
                                 "OK"
                             );
-                            HyperDebug.LogWarning("HyperLoader scene not found in Build Settings");
-                        }
-                        else if (hyperLoaderIndex == 0)
-                        {
-                            if (IsSDKDeveloper()) HyperDebug.Log("HyperLoader is already at index 0");
-                        }
-                        else
-                        {
-                            var hyperLoaderScene = scenes[hyperLoaderIndex];
-                            scenes.RemoveAt(hyperLoaderIndex);
-                            scenes.Insert(0, hyperLoaderScene);
-                            hyperLoaderScene.enabled = true;
-
-                            EditorBuildSettings.scenes = scenes.ToArray();
-                            if (IsSDKDeveloper()) HyperDebug.LogSuccess($"Applied: Moved HyperLoader scene to build index 0 (was at index {hyperLoaderIndex})");
+                            if (!string.IsNullOrEmpty(sceneError))
+                            {
+                                HyperDebug.LogWarning(sceneError);
+                            }
                         }
                     }
-                    catch (System.Exception e)
-                    {
-                        EditorUtility.DisplayDialog(
-                            "Build Settings Error",
-                            "Could not automatically move HyperLoader to index 0.\n\n" +
-                            "Please manually set it in:\n" +
-                            "File > Build Settings\n\n" +
-                            "Move HyperLoader scene to index 0",
-                            "OK"
-                        );
-                        HyperDebug.LogWarning($"Could not move HyperLoader scene: {e.Message}");
-                    }
                     break;
 
                 case SettingType.ColorSpace:
@@ -1466,6 +1431,39 @@ namespace Hyper.Editor
             return $"{len:0.##} {sizes[order]}";
         }
 
+        #endregion
+
+        #region Build Settings Helpers
+
+        private static bool TryEnsureSceneAtIndex(string scenePath, int targetIndex, out string errorMessage)
+        {
+            errorMessage = null;
+
+            if (string.IsNullOrEmpty(scenePath))
+            {
+                errorMessage = "Scene path is null or empty.";
+                return false;
+            }
+
+            if (!File.Exists(scenePath))
+            {
+                errorMessage = $"Scene not found at path: {scenePath}";
+                return false;
+            }
+
+            var scenes = new List<EditorBuildSettingsScene>(EditorBuildSettings.scenes);
+            scenes.RemoveAll(s => string.Equals(s.path, scenePath, StringComparison.OrdinalIgnoreCase));
+
+            targetIndex = Mathf.Clamp(targetIndex, 0, scenes.Count);
+
+            var newScene = new EditorBuildSettingsScene(scenePath, true);
+            scenes.Insert(targetIndex, newScene);
+
+            EditorBuildSettings.scenes = scenes.ToArray();
+            return true;
+        }
+
+
         private static string FormatBuildTime(System.DateTime buildTime)
         {
             System.TimeSpan timeSince = System.DateTime.Now - buildTime;
@@ -2168,7 +2166,7 @@ namespace Hyper.Editor
         /// </summary>
         private static void ForceAssetRepack()
         {
-            const string hyperLoaderScenePath = "Assets/HyperSDK/HyperLoader.unity";
+                const string hyperLoaderScenePath = HyperConstants.HYPER_LOADER_SCENE_PATH;
             const string markerPrefix = "__HyperSDK_BuildMarker";
             if (IsSDKDeveloper()) HyperDebug.Log("ForceAssetRepack() called");
 

package/Editor/Scripts/Utils/HyperSceneReferenceDrawer.cs

@@ -16,7 +16,10 @@ namespace Hyper.Editor
             EditorGUI.BeginProperty(position, label, property);
 
             SerializedProperty guidProperty = property.FindPropertyRelative("sceneGUID");
-            if (guidProperty == null)
+            SerializedProperty pathProperty = property.FindPropertyRelative("scenePath");
+            SerializedProperty nameProperty = property.FindPropertyRelative("sceneName");
+
+            if (guidProperty == null || pathProperty == null || nameProperty == null)
             {
                 EditorGUI.LabelField(position, label.text, "HyperSceneReference: Invalid property structure");
                 EditorGUI.EndProperty();
@@ -44,18 +47,23 @@ namespace Hyper.Editor
                 false
             ) as SceneAsset;
 
-            // Update GUID if scene changed
+            // Update serialized values if scene changed
             if (newScene != currentScene)
             {
                 if (newScene != null)
                 {
                     string newPath = AssetDatabase.GetAssetPath(newScene);
                     string newGUID = AssetDatabase.AssetPathToGUID(newPath);
+                    string newName = System.IO.Path.GetFileNameWithoutExtension(newPath);
                     guidProperty.stringValue = newGUID;
+                    pathProperty.stringValue = newPath;
+                    nameProperty.stringValue = newName;
                 }
                 else
                 {
                     guidProperty.stringValue = string.Empty;
+                    pathProperty.stringValue = string.Empty;
+                    nameProperty.stringValue = string.Empty;
                 }
             }
 

package/Editor/Scripts/Windows/HyperCoreSettingsWindow.cs

@@ -78,14 +78,11 @@ namespace Hyper.Editor
         private void CreateSettingsAsset()
         {
             // Ensure Resources folder exists
-            if (!AssetDatabase.IsValidFolder(HyperConstants.RESOURCES_FOLDER_PATH))
-            {
-                AssetDatabase.CreateFolder("Assets", "Resources");
-            }
+            HyperSettingsWindow.EnsureResourcesFolderExists();
 
             // Create settings asset
             var newSettings = CreateInstance<HyperSDKSettings>();
-            string assetPath = $"{HyperConstants.RESOURCES_FOLDER_PATH}/HyperSDKSettings.asset";
+            string assetPath = $"{HyperConstants.SETTINGS_ASSET_PATH}";
 
             AssetDatabase.CreateAsset(newSettings, assetPath);
             AssetDatabase.SaveAssets();

package/Editor/Scripts/Windows/HyperGameContentWindow.cs

@@ -76,10 +76,7 @@ namespace Hyper.Editor
         private void CreateConfigAsset()
         {
             // Ensure Resources folder exists
-            if (!AssetDatabase.IsValidFolder(HyperConstants.RESOURCES_FOLDER_PATH))
-            {
-                AssetDatabase.CreateFolder("Assets", "Resources");
-            }
+            HyperSettingsWindow.EnsureResourcesFolderExists();
 
             // Create config asset
             var newConfig = CreateInstance<HyperGameContentConfig>();

package/Editor/Scripts/Windows/HyperSettingsWindow.cs

@@ -109,13 +109,10 @@ namespace Hyper.Editor
 
         private void CreateSettingsAsset()
         {
-            if (!AssetDatabase.IsValidFolder(HyperConstants.RESOURCES_FOLDER_PATH))
-            {
-                AssetDatabase.CreateFolder("Assets", "Resources");
-            }
+            EnsureResourcesFolderExists();
 
             var newSettings = CreateInstance<HyperSDKSettings>();
-            string assetPath = $"{HyperConstants.RESOURCES_FOLDER_PATH}/HyperSDKSettings.asset";
+            string assetPath = $"{HyperConstants.SETTINGS_ASSET_PATH}";
 
             AssetDatabase.CreateAsset(newSettings, assetPath);
             AssetDatabase.SaveAssets();
@@ -129,13 +126,10 @@ namespace Hyper.Editor
 
         private void CreateConfigAsset()
         {
-            if (!AssetDatabase.IsValidFolder(HyperConstants.RESOURCES_FOLDER_PATH))
-            {
-                AssetDatabase.CreateFolder("Assets", "Resources");
-            }
+            EnsureResourcesFolderExists();
 
             var newConfig = CreateInstance<HyperGameContentConfig>();
-            string assetPath = $"{HyperConstants.RESOURCES_FOLDER_PATH}/HyperGameContentConfig.asset";
+            string assetPath = $"{HyperConstants.GAME_CONTENT_ASSET_PATH}";
 
             AssetDatabase.CreateAsset(newConfig, assetPath);
             AssetDatabase.SaveAssets();
@@ -287,6 +281,33 @@ namespace Hyper.Editor
         }
 
         #endregion
+        internal static void EnsureResourcesFolderExists()
+        {
+            if (AssetDatabase.IsValidFolder(HyperConstants.RESOURCES_FOLDER_PATH))
+            {
+                return;
+            }
+
+            string[] segments = HyperConstants.RESOURCES_FOLDER_PATH.Split('/');
+            if (segments.Length == 0)
+            {
+                return;
+            }
+
+            string currentPath = segments[0]; // "Assets"
+            for (int i = 1; i < segments.Length; i++)
+            {
+                string folderName = segments[i];
+                string nextPath = $"{currentPath}/{folderName}";
+
+                if (!AssetDatabase.IsValidFolder(nextPath))
+                {
+                    AssetDatabase.CreateFolder(currentPath, folderName);
+                }
+
+                currentPath = nextPath;
+            }
+        }
     }
 }
 #endif

package/HyperLoader.unity

@@ -885,7 +885,7 @@ GameObject:
   m_Component:
   - component: {fileID: 1064166296}
   m_Layer: 0
-  m_Name: __HyperSDK_BuildMarker_638996587933635093
+  m_Name: __HyperSDK_BuildMarker_638997386571830226
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
@@ -1840,7 +1840,7 @@ MonoBehaviour:
   m_MinValue: 0
   m_MaxValue: 1
   m_WholeNumbers: 0
-  m_Value: 0.227
+  m_Value: 0.065
   m_OnValueChanged:
     m_PersistentCalls:
       m_Calls: []

package/Runtime/Internal/UI/Modals/GamePausedModal.cs

@@ -120,7 +120,7 @@ namespace Hyper.Internal
         {
             _dataManager.SetSound(_dataManager.GetSound() == 1 ? 0 : 1);
             soundIcon.sprite = _dataManager.GetSound() == 1 ? soundIconOn : soundIconOff;
-            soundText.text = _dataManager.GetSound() == 1 ? "Sound ON" : "Sound OFF";
+            soundText.text = _dataManager.GetSound() == 1 ? "Sound On" : "Sound Off";
         }
 
         public void ShowTutorial()

package/Runtime/Internal/Utils/HyperConstants.cs

@@ -37,6 +37,7 @@ namespace Hyper.Internal
         public const string SETTINGS_ASSET_PATH = "Assets/HyperSDK/Runtime/Resources/HyperSDKSettings.asset";
         public const string GAME_CONTENT_ASSET_PATH = "Assets/HyperSDK/Runtime/Resources/HyperGameContentConfig.asset";
         public const string RESOURCES_FOLDER_PATH = "Assets/HyperSDK/Runtime/Resources";
+        public const string HYPER_LOADER_SCENE_PATH = "Assets/HyperSDK/HyperLoader.unity";
         
         /// <summary>
         /// Returns the banner texture path, checking dev mode (Assets/) first, then package mode (Packages/).

package/Runtime/Resources/HyperGameContentConfig.asset

@@ -14,9 +14,15 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   GameScene:
     sceneGUID: 
+    scenePath: 
+    sceneName: 
   PracticeScene:
     sceneGUID: 
+    scenePath: 
+    sceneName: 
   PracticeSceneType: 0
   TransitionScene:
     sceneGUID: 
+    scenePath: 
+    sceneName: 
   gamePosterSprite: {fileID: 0}

package/Runtime/Shared/Utils/HyperSceneReference.cs

@@ -8,75 +8,69 @@ namespace Hyper.Shared
     /// Allows drag-and-drop scene assignment in the inspector without external dependencies.
     /// </summary>
     [Serializable]
-    public class HyperSceneReference
+    public class HyperSceneReference : ISerializationCallbackReceiver
     {
         [SerializeField]
         private string sceneGUID;
 
+        [SerializeField]
+        private string scenePath;
+
+        [SerializeField]
+        private string sceneName;
+
         /// <summary>
-        /// Gets the scene name from the GUID, or null if invalid.
+        /// Gets the scene name stored at serialization time.
         /// </summary>
         public string SceneName
         {
             get
             {
-                if (string.IsNullOrEmpty(sceneGUID))
-                {
-                    return null;
-                }
-
 #if UNITY_EDITOR
-                string assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(sceneGUID);
-                if (string.IsNullOrEmpty(assetPath))
+                // In editor, keep sceneName in sync with GUID/path for clarity
+                if (!string.IsNullOrEmpty(sceneGUID))
                 {
-                    return null;
+                    string assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(sceneGUID);
+                    if (!string.IsNullOrEmpty(assetPath))
+                    {
+                        string fileName = System.IO.Path.GetFileNameWithoutExtension(assetPath);
+                        if (!string.IsNullOrEmpty(fileName))
+                        {
+                            sceneName = fileName;
+                            scenePath = assetPath;
+                        }
+                    }
                 }
-
-                // Extract scene name from path (e.g., "Assets/Scenes/MyScene.unity" -> "MyScene")
-                string sceneName = System.IO.Path.GetFileNameWithoutExtension(assetPath);
-                return sceneName;
-#else
-                // In builds, we can't resolve GUIDs, so return null
-                return null;
 #endif
+                return sceneName;
             }
         }
 
+        /// <summary>
+        /// Gets the scene path stored at serialization time.
+        /// </summary>
+        public string ScenePath => scenePath;
+
         /// <summary>
         /// Gets the scene GUID.
         /// </summary>
         public string GUID => sceneGUID;
 
         /// <summary>
-        /// Returns true if the scene reference is valid (has a GUID and resolves to a scene).
+        /// Returns true if the scene reference has valid serialized data.
         /// </summary>
         public bool IsValid
         {
             get
             {
-                if (string.IsNullOrEmpty(sceneGUID))
-                {
-                    return false;
-                }
-
-#if UNITY_EDITOR
-                string assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(sceneGUID);
-                if (string.IsNullOrEmpty(assetPath))
-                {
-                    return false;
-                }
-
-                // Check if it's actually a scene file
-                return assetPath.EndsWith(".unity", System.StringComparison.OrdinalIgnoreCase);
-#else
-                // In builds, assume valid if GUID exists (can't verify without AssetDatabase)
-                return true;
-#endif
+                return !string.IsNullOrEmpty(sceneGUID) &&
+                       !string.IsNullOrEmpty(sceneName);
             }
         }
 
         /// <summary>
         /// Implicit conversion to string for backward compatibility.
+        /// Returns the stored scene name.
         /// </summary>
         public static implicit operator string(HyperSceneReference sceneRef)
         {
@@ -90,6 +84,28 @@ namespace Hyper.Shared
         {
             return SceneName ?? string.Empty;
         }
+
+#if UNITY_EDITOR
+        public void OnBeforeSerialize()
+        {
+            if (!string.IsNullOrEmpty(sceneGUID))
+            {
+                string assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(sceneGUID);
+                if (!string.IsNullOrEmpty(assetPath))
+                {
+                    scenePath = assetPath;
+                    sceneName = System.IO.Path.GetFileNameWithoutExtension(assetPath);
+                }
+            }
+        }
+
+        public void OnAfterDeserialize()
+        {
+        }
+#else
+        public void OnBeforeSerialize() { }
+        public void OnAfterDeserialize() { }
+#endif
     }
 }
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "app.hypergames.hypersdk",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "displayName": "HyperSDK",
-  "description": "Official Unity SDK for HyperGames. Brings platform APIs, multiplayer battle flow, score and tutorial systems, and WebGL build tooling straight into your project.",
+  "description": "Official Unity SDK for Hyper: multiplayer battles, leaderboards, deterministic RNG, session management, tutorials, and WebGL optimizations for production-ready games.",
   "unity": "6000.0",
   "unityRelease": "0b5",
   "keywords": [
@@ -25,9 +25,9 @@
     "email": "info@mvm.gg",
     "url": "https://mvm.gg/"
   },
-  "licensesUrl": "https://github.com/mvmhyper/hyper-sdk/blob/main/LICENSE.md",
-  "changelogUrl": "https://github.com/mvmhyper/hyper-sdk/blob/main/CHANGELOG.md",
-  "documentationUrl": "https://docs.hypergames.app/",
+  "licensesUrl": "https://mvm.gg/",
+  "changelogUrl": "https://mvm.gg/",
+  "documentationUrl": "https://mvm.gg/",
   "repository": {
     "type": "git",
     "url": "https://github.com/mvmhyper/hyper-sdk.git",