gg.easy.airship 0.1.2162 → 0.1.2164

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.cs]
+csharp_new_line_before_open_brace = none
+csharp_new_line_before_else = false
+csharp_new_line_before_catch = false
+csharp_new_line_before_finally = false
+csharp_new_line_before_members_in_object_initializers = false
+csharp_new_line_before_members_in_anonymous_types = false

package/Editor/BuildMenu.cs

@@ -49,38 +49,38 @@ namespace Editor {
         }
 
         public static void BuildLinuxServerStaging() {
-            PlayerSettings.SetScriptingDefineSymbols(NamedBuildTarget.Server, new string[] {"AIRSHIP_STAGING", "AIRSHIP_PLAYER", "AIRSHIP_INTERNAL"});
-            BuildLinuxServer();
+            BuildLinuxServer(new []{"AIRSHIP_STAGING"});
         }
-
+        
 #if AIRSHIP_PLAYER
         [MenuItem("Airship/Create Binary/Server/Linux", priority = 80)]
 #endif
-        public static void BuildLinuxServer() {
-            OnBuild();
-            EditorBuildSettingsScene[] scenes = {
-                new("Packages/gg.easy.airship/Runtime/Scenes/MainMenu.unity", true),
-                new("Packages/gg.easy.airship/Runtime/Scenes/CoreScene.unity", true),
-                new("Packages/gg.easy.airship/Runtime/Scenes/Login.unity", true)
-            };
-            EditorBuildSettings.scenes = scenes;
+        public static void BuildLinuxServerProduction() {
+            BuildLinuxServer(new string[]{});
+        }
+
 
+        public static void BuildLinuxServer(string[] extraDefines) {
+            OnBuild();
             FileUtil.DeleteFileOrDirectory("build/StandaloneLinux64");
 
-            // This should probably be NamedBuildTarget.Server (rather than Standalone), but that does cause some issues.
-            // We will want to review this again in the future as a possible optimization.
-            PlayerSettings.SetScriptingBackend(NamedBuildTarget.Standalone, ScriptingImplementation.IL2CPP);
-            PlayerSettings.dedicatedServerOptimizations = true;
-            PlayerSettings.insecureHttpOption = InsecureHttpOption.AlwaysAllowed;
+            BuildProfile buildProfile =
+                AssetDatabase.LoadAssetAtPath<BuildProfile>("Assets/Settings/Build Profiles/Dedicated Server (Linux).asset");
+            buildProfile.overrideGlobalScenes = true;
+            buildProfile.scenes = new[] {
+                new EditorBuildSettingsScene("Packages/gg.easy.airship/Runtime/Scenes/CoreScene.unity", true)
+            };
+            buildProfile.scriptingDefines = new[] { "UNITY_SERVER", "AIRSHIP_PLAYER", "AIRSHIP_INTERAL" }.Concat(extraDefines).ToArray();
+            BuildProfile.SetActiveBuildProfile(buildProfile);
+            
+            Debug.Log("Building with " + buildProfile.scenes.Length + " scenes");
 
-            EditorUserBuildSettings.managedDebuggerFixedPort = 55000;
-            var options = new BuildPlayerOptions();
-            options.scenes = new[] { "Packages/gg.easy.airship/Runtime/Scenes/CoreScene.unity" };
-            options.locationPathName = $"build/StandaloneLinux64/{ServerExecutableName}";
-            options.target = BuildTarget.StandaloneLinux64;
-            options.extraScriptingDefines = new[] { "UNITY_SERVER", "AIRSHIP_PLAYER", "AIRSHIP_INTERAL" };
-            options.subtarget = (int)StandaloneBuildSubtarget.Server;
-            options.options |= BuildOptions.Development; //Enable the profiler
+            var options = new BuildPlayerWithProfileOptions() {
+                buildProfile = buildProfile,
+                locationPathName = $"build/StandaloneLinux64/{ServerExecutableName}",
+                options = BuildOptions.Development,
+            };
+            
             var report = BuildPipeline.BuildPlayer(options);
             var summary = report.summary;
             switch (summary.result) {
@@ -94,7 +94,7 @@ namespace Editor {
                     Debug.Log("Build Linux unexpected result:" + summary.result);
                     break;
             }
-
+            
             CreateAssetBundles.AddAllGameBundleScenes();
         }
 

package/Runtime/Code/AirshipConst.cs

@@ -1,11 +1,11 @@
 // ReSharper disable InconsistentNaming
 namespace Code {
     public static class AirshipConst {
-        public const int playerVersion = 12;
+        public const int playerVersion = 13;
 
         /// <summary>
         /// The server will kick clients that have a playerVersion lower than this value.
         /// </summary>
-        public const int minAcceptedPlayerVersionOnServer = 12;
+        public const int minAcceptedPlayerVersionOnServer = 13;
     }
 }

package/Runtime/Code/Analytics/ClientFolderUploader.cs

@@ -0,0 +1,145 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Threading.Tasks;
+using Code.Http.Internal;
+using Code.Http.Public;
+using Code.Platform.Shared;
+using Proyecto26;
+using UnityEngine;
+
+namespace Code.Analytics {
+    [Serializable]
+    public class PostArtifactResponse {
+        public string id;
+        public string url;
+    }
+
+    [Serializable]
+    public class RequestBody {
+        public string type;
+        public string name;
+        public string contentType;
+        public long contentLength;
+    }
+
+    public class ClientFolderUploader : MonoBehaviour {
+
+        // Start in the past otherwise they can't do this for the first 10 seconds since time starts at 0.
+        private float timeOfLastUpload = -10;
+
+        public void ButtonClick() {
+            if (Time.unscaledTime - timeOfLastUpload < 10) {
+                Debug.LogWarning("[ClientFolderUploader] Upload already in progress or too soon after last upload");
+                return;
+            }
+            timeOfLastUpload = Time.unscaledTime;
+
+            _ = UploadAsync();
+        }
+
+        private async Task UploadAsync() {
+            try {
+                await Upload();
+                Debug.Log("[ClientFolderUploader] Upload completed successfully");
+            } catch (Exception ex) {
+                Debug.LogError($"[ClientFolderUploader] Upload failed: {ex.Message}");
+            }
+        }
+
+        public async Task Upload() {
+            try {
+                var path = Path.GetDirectoryName(Application.consoleLogPath);
+
+                var zipPath = Path.Combine(Application.temporaryCachePath, "logs.zip");
+                if (File.Exists(zipPath)) {
+                    File.Delete(zipPath);
+                }
+
+                var playerLogFile = Path.Combine(path, "Player.log");
+                var playerPrevLogFile = Path.Combine(path, "Player-prev.log");
+                var editorLogFile = Path.Combine(path, "Editor.log");
+                var editorPrevLogFile = Path.Combine(path, "Editor-prev.log");
+
+                Debug.Log("[ClientFolderUploader] Creating zip archive");
+                try {
+                    using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create)) {
+                        var fileExists = false;
+                        if (File.Exists(playerLogFile)) {
+                            fileExists = true;
+                            Debug.Log("[ClientFolderUploader] Adding Player.log");
+                            archive.CreateEntryFromFile(playerLogFile, "Player.log");
+                        }
+
+                        if (File.Exists(playerPrevLogFile)) {
+                            fileExists = true;
+                            Debug.Log("[ClientFolderUploader] Adding Player-prev.log");
+                            archive.CreateEntryFromFile(playerPrevLogFile, "Player-prev.log");
+                        }
+
+                        if (File.Exists(editorLogFile)) {
+                            fileExists = true;
+                            Debug.Log("[ClientFolderUploader] Adding Editor.log");
+                            archive.CreateEntryFromFile(editorLogFile, "Editor.log");
+                        }
+
+                        if (File.Exists(editorPrevLogFile)) {
+                            fileExists = true;
+                            Debug.Log("[ClientFolderUploader] Adding Editor-prev.log");
+                            archive.CreateEntryFromFile(editorPrevLogFile, "Editor-prev.log");
+                        }
+
+                        if (!fileExists) {
+                            return;
+                        }
+                    }
+                } catch (Exception ex) {
+                    Debug.LogError($"[ClientFolderUploader] Zip creation failed: {ex.Message}");
+                    throw;
+                }
+
+                var contentType = "application/zip";
+                var contentLength = new FileInfo(zipPath).Length;
+
+                var body = new RequestBody {
+                    type = "CLIENT_DEBUG_ARCHIVE",
+                    name = "PlayerLogs.zip",
+                    contentType = contentType,
+                    contentLength = contentLength,
+                };
+
+                Debug.Log("[ClientFolderUploader] Creating artifact");
+                var url = $"{AirshipPlatformUrl.contentService}/artifacts/platform/signed-url";
+
+                Http.HttpResponse res;
+                if (String.IsNullOrEmpty(InternalHttpManager.authToken)) {
+                    res = await HttpManager.PostAsync(url, JsonUtility.ToJson(body));
+                } else {
+                    res = await InternalHttpManager.PostAsync(url, JsonUtility.ToJson(body));
+                }
+
+                if (res.statusCode < 200 || res.statusCode >= 300) {
+                    Debug.LogError($"[ClientFolderUploader] Error response from server: {res.statusCode} - {res.error}");
+                    throw new Exception($"Failed to get signed URL: {res.error}");
+                }
+
+                var response = JsonUtility.FromJson<PostArtifactResponse>(res.data);
+
+                Debug.Log("[ClientFolderUploader] Uploading file");
+                await HttpManager.PutAsync(new RequestHelper() {
+                    Uri = response.url,
+                    BodyRaw = File.ReadAllBytes(zipPath),
+                    Headers = new System.Collections.Generic.Dictionary<string, string>
+                    {
+                        { "Content-Type", contentType },
+                    },
+                }, "");
+
+                File.Delete(zipPath);
+            } catch (Exception ex) {
+                Debug.LogError($"[ClientFolderUploader] Error during upload process: {ex.Message}");
+                throw;
+            }
+        }
+    }
+}

