app.hypergames.hypersdk 1.8.2 → 1.8.4

package/Runtime/Internal/UI/Components/ConnectionStatusIcon.cs

@@ -1,6 +1,8 @@
 using Hyper.Internal.Managers;
 using Hyper.Internal.Animation;
+using TMPro;
 using UnityEngine;
+using UnityEngine.UI;
 
 namespace Hyper.Internal
 {
@@ -9,43 +11,286 @@ namespace Hyper.Internal
         public GameObject lost;
         public GameObject restored;
 
+        [Tooltip("Wifi / latency visuals while connected. Leave unassigned only if the prefab has no dynamic group.")]
+        public GameObject dynamicPingIcon;
+
+        [Header("Ping thresholds (ms)")]
+        [Tooltip("Latency at or below (when connected) uses solid good color; above uses solid average color.")]
+        [SerializeField] private int goodPingMaxMs = 103;
+        [Tooltip("Bar section alphas grade from all 1 at 0 ms to the bad profile at this latency (ms).")]
+        [SerializeField] private int badPingMaxMs = 293;
+
+        [Header("Ping colors (no blending — either good or average)")]
+        [SerializeField] private Color goodPingColor = new Color(0.14509805f, 0.6666667f, 0.4f, 1f);
+        [SerializeField] private Color averagePingColor = new Color(1f, 0.4862745f, 0f, 1f);
+
+        [Header("Ping bars (top to bottom)")]
+        [SerializeField] private Image goodPingBar;
+        [SerializeField] private Image averagePingBar;
+        [SerializeField] private Image lowPingBar;
+
+        [Header("Wifi holder extras")]
+        [Tooltip("Background uses same RGB as the active ping tone; alpha fixed at 10%.")]
+        [SerializeField] private Image wifiBackgroundImage;
+        [Tooltip("Wifi dot uses same RGB; alpha fixed at 100%.")]
+        [SerializeField] private Image wifiDotImage;
+
+        [Header("Latency label")]
+        [SerializeField] private TextMeshProUGUI wifiLatencyText;
+
+        private const float WifiBackgroundAlpha = 0.175f;
+        private const float WifiDotAlpha = 1f;
+
+        /// <summary>Never below this so bars stay faintly visible.</summary>
+        private const float BarAlphaFloor = 0.1f;
+
+        // stressT = 0 good latency → all bars full; stressT = 1 bad → graded (bottom strongest) + dot at 1.
+        private const float TopBarAlphaGood = 1f;
+        private const float MidBarAlphaGood = 1f;
+        private const float LowBarAlphaGood = 1f;
+
+        private const float TopBarAlphaBad = 0.12f;
+        private const float MidBarAlphaBad = 0.3f;
+        private const float LowBarAlphaBad = 0.65f;
+
+        private const string HypergamesProductionApiUrl = "https://api.hypergames.app";
+
+#if UNITY_EDITOR
+        [Header("Editor test")]
+        [SerializeField] private bool simulateRandomPingInEditor = true;
+        [SerializeField] private int editorSimMinMs = 20;
+        [SerializeField] private int editorSimMaxMs = 400;
+        [SerializeField] private float editorSimIntervalSeconds = 2f;
+
+        private float _editorNextPingSampleTime;
+        private int _editorSimulatedLatencyMs;
+#endif
+
         private RectTransform rectTransform;
+        private EventManager _eventManager;
+        private BackendManager _backendManager;
 
         private void Awake()
         {
-            var _eventManager = HyperRuntime.EventManager;
+            _eventManager = HyperRuntime.EventManager;
+            _backendManager = HyperRuntime.BackendManager;
             rectTransform = GetComponent<RectTransform>();
 
-           _eventManager.OnInternetConnectionLost += ConnectionLost;
-           _eventManager.OnInternetConnectionFound += ConnectionRestored;
+            _eventManager.OnInternetConnectionLost += ConnectionLost;
+            _eventManager.OnInternetConnectionFound += ConnectionRestored;
+            _eventManager.OnBackendSocketManuallyClosed += OnBackendSocketManuallyClosed;
         }
 
         private void Start()
         {
-            rectTransform.anchoredPosition = new Vector2(rectTransform.anchoredPosition.x, -100);
+            ApplyStandardVisibility();
+
+            if (!ShouldUseDynamicPingIcon() && rectTransform != null)
+            {
+                Vector2 p = rectTransform.anchoredPosition;
+                rectTransform.anchoredPosition = new Vector2(p.x, -100f);
+            }
+
+#if UNITY_EDITOR
+            if (simulateRandomPingInEditor)
+            {
+                editorSimMaxMs = Mathf.Max(editorSimMinMs, editorSimMaxMs);
+                editorSimIntervalSeconds = Mathf.Max(0.1f, editorSimIntervalSeconds);
+                ResampleEditorPing();
+                _editorNextPingSampleTime = Time.realtimeSinceStartup + editorSimIntervalSeconds;
+            }
+#endif
+        }
+
+        private void OnDestroy()
+        {
+            if (_eventManager != null)
+            {
+                _eventManager.OnInternetConnectionLost -= ConnectionLost;
+                _eventManager.OnInternetConnectionFound -= ConnectionRestored;
+                _eventManager.OnBackendSocketManuallyClosed -= OnBackendSocketManuallyClosed;
+            }
+        }
+
+        private void Update()
+        {
+#if UNITY_EDITOR
+            if (simulateRandomPingInEditor)
+            {
+                if (Time.realtimeSinceStartup >= _editorNextPingSampleTime)
+                {
+                    ResampleEditorPing();
+                    _editorNextPingSampleTime = Time.realtimeSinceStartup + editorSimIntervalSeconds;
+                }
+            }
+#endif
+
+            bool haveLatency = TryGetCurrentLatency(out int lat, out bool socketOk);
+            bool showPingUi = ShouldUseDynamicPingIcon();
+
+            if (wifiLatencyText != null)
+            {
+                if (!showPingUi)
+                    wifiLatencyText.text = string.Empty;
+                else if (!haveLatency || !socketOk || lat < 0)
+                    wifiLatencyText.text = "--";
+                else
+                    wifiLatencyText.text = $"{Mathf.Clamp(lat, 0, badPingMaxMs)} ms";
+            }
+
+            if (!showPingUi || dynamicPingIcon == null || !dynamicPingIcon.activeSelf)
+                return;
+
+            if (!haveLatency)
+                return;
+
+            RefreshPingBars(lat, socketOk);
+        }
+
+        private bool TryGetCurrentLatency(out int lat, out bool socketOk)
+        {
+#if UNITY_EDITOR
+            if (simulateRandomPingInEditor)
+            {
+                lat = _editorSimulatedLatencyMs;
+                socketOk = true;
+                return true;
+            }
+#endif
+            BackendManager backend = HyperRuntime.BackendManager;
+            if (backend == null)
+            {
+                lat = -1;
+                socketOk = false;
+                return false;
+            }
+
+            lat = backend.SdkSmoothedLatencyMs;
+            socketOk = backend.isSocketConnected;
+            return true;
+        }
+
+#if UNITY_EDITOR
+        private void ResampleEditorPing()
+        {
+            int min = Mathf.Min(editorSimMinMs, editorSimMaxMs);
+            int max = Mathf.Max(editorSimMinMs, editorSimMaxMs);
+            _editorSimulatedLatencyMs = Random.Range(min, max + 1);
+        }
+#endif
+
+        private void OnBackendSocketManuallyClosed()
+        {
+            this.DOKill();
+            gameObject.SetActive(false);
         }
 
-        void ConnectionLost()
+        private void ConnectionLost()
         {
-            lost.SetActive(true);
-            restored.SetActive(false);
+            SetActiveSafe(lost, true);
+            SetActiveSafe(restored, false);
+            SetActiveSafe(dynamicPingIcon, false);
 
-            rectTransform.DOAnchorPosY(0f, 0.5f).SetUpdate(true).SetEase(HyperTween.Ease.InQuad);
+            if (rectTransform != null)
+                rectTransform.DOAnchorPosY(0f, 0.5f).SetUpdate(true).SetEase(HyperTween.Ease.InQuad);
         }
 
-        void ConnectionRestored()
+        private void ConnectionRestored()
         {
-            lost.SetActive(false);
-            restored.SetActive(true);
+            SetActiveSafe(lost, false);
+            SetActiveSafe(restored, false);
+            SetActiveSafe(dynamicPingIcon, ShouldUseDynamicPingIcon());
 
-            rectTransform.DOAnchorPosY(0, 0.5f).SetUpdate(true).SetEase(HyperTween.Ease.InQuad).OnComplete(() =>
+            if (rectTransform != null)
             {
-                HyperTween.DelayedCall(4f, () =>
+                rectTransform.DOAnchorPosY(0f, 0.5f).SetUpdate(true).SetEase(HyperTween.Ease.InQuad).OnComplete(() =>
                 {
-                    rectTransform.DOAnchorPosY(-100f, 0.5f).SetUpdate(true).SetEase(HyperTween.Ease.InQuad);
+                    if (!ShouldUseDynamicPingIcon())
+                    {
+                        HyperTween.DelayedCall(4f, () =>
+                        {
+                            if (rectTransform != null)
+                                rectTransform.DOAnchorPosY(-100f, 0.5f).SetUpdate(true).SetEase(HyperTween.Ease.InQuad);
+                        });
+                    }
                 });
-            });
+            }
+        }
+
+        private void ApplyStandardVisibility()
+        {
+            SetActiveSafe(lost, false);
+            SetActiveSafe(restored, false);
+            SetActiveSafe(dynamicPingIcon, ShouldUseDynamicPingIcon());
+        }
+
+        private bool ShouldUseDynamicPingIcon()
+        {
+            if (HyperRuntime.GameManager == null || !HyperRuntime.GameManager.IsBattleMode)
+                return false;
+
+            if (_backendManager == null)
+                return true;
+
+            return _backendManager.GetServerUrl() != HypergamesProductionApiUrl;
+        }
+
+        private static void SetActiveSafe(GameObject go, bool active)
+        {
+            if (go != null)
+                go.SetActive(active);
         }
-    }
 
