app.hypergames.hypersdk 1.1.11 → 1.2.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [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)
+
+
+### Features
+
+* move HyperLoader scene to root and refactor SDK utilities naming ([4407493](https://github.com/mvmhyper/hyper-sdk/commit/4407493b8ad8edb86a1c21f9ba9701f350755197))
+
 ## [1.1.11](https://github.com/mvmhyper/hyper-sdk/compare/v1.1.10...v1.1.11) (2025-11-26)
 
 

package/Editor/Scripts/Setup/HyperSDKInstaller.cs

@@ -13,7 +13,7 @@ namespace Hyper.Editor
     {
         private const string InstallerPrefsKey = "HyperSDKInstaller.LastInstalledVersion";
         private const string HyperLoaderSceneRelativePath = "HyperLoader.unity";
-        private const string HyperLoaderSceneDestination = "Assets/HyperSDK/Scenes/HyperLoader.unity";
+        private const string HyperLoaderSceneDestination = "Assets/HyperSDK/HyperLoader.unity";
         private const string WebGLTemplateRelativePath = "WebGLTemplates/HyperLoader";
         private const string WebGLTemplateDestination = "Assets/WebGLTemplates/HyperLoader";
         private const string HyperGameContentConfigRelativePath = "Runtime/Resources/HyperGameContentConfig.asset";

package/Editor/Scripts/Utils/{SceneReferenceDrawer.cs → HyperSceneReferenceDrawer.cs}

@@ -6,19 +6,22 @@ using Hyper.Shared;
 namespace Hyper.Editor
 {
     /// <summary>
-    /// Custom property drawer for SceneReference that allows drag-and-drop scene assignment.
+    /// Custom property drawer for HyperSceneReference that allows drag-and-drop scene assignment.
     /// </summary>
-    [CustomPropertyDrawer(typeof(SceneReference))]
-    public class SceneReferenceDrawer : PropertyDrawer
+    [CustomPropertyDrawer(typeof(HyperSceneReference))]
+    public class HyperSceneReferenceDrawer : PropertyDrawer
     {
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
             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, "SceneReference: Invalid property structure");
+                EditorGUI.LabelField(position, label.text, "HyperSceneReference: Invalid property structure");
                 EditorGUI.EndProperty();
                 return;
             }
@@ -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/Utils/HyperSceneReferenceDrawer.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 34a12760281cb024b99481f162081826

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

package/Runtime/Internal/ScriptableObjects/HyperGameContentConfig.cs

@@ -13,7 +13,7 @@ namespace Hyper.Internal
         [Header("Battle Mode")]
         [Tooltip("BATTLE mode → Gameplay Scene: go straight into the match (no menu) after the loading screen.")]
         [Space(2)]
-        public SceneReference GameScene;
+        public HyperSceneReference GameScene;
 
         #endregion
 
@@ -22,7 +22,7 @@ namespace Hyper.Internal
         [Header("Practice Mode")]
         [Tooltip("PRACTICE mode → Menu Scene: open a menu after the loading screen so players can choose stage/options.")]
         [Space(2)]
-        public SceneReference PracticeScene;
+        public HyperSceneReference PracticeScene;
 
         public PracticeSceneType PracticeSceneType = PracticeSceneType.Menu;
 
@@ -39,7 +39,7 @@ namespace Hyper.Internal
         [Header("Scene Transitions")]
         [Tooltip("Optional: Scene used for transitions or loading between other scenes.")]
         [Space(2)]
-        public SceneReference TransitionScene;
+        public HyperSceneReference TransitionScene;
 
         /// <summary>
         /// Returns true if transition scene exists.

package/Runtime/Internal/Utils/JsonCompressor.cs

@@ -2,7 +2,6 @@ using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using System;
 using System.Text;
-using Hyper.Internal;
 
 namespace Hyper.Internal
 {

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

@@ -0,0 +1,111 @@
+using System;
+using UnityEngine;
+
+namespace Hyper.Shared
+{
+    /// <summary>
+    /// Serializable scene reference that stores scene GUID and provides scene name access.
+    /// Allows drag-and-drop scene assignment in the inspector without external dependencies.
+    /// </summary>
+    [Serializable]
+    public class HyperSceneReference : ISerializationCallbackReceiver
+    {
+        [SerializeField]
+        private string sceneGUID;
+
+        [SerializeField]
+        private string scenePath;
+
+        [SerializeField]
+        private string sceneName;
+
+        /// <summary>
+        /// Gets the scene name stored at serialization time.
+        /// </summary>
+        public string SceneName
+        {
+            get
+            {
+#if UNITY_EDITOR
+                // In editor, keep sceneName in sync with GUID/path for clarity
+                if (!string.IsNullOrEmpty(sceneGUID))
+                {
+                    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;
+                        }
+                    }
+                }
+#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 has valid serialized data.
+        /// </summary>
+        public bool IsValid
+        {
+            get
+            {
+                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)
+        {
+            return sceneRef?.SceneName;
+        }
+
+        /// <summary>
+        /// Returns the scene name, or empty string if invalid.
+        /// </summary>
+        public override string ToString()
+        {
+            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/Runtime/Shared/Utils/HyperSceneReference.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 349344249f15f3745852faad142ee623

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "app.hypergames.hypersdk",
-  "version": "1.1.11",
+  "version": "1.2.1",
   "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,21 +25,14 @@
     "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",
     "revision": "v0.1.0"
   },
-  "samples": [
-    {
-      "displayName": "Math Rush Sample Game",
-      "description": "Complete example game demonstrating HyperSDK integration including score submission, deterministic RNG, game modes, and UI integration. Perfect starting point for understanding how to use HyperSDK in your own games.",
-      "path": "Samples~/MathRushSample"
-    }
-  ],
   "dependencies": {
     "com.unity.nuget.newtonsoft-json": "3.2.1"
   }

package/Editor/Scripts/Utils/SceneReferenceDrawer.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 3d2d4a03230c53c4e8b11752555a23df

package/Runtime/Internal/Utils/SceneReferenceExtensions.cs

@@ -1,32 +0,0 @@
-// using Eflatun.SceneReference;
-
-// namespace Hyper.Internal
-// {
-//     /// <summary>
-//     /// Extension methods for Eflatun.SceneReference to simplify scene name retrieval.
-//     /// </summary>
-//     internal static class SceneReferenceExtensions
-//     {
-//         /// <summary>
-//         /// Gets the scene name if the scene reference is valid and in a regular state.
-//         /// </summary>
-//         /// <param name="sceneRef">The scene reference to validate</param>
-//         /// <returns>The scene name if valid, null otherwise</returns>
-//         public static string GetValidSceneName(this SceneReference sceneRef)
-//         {
-//             return (sceneRef != null && sceneRef.State == SceneReferenceState.Regular)
-//                 ? sceneRef.Name
-//                 : null;
-//         }
-
-//         /// <summary>
-//         /// Checks if a scene reference is valid and usable.
-//         /// </summary>
-//         /// <param name="sceneRef">The scene reference to check</param>
-//         /// <returns>True if the scene reference is valid and in regular state</returns>
-//         public static bool IsValid(this SceneReference sceneRef)
-//         {
-//             return sceneRef != null && sceneRef.State == SceneReferenceState.Regular;
-//         }
-//     }
-// }

package/Runtime/Internal/Utils/SceneReferenceExtensions.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 44da65fed37b13143843f10688e5605b

package/Runtime/Shared/Utils/SceneReference.cs

@@ -1,95 +0,0 @@
-using System;
-using UnityEngine;
-
-namespace Hyper.Shared
-{
-    /// <summary>
-    /// Serializable scene reference that stores scene GUID and provides scene name access.
-    /// Allows drag-and-drop scene assignment in the inspector without external dependencies.
-    /// </summary>
-    [Serializable]
-    public class SceneReference
-    {
-        [SerializeField]
-        private string sceneGUID;
-
-        /// <summary>
-        /// Gets the scene name from the GUID, or null if invalid.
-        /// </summary>
-        public string SceneName
-        {
-            get
-            {
-                if (string.IsNullOrEmpty(sceneGUID))
-                {
-                    return null;
-                }
-
-#if UNITY_EDITOR
-                string assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(sceneGUID);
-                if (string.IsNullOrEmpty(assetPath))
-                {
-                    return null;
-                }
-
-                // 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
-            }
-        }
-
-        /// <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).
-        /// </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
-            }
-        }
-
-        /// <summary>
-        /// Implicit conversion to string for backward compatibility.
-        /// </summary>
-        public static implicit operator string(SceneReference sceneRef)
-        {
-            return sceneRef?.SceneName;
-        }
-
-        /// <summary>
-        /// Returns the scene name, or empty string if invalid.
-        /// </summary>
-        public override string ToString()
-        {
-            return SceneName ?? string.Empty;
-        }
-    }
-}
-

package/Runtime/Shared/Utils/SceneReference.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 4322e1afbf85a694ead3a86b6a404991