package/Runtime/Code/Analytics/ClientFolderUploader.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 474c8118d514c47d2b470bdd6dd04d84

package/Runtime/Code/Auth/Socket/SocketManager.cs

@@ -5,6 +5,7 @@ using System.Threading.Tasks;
 using Airship.DevConsole;
 using Code.Auth;
 using Code.Http.Internal;
+using Code.Network;
 using Code.Platform.Shared;
 using Code.Util;
 using Luau;
@@ -62,6 +63,13 @@ public class SocketManager : Singleton<SocketManager> {
                     Debug.LogError("Failed to join game: " + res.error);
                 }
             }));
+        
+        DevConsole.AddCommand(Command.Create<string>("ping", "", "Measure ping to an airship server cluster",
+            Parameter.Create("Ping Server IP", "IP of the Airship cluster ping server."), (serverIp) => {
+               UdpPingTool.GetPing(serverIp, 1000).ContinueWith((result) => {
+                   Debug.Log($"Latency to {serverIp.Trim()} is {result.Result}ms");
+               });
+            }));
     }
 
     public static async Task<bool> ConnectAsyncInternal() {

package/Runtime/Code/Bootstrap/AirshipEntryPoint.cs

@@ -0,0 +1,13 @@
+using System;
+using Code.Bootstrap;
+using UnityEngine;
+
+
+/// <summary>
+/// This singleton is exists in the CoreScene, MainMenu, and Login scene.
+/// </summary>
+public class AirshipEntryPoint : Singleton<AirshipEntryPoint> {
+    private void Start() {
+        Debug.unityLogger.logHandler = new AirshipLogHandler();
+    }
+}

package/Runtime/Code/Bootstrap/AirshipEntryPoint.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1441bc18c60b412884336c9740a95575
+timeCreated: 1753828357

package/Runtime/Code/Bootstrap/AirshipLogHandler.cs

@@ -0,0 +1,22 @@
+using System;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace Code.Bootstrap {
+    public class AirshipLogHandler : ILogHandler {
+        private readonly ILogHandler defaultLogHandler = Debug.unityLogger.logHandler;
+
+        public void LogFormat(LogType logType, Object context, string format, params object[] args) {
+            string message = string.Format(format, args);
+
+            // TextMeshPro warning about unsupported character.
+            if (message.Contains("Unicode value \\u0007")) return;
+
+            defaultLogHandler.LogFormat(logType, context, format, args);
+        }
+
+        public void LogException(Exception exception, Object context) {
+            defaultLogHandler.LogException(exception, context);
+        }
+    }
+}

package/Runtime/Code/Bootstrap/AirshipLogHandler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ff48f1daed464a5aa73f34da054f6e7f
+timeCreated: 1753828486

package/Runtime/Code/Bootstrap/ClientBootstrap.cs

@@ -8,7 +8,11 @@ public class ClientBootstrap : MonoBehaviour
     private void Start()
     {
         if (RunCore.IsClient()) {
+#if UNITY_STANDALONE_OSX
+            Application.targetFrameRate = -1;
+#else
             Application.targetFrameRate = (int)Math.Ceiling(Screen.currentResolution.refreshRateRatio.value);
+#endif
             Application.logMessageReceived += AnalyticsRecorder.RecordLogMessageToAnalytics;
         }
     }

package/Runtime/Code/Bootstrap/SignalHandler.cs

@@ -1,10 +1,6 @@
 using System.Collections;
-using System.Threading;
+using System.Runtime.InteropServices;
 using Code.Util;
-#if UNITY_STANDALONE_LINUX || UNITY_EDITOR_LINUX
-using Mono.Unix;
-using Mono.Unix.Native;
-#endif
 using UnityEngine;
 
 namespace Code.Bootstrap {
@@ -12,34 +8,51 @@ namespace Code.Bootstrap {
         public ServerBootstrap serverBootstrap;
         public UnityMainThreadDispatcher unityMainThread;
 
-
 #if UNITY_STANDALONE_LINUX || UNITY_EDITOR_LINUX
-        void Start() {
-            var thread = new Thread(CheckForSignals);
-            thread.Start();
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void SignalDelegate();
+
+        [DllImport("signalhandler", CallingConvention = CallingConvention.Cdecl)]
+        private static extern void RegisterSigTermHandler(SignalDelegate callback);
+
+        private static SignalDelegate cachedDelegate;
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        private static void Init()
+        {
+            cachedDelegate = OnSigTerm;
+            RegisterSigTermHandler(cachedDelegate);
+            Debug.Log("Unix SIGTERM handler registered");
         }
 
-        private void CheckForSignals() {
-            while (true) {
-                var signals = new UnixSignal[] {
-                    new UnixSignal(Signum.SIGTERM)
-                };
-                int index = UnixSignal.WaitAny(signals, -1);
-
-                if (index >= 0 && signals[index].IsSet) {
-                    Debug.Log("Sigterm.1");
-                    this.unityMainThread.Enqueue(HandleSigterm());
-                    signals[index].Reset();
-                }
+        // This is called from a POSIX signal context
+        [AOT.MonoPInvokeCallback(typeof(SignalDelegate))]
+        private static void OnSigTerm()
+        {
+            Debug.Log("SIGTERM signal received from native");
+
+            // We can't call Unity APIs directly from signal thread,
+            // So we need to dispatch back to main thread
+            _hasSigterm = true;
+        }
+
+        private static bool _hasSigterm;
+
+        private void Update()
+        {
+            if (_hasSigterm)
+            {
+                _hasSigterm = false;
+                unityMainThread.Enqueue(HandleSigterm());
             }
         }
 
-        private IEnumerator HandleSigterm() {
+        private IEnumerator HandleSigterm()
+        {
             Debug.Log("SIGTERM received. Performing cleanup.");
-            // Perform your cleanup here
             serverBootstrap.InvokeOnProcessExit();
             yield return null;
-            // Application.Quit();
+            Application.Quit();
         }
 #endif
     }

package/Runtime/Code/CoreUI/Login/LoginApp.cs

@@ -283,7 +283,7 @@ public class LoginApp : MonoBehaviour {
         RestClient.Get(new RequestHelper() {
             Uri = AirshipPlatformUrl.gameCoordinator + (prodApp ? "/auth/steam/in-game" : "/auth/steam/in-game-playtest"),
             Headers = new Dictionary<string, string>() {
-                { "Authorization", steamToken }
+                { "steam-token", steamToken }
             },
         }).Then((gcRes) => {
             print("gc response: " + gcRes.Text);

package/Runtime/Code/Luau/LuauCoreCallbacks.cs

@@ -1157,10 +1157,8 @@ public partial class LuauCore : MonoBehaviour {
     static unsafe int CallMethodCallback(LuauContext context, IntPtr thread, int instanceId, IntPtr classNamePtr, int classNameSize, IntPtr methodNamePtr, int methodNameLength, int numParameters, IntPtr firstParameterType, IntPtr firstParameterData, IntPtr firstParameterSize, IntPtr firstParameterIsTable, IntPtr shouldYield) {
         CurrentContext = context;
         
-        // if (s_shutdown) return 0;
         Marshal.WriteInt32(shouldYield, 0);
         if (!IsReady) {
-            Profiler.EndSample();
             return 0;
         }
 
@@ -1428,7 +1426,6 @@ public partial class LuauCore : MonoBehaviour {
             return returnCount;
         }
 
-        Profiler.BeginSample("LuauCore.InvokeMethod");
         try {
             returnValue = finalMethod.Invoke(invokeObj, parsedData.Array);
         }
@@ -1439,8 +1436,6 @@ public partial class LuauCore : MonoBehaviour {
         catch (Exception e) {
             return LuauError(thread,
                 "Error: Exception thrown in method " + type.Name + "." + finalMethod.Name + ": " + e);
-        } finally {
-            Profiler.EndSample();
         }
 
         WriteMethodReturnValuesToThread(thread, type, finalMethod.ReturnType, finalParameters, returnValue, parsedData.Array);

package/Runtime/Code/LuauAPI/FrameTimingManagerAPI.cs

@@ -0,0 +1,10 @@
+using System;
+using UnityEngine;
+
+[LuauAPI]
+public class FrameTimingManagerAPI : BaseLuaAPIClass {
+    public override Type GetAPIType()
+    {
+        return typeof(UnityEngine.FrameTimingManager);
+    }
+}

package/Runtime/Code/LuauAPI/FrameTimingManagerAPI.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 35174f37579d4286a02956701ad67c2b
+timeCreated: 1753723051

package/Runtime/Code/Network/AirshipNetworkManager.cs

@@ -58,7 +58,9 @@ public class AirshipNetworkManager : NetworkManager {
     }
 
     public override void ConfigureHeadlessFrameRate() {
-        // Override default behavior of setting target frame rate equal to send rate. 
+        if (RunCore.IsClient()) return;
+        
+        // Override default behavior of setting target frame rate equal to send rate.
         // Since we aren't rendering anything, doing tons of Update calls isn't really very important, so we definitely should
         // lower the target frame rate, we just don't want to use the mirror default of using send rate because we may
         // set send rate lower than tick rate in the future and we want framerate to always match tick rate for dedicated servers.