+        private void RefreshPingBars(int lat, bool socketOk)
+        {
+            bool isGoodPing = socketOk && lat >= 0 && lat <= goodPingMaxMs;
+            Color tone = isGoodPing ? goodPingColor : averagePingColor;
+
+            float stressT;
+            if (!socketOk || lat < 0)
+            {
+                stressT = 1f;
+            }
+            else
+            {
+                float span = Mathf.Max(1f, badPingMaxMs);
+                stressT = Mathf.Clamp01(lat / span);
+            }
+
+            float topAlpha = Mathf.Lerp(TopBarAlphaGood, TopBarAlphaBad, stressT);
+            float midAlpha = Mathf.Lerp(MidBarAlphaGood, MidBarAlphaBad, stressT);
+            float lowAlpha = Mathf.Lerp(LowBarAlphaGood, LowBarAlphaBad, stressT);
+
+            topAlpha = Mathf.Max(topAlpha, BarAlphaFloor);
+            midAlpha = Mathf.Max(midAlpha, BarAlphaFloor);
+            lowAlpha = Mathf.Max(lowAlpha, BarAlphaFloor);
+
+            ApplyBarTint(goodPingBar, tone, topAlpha);
+            ApplyBarTint(averagePingBar, tone, midAlpha);
+            ApplyBarTint(lowPingBar, tone, lowAlpha);
+
+            ApplyToneFixedAlpha(wifiBackgroundImage, tone, WifiBackgroundAlpha);
+            ApplyToneFixedAlpha(wifiDotImage, tone, WifiDotAlpha);
+        }
+
+        private static void ApplyBarTint(Image img, Color toneRgb, float alphaMultiplier)
+        {
+            if (img == null)
+                return;
+
+            Color c = toneRgb;
+            c.a = Mathf.Clamp01(toneRgb.a * Mathf.Clamp01(alphaMultiplier));
+            img.color = c;
+        }
+
+        private static void ApplyToneFixedAlpha(Image img, Color toneRgb, float alpha)
+        {
+            if (img == null)
+                return;
+
+            Color c = toneRgb;
+            c.a = alpha;
+            img.color = c;
+        }
+    }
 }

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

