gg.easy.airship 0.1.2163 → 0.1.2165

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/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,176 @@
+using System;
+using System.Collections.Generic;
+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 tempCurPlayerLogFile = Path.Combine(path, "Player-cur.log");
+                var playerPrevLogFile = Path.Combine(path, "Player-prev.log");
+                var editorLogFile = Path.Combine(path, "Editor.log");
+                var tempCurEditorLogFile = Path.Combine(path, "Editor-cur.log");
+                var editorPrevLogFile = Path.Combine(path, "Editor-prev.log");
+
+                var logMessages = new List<string>();
+
+                Action printDebugLines = () => {
+                    foreach (var message in logMessages) {
+                        Debug.Log(message);
+                    }
+                    logMessages.Clear();
+                };
+
+                var cleanupFiles = new List<string>() {
+                    zipPath,
+                };
+
+                Debug.Log("[ClientFolderUploader] Creating zip archive");
+                try {
+                        if (File.Exists(zipPath)) {
+                            File.Delete(zipPath);
+                        }
+                        using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create)) {
+                            var fileExists = false;
+                            if (File.Exists(playerLogFile)) {
+                                fileExists = true;
+                                File.Copy(playerLogFile, tempCurPlayerLogFile, true);
+                                logMessages.Add("[ClientFolderUploader] Adding Player.log");
+                                archive.CreateEntryFromFile(tempCurPlayerLogFile, "Player.log");
+                                cleanupFiles.Add(tempCurPlayerLogFile);
+                            }
+
+                            if (File.Exists(playerPrevLogFile)) {
+                                fileExists = true;
+                                logMessages.Add("[ClientFolderUploader] Adding Player-prev.log");
+                                archive.CreateEntryFromFile(playerPrevLogFile, "Player-prev.log");
+                            }
+
+                            if (File.Exists(editorLogFile)) {
+                                fileExists = true;
+                                File.Copy(editorLogFile, tempCurEditorLogFile, true);
+                                logMessages.Add("[ClientFolderUploader] Adding Editor.log");
+                                archive.CreateEntryFromFile(tempCurEditorLogFile, "Editor.log");
+                                cleanupFiles.Add(tempCurEditorLogFile);
+                            }
+
+                            if (File.Exists(editorPrevLogFile)) {
+                                fileExists = true;
+                                logMessages.Add("[ClientFolderUploader] Adding Editor-prev.log");
+                                archive.CreateEntryFromFile(editorPrevLogFile, "Editor-prev.log");
+                            }
+
+                            if (!fileExists) {
+                                return;
+                            }
+                        }
+                    } catch (Exception ex) {
+                        printDebugLines();
+                        Debug.LogError($"[ClientFolderUploader] Zip creation failed: {ex.Message}");
+                        throw;
+                    }
+
+                printDebugLines();
+
+                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 },
+                    },
+                }, "");
+
+                Debug.Log("[ClientFolderUploader] Deleting temporary files");
+                foreach (var file in cleanupFiles) {
+                    if (File.Exists(file)) {
+                        File.Delete(file);
+                    }
+                }
+            } 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/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/Bundles/AssetBridge.cs

@@ -259,7 +259,7 @@ public class AssetBridge : IAssetBridge
 #endif
 
 		if (printErrorOnFail) {
-			Debug.LogError("AssetBundle file not found: " + path + " (No asset bundle understood this path - is this asset bundle loaded?)");
+			Debug.LogError($"Failed to load asset at path \"{path}\". Are you sure it exists?");
 		}
 		return null;
 	}

package/Runtime/Code/Bundles/SystemRoot.cs

@@ -35,6 +35,7 @@ public class SystemRoot : Singleton<SystemRoot> {
 	public List<AssetBundleCreateRequest> extraBundleLoadRequests = new();
 	public static bool startedLoadingExtraBundle = false;
 	public static bool preWarmedCoreShaders = false;
+	private static bool disableCoreMaterialsBundle = false;
 	public AssetBundle coreMaterialsAssetBundle;
 	private bool loadInProgress = false;
 
@@ -105,16 +106,18 @@ public class SystemRoot : Singleton<SystemRoot> {
 				Debug.Log($"Loaded CoreMaterials bundle in {st.ElapsedMilliseconds} ms.");
 			}
 #else
-			if (File.Exists(path)) {
-				Debug.Log($"Loading CoreMaterials... ({path})");
-				var st = Stopwatch.StartNew();
-				var ao = AssetBundle.LoadFromFileAsync(path);
-				this.extraBundleLoadRequests.Add(ao);
-				await ao;
-				this.coreMaterialsAssetBundle = ao.assetBundle;
-				Debug.Log($"Loaded CoreMaterials bundle in {st.ElapsedMilliseconds} ms.");
-			} else {
-				Debug.LogWarning($"CoreMaterials path not found ({path})");
+			if (!disableCoreMaterialsBundle) {
+				if (File.Exists(path)) {
+					Debug.Log($"Loading CoreMaterials... ({path})");
+					var st = Stopwatch.StartNew();
+					var ao = AssetBundle.LoadFromFileAsync(path);
+					this.extraBundleLoadRequests.Add(ao);
+					await ao;
+					this.coreMaterialsAssetBundle = ao.assetBundle;
+					Debug.Log($"Loaded CoreMaterials bundle in {st.ElapsedMilliseconds} ms.");
+				} else {
+					Debug.LogWarning($"CoreMaterials path not found ({path})");
+				}
 			}
 #endif
 		}
@@ -342,11 +345,13 @@ public class SystemRoot : Singleton<SystemRoot> {
 			yield return this.WaitAll(loadLists[0].ToArray());
 			Debug.Log("Loading game...");
 			yield return this.WaitAll(loadLists[1].ToArray());
-			
-			foreach (var ao in this.extraBundleLoadRequests) {
-				if (!ao.isDone) {
-					Debug.Log("Waiting for shipped asset bundles to load...");
-					yield return ao;
+
+			if (!disableCoreMaterialsBundle) {
+				foreach (var ao in this.extraBundleLoadRequests) {
+					if (!ao.isDone) {
+						Debug.Log("Waiting for shipped asset bundles to load...");
+						yield return ao;
+					}
 				}
 			}
 

package/Runtime/Code/Luau/LuauCoreReflection.cs

@@ -420,7 +420,7 @@ public partial class LuauCore : MonoBehaviour
         LuauPlugin.LuauPushValueToThread(thread, (int)PODTYPE.POD_DOUBLE, new IntPtr(value: &value), 0);
     }
 
-    private static bool WriteArrayToThread(IntPtr thread, IEnumerable array, Type t, int knownSize = 0) {
+    public static bool WriteArrayToThread(IntPtr thread, IEnumerable array, Type t, int knownSize = 0) {
         LuauPluginRaw.NewTable(thread, knownSize);
 
         var i = 0;

package/Runtime/Code/Luau/ReflectionList.cs

@@ -187,6 +187,7 @@ namespace Luau {
             [typeof(MeshFilter)] = LuauContextAll,
             [typeof(Sprite)] = LuauContextAll,
             [typeof(DecalProjector)] = LuauContextAll,
+            [typeof(LODGroup)] = LuauContextAll,
             //Spline
             [typeof(Spline)] = LuauContextAll,
             [typeof(BezierCurve)] = LuauContextAll,

package/Runtime/Code/LuauAPI/FrameTimingManagerAPI.cs

@@ -3,8 +3,28 @@ using UnityEngine;
 
 [LuauAPI]
 public class FrameTimingManagerAPI : BaseLuaAPIClass {
-    public override Type GetAPIType()
-    {
+    public override Type GetAPIType() {
         return typeof(UnityEngine.FrameTimingManager);
     }
+
+    public override int OverrideStaticMethod(LuauContext context, IntPtr thread, string methodName, int numParameters,
+        ArraySegment<int> parameterDataPODTypes, ArraySegment<IntPtr> parameterDataPtrs,
+        ArraySegment<int> parameterDataSizes) {
+        if (methodName is "GetLatestTimings") {
+            if (numParameters != 1) throw new ArgumentException("GetLatestTimings expects 1 parameter.");
+
+            var numTimings = (uint) LuauCore.GetParameterAsInt(0, numParameters, parameterDataPODTypes, parameterDataPtrs,
+                parameterDataSizes);
+            
+            // Arbitrary limit to avoid huge allocations / requests
+            if (numTimings > 1000) throw new ArgumentException("Requested too many frames (>1000) from GetLatestTimings.");
+            
+            // This function will alloc -- we could look to in the future support a non-alloc setup
+            var timings = new FrameTiming[numTimings];
+            var fetchedResults = FrameTimingManager.GetLatestTimings(numTimings, timings);
+            LuauCore.WriteArrayToThread(thread, timings, typeof(FrameTiming), (int) fetchedResults);
+            return 1;
+        }
+        return -1;
+    }
 }

package/Runtime/Code/Network/StateSystem/AirshipNetworkedStateManager.cs

@@ -76,6 +76,8 @@ namespace Code.Network.StateSystem
         // Non-auth server command tracking
         // Note: we also re-use some of the above command buffer fields
         private SortedList<int, State> serverReceivedStateBuffer = new SortedList<int, State>();
+        // Last observed state from OnTick when running as a non-auth server.
+        private State serverLastObservedState;
 
         // Client processing for input prediction
         private State clientLastConfirmedState;
@@ -224,6 +226,12 @@ namespace Code.Network.StateSystem
             simManager.OnSetSnapshot -= this.OnSetSnapshot;
             simManager.OnCaptureSnapshot -= this.OnCaptureSnapshot;
             simManager.OnLagCompensationCheck -= this.OnLagCompensationCheck;
+            
+            this.OnClientReceiveSnapshot -= ClientReceiveSnapshot;
+            this.OnClientReceiveDiff -= ClientReceiveDiff;
+            this.OnServerReceiveSnapshot -= ServerReceiveSnapshot;
+            this.OnServerReceiveInput -= ServerReceiveInputCommand;
+            this.OnServerReceiveFullSnapshotRequest -= ServerReceiveFullSnapshotRequest;
         }
 
         private void SendNetworkMessages() {
@@ -810,20 +818,30 @@ namespace Code.Network.StateSystem
                 // not a shared timeline.
                 latestState.tick = tick;
                 latestState.time = time;
+                this.serverLastObservedState = latestState;
                 // Use this as the current state for the server
                 this.stateSystem.SetCurrentState(latestState);
                 // Since it's new, update our server interpolation functions
-                this.stateSystem.InterpolateReachedState(latestState); 
-                // Add the state to our history as we would in a authoritative setup
-                this.stateHistory.Set(tick, latestState);
+                this.stateSystem.InterpolateReachedState(latestState);
             }
         }
 
-        public void NonAuthServerCaptureSnapshot(int tick, double time, bool replay)
-        {
-            // Non server auth will accept the client auth as the official possition. No need to capture
-            // the state after the physics tick as the position that was pulled from the buffer in OnTick
-            // was already added to the state timeline as the official position.
+        public void NonAuthServerCaptureSnapshot(int tick, double time, bool replay) {
+            if (this.serverLastObservedState != null) {
+                // Non server auth will accept the client auth as the official position. No need to get
+                // the state after the physics tick as the position that was pulled from the buffer in OnTick
+                // is the official position.
+                var authState = this.serverLastObservedState.Clone() as State;
+                authState.tick = tick;
+                authState.time = time;
+                this.stateHistory.Set(tick, authState);
+            }
+            else {
+                // If we haven't received any auth state from the client, just use what the server has so we have
+                // something to send to observers.
+                var currentState = this.stateSystem.GetCurrentState(this.serverLastProcessedCommandNumber, tick, time);
+                this.stateHistory.Set(tick, currentState);
+            }
         }
 
         public void NonAuthServerSetSnapshot(int tick)
@@ -977,7 +995,7 @@ namespace Code.Network.StateSystem
             if (!this.observerHistory.GetAround(NetworkTime.time, out State prevState, out State nextState))
             {
                 // if (clientTime < this.observerHistory.Keys[0]) return; // Our local time hasn't advanced enough to render the positions reported. No need to log debug
-                // Debug.LogWarning("Frame " + Time.frameCount + " not enough state history for rendering. " + this.observerHistory.Keys.Count +
+                // Debug.LogWarning("Frame " + Time.frameCount + " not enough state history for rendering " + this.name + ". " + this.observerHistory.Keys.Count +
                 //                  " entries. First " + this.observerHistory.Keys[0] + " Last " +
                 //                  this.observerHistory.Keys[^1] + " Target " + NetworkTime.time + " Buffer is: " +  NetworkClient.bufferTime + " Estimated Latency (1 way): " +
                 //                  (NetworkTime.rtt / 2) + " TScale: " + Time.timeScale);
@@ -1177,7 +1195,7 @@ namespace Code.Network.StateSystem
             // Debug.Log("Server received command " + command.commandNumber + " for " + this.gameObject.name);
             // This should only occur if the server is authoritative.
             if (!serverAuth) {
-                Debug.LogWarning($"Received input command from {this.name}, but the networking mode is not server authoritative. Command will be ignored.");
+                // Debug.LogWarning($"Received input command from {this.name}, but the networking mode is not server authoritative. Command will be ignored.");
                 return;
             }
 
@@ -1198,8 +1216,8 @@ namespace Code.Network.StateSystem
             // Reject commands if our buffer is full.
             if (this.serverCommandBuffer.Count > this.serverCommandBufferMaxSize)
             {
-                Debug.LogWarning("Dropping command " + command.commandNumber +
-                                 " for "+ this.name + " due to exceeding command buffer size. First command in buffer is " + this.serverCommandBuffer.Values[0]);
+                // Debug.LogWarning("Dropping command " + command.commandNumber +
+                //                  " for "+ this.name + " due to exceeding command buffer size. First command in buffer is " + this.serverCommandBuffer.Values[0]);
                 return;
             }