@@ -74,7 +74,7 @@ namespace Hyper.Internal
 
             loadingCircle.SetActive(true);
 
-            HyperRuntime.BackendManager.LogEvent(ConsoleEventType.sdk_GameEndNoInternet);
+            HyperRuntime.BackendManager.LogEvent(ConsoleEventType.GameEnd);
         }
 
         public void Retry()

package/Runtime/Plugins/WebGL/HyperTutorialCachePlugin.jslib

@@ -1,11 +1,13 @@
 mergeInto(LibraryManager.library, {
   $CachedTutorialData: null,
 
-  FetchAndCacheTutorials: function (gameSlugPtr, gameObjectPtr) {
+  FetchAndCacheTutorials: function (serverBaseUrlPtr, gameSlugPtr, gameObjectPtr) {
+    let baseUrl = UTF8ToString(serverBaseUrlPtr);
+    if (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
     const gameSlug = UTF8ToString(gameSlugPtr);
     const gameObject = UTF8ToString(gameObjectPtr);
 
-    const endpoint = `https://api.dev.hypergames.app/games/${gameSlug}/tutorials`;
+    const endpoint = `${baseUrl}/games/${gameSlug}/tutorials`;
 
     caches.open("tutorial-cache").then(async (cache) => {
       try {

package/Runtime/Plugins/WebGL/HyperWebSocketPlugin.jslib

@@ -45,6 +45,11 @@ mergeInto(LibraryManager.library, {
       const msg = JSON.stringify(data);
       SendMessage('HyperSDKSingleton', 'OnSocketScoreUpdated', msg);
     });
+
+    socket.on('sdkPong', (data) => {
+      const msg = JSON.stringify(data);
+      SendMessage('HyperSDKSingleton', 'OnSocketSdkPong', msg);
+    });
   },
 
   SendWebSocketMessage: function (messagePtr) {

package/Runtime/Resources/Sprites/Control Bar/Internet Connection/Group 36946.png.meta

@@ -0,0 +1,169 @@
+fileFormatVersion: 2
+guid: 7ea254ee7cab588419030e57237587e2
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -505862413677581413
+    second: Group 36946_0
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: Group 36946_0
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: b9ba68f90d0daf8f0800000000000000
+      internalID: -505862413677581413
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      Group 36946_0: -505862413677581413
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Resources/Sprites/Control Bar/Internet Connection/Group-1.png.meta

@@ -0,0 +1,169 @@
+fileFormatVersion: 2
+guid: 59e469bf5447a2843984dd0d1e3e49b6
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -1671329636532071926
+    second: Group-1_0
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 256
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 1
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: Group-1_0
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 47
+        height: 16
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: a025ce7fc8e3ec8e0800000000000000
+      internalID: -1671329636532071926
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      Group-1_0: -1671329636532071926
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: