gg.easy.airship 0.1.2194 → 0.1.2195

package/Editor/Settings/AirshipSettingsProvider.cs

@@ -1,6 +1,7 @@
 using UnityEngine;
 using UnityEditor;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using Airship.Editor;
 using Code.Bootstrap;
@@ -186,7 +187,9 @@ public class AirshipSettingsProvider : SettingsProvider
 
             if (newTimeout != EditorIntegrationsConfig.instance.luauScriptTimeout) {
                 EditorIntegrationsConfig.instance.luauScriptTimeout = newTimeout;
-                LuauPlugin.SetScriptTimeoutDuration(newTimeout);
+                if (!Debugger.IsAttached) {
+                    LuauPlugin.SetScriptTimeoutDuration(newTimeout);
+                }
             }
             
             if (GUI.changed) {
@@ -252,6 +255,12 @@ public class AirshipSettingsProvider : SettingsProvider
 
     [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
     private static void OnReload() {
-        LuauPlugin.SetScriptTimeoutDuration(EditorIntegrationsConfig.instance.luauScriptTimeout);
+        if (Debugger.IsAttached) {
+            // If the debugger is attached, just feed in a large delay to effectively disable the timeout.
+            // In the future, we could adjust the plugin to take something like -1 to disable it.
+            LuauPlugin.SetScriptTimeoutDuration(86400);
+        } else {
+            LuauPlugin.SetScriptTimeoutDuration(EditorIntegrationsConfig.instance.luauScriptTimeout);
+        }
     }
 }

package/Runtime/Code/AirshipConst.cs

@@ -6,17 +6,18 @@ using UnityEngine.Scripting;
 namespace Code {
     [LuauAPI][Preserve]
     public static class AirshipConst {
-        public const int playerVersion = 21;
+        public const int playerVersion = 23;
         public static readonly IReadOnlyList<string> playerFlags = new string[] {
             "SkipLoading",
             "LagCompCheckIdIsInt",
             "PlatformGearDownloadClassId",
+            "HasTransformMoveDirection", // True for versions that have access to CharacterMovement.TransformMoveDirection
         };
 
 
         /// <summary>
         /// The server will kick clients that have a playerVersion lower than this value.
         /// </summary>
-        public const int minAcceptedPlayerVersionOnServer = 21;
+        public const int minAcceptedPlayerVersionOnServer = 23;
     }
 }

package/Runtime/Code/Bootstrap/ServerBootstrap.cs

@@ -66,6 +66,9 @@ public class ServerBootstrap : MonoBehaviour
     private GameServer gameServer;
 
     [NonSerialized] public bool isServerReady = false;
+    /// <summary>
+    /// Can be fired multiple times.
+    /// </summary>
     public event Action OnStartLoadingGame;
     public event Action OnServerReady;
     public event Action OnStartupConfigReady;
@@ -373,6 +376,7 @@ public class ServerBootstrap : MonoBehaviour
 		var request = UnityWebRequestProxyHelper.ApplyProxySettings(new UnityWebRequest(url));
 		var gameConfigPath = Path.Combine(Application.persistentDataPath, "Games", startupConfig.GameBundleId, "gameConfig.json");
 		request.downloadHandler = new DownloadHandlerFile(gameConfigPath);
+		request.timeout = 7;
 		yield return request.SendWebRequest();
 		if (request.result != UnityWebRequest.Result.Success) {
 			Debug.LogError($"Failed to download gameConfig.json. url={url}, message={request.error}");

package/Runtime/Code/Bundles/SystemRoot.cs

@@ -175,15 +175,25 @@ public class SystemRoot : Singleton<SystemRoot> {
 		var sw = Stopwatch.StartNew();
 
 		// Find packages we should UNLOAD
-		List<string> unloadList = new();
+		HashSet<string> unloadList = new();
 		foreach (var loadedPair in this.loadedAssetBundles) {
 			if (forceUnloadAll) {
 				unloadList.Add(loadedPair.Key);
 				continue;
 			}
+
 			var packageToLoad = packages.Find(p => p.id.ToLower() == loadedPair.Value.airshipPackage.id.ToLower());
+			// Todo: we can not unload asset bundles if there is only a code change.
 			if (packageToLoad == null || packageToLoad.assetVersion != loadedPair.Value.airshipPackage.assetVersion || packageToLoad.codeVersion != loadedPair.Value.airshipPackage.codeVersion) {
 				unloadList.Add(loadedPair.Key);
+
+				// If a package changes, then we need to unload everything because other packages & the game may depend on it.
+				if (packageToLoad != null && packageToLoad.packageType == AirshipPackageType.Package) {
+					foreach (var loaded in loadedAssetBundles) {
+						unloadList.Add(loaded.Key);
+					}
+					break;
+				}
 			}
 		}
 

package/Runtime/Code/CoreUI/Components/AirshipVersionOverlay.cs

@@ -14,6 +14,11 @@ namespace Code.CoreUI.Components {
             }
 #endif
 
+#if UNITY_IOS || UNITY_ANDROID
+            this.versionText.enabled = false;
+            return;
+#endif
+
             var hash = AirshipVersion.GetVersionHash();
             this.versionText.text = Application.version + "-" + hash;
         }

package/Runtime/Code/Luau/LuauCore.cs

@@ -258,11 +258,35 @@ public partial class LuauCore : MonoBehaviour {
     }
 
 #if UNITY_EDITOR
+    private PauseState _editorPauseState = PauseState.Unpaused;
+    private bool _appPaused = false;
+    private bool _pluginPaused = false;
+
+    private void OnApplicationOrEditorPauseChanged() {
+        var shouldPause = _appPaused || _editorPauseState == PauseState.Paused;
+        if (shouldPause == _pluginPaused) return;
+        
+        _pluginPaused = shouldPause;
+        LuauPlugin.SetIsPaused(_pluginPaused);
+    }
+    
     private void OnPauseStateChanged(PauseState state) {
-        LuauPlugin.SetIsPaused(state == PauseState.Paused);
+        // Handle pauses in-editor triggered by the toolbar pause button
+        _editorPauseState = state;
+        OnApplicationOrEditorPauseChanged();
     }
 #endif
 
+    private void OnApplicationPause(bool pauseStatus) {
+        // Handle application pauses (e.g. when application loses focus on iOS)
+#if UNITY_EDITOR
+        _appPaused = pauseStatus;
+        OnApplicationOrEditorPauseChanged();
+#else
+        LuauPlugin.SetIsPaused(pauseStatus);
+#endif
+    }
+
     private void Start() {
         Application.quitting += Quit;
         LuauPlugin.unityMainThreadId = Thread.CurrentThread.ManagedThreadId;

package/Runtime/Code/Luau/LuauCoreCallbacks.cs

@@ -717,6 +717,12 @@ public partial class LuauCore : MonoBehaviour {
     }
     
     private static unsafe void SetFieldValue<T>(object instance, T value, FieldInfo fieldInfo) where T : unmanaged {
+        // If declaring type is not blittable just use reflection
+        if (!UnsafeUtility.IsBlittable(fieldInfo.DeclaringType)) {
+            fieldInfo.SetValue(instance, value);
+            return;
+        }
+
         if (fieldInfo.IsStatic) {
             // Not sure how to do non-alloc static field sets, so just use reflection for now
             // (these are relatively rare anyways)

package/Runtime/Code/Network/Net.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Code.Luau;
+using Code.Zstd;
 using Mirror;
 using UnityEngine;
 using UnityEngine.Scripting;
@@ -75,11 +76,16 @@ namespace Assets.Luau.Network {
 
 	    private void OnBroadcastFromClient(NetworkConnectionToClient conn, NetBroadcast msg) {
 		    // Runs on the server, when the client broadcasts a message
-		    if ((ulong)msg.Blob.DecompressedDataSize >= MaxBytesAtOnce) {
-			    Debug.LogWarning($"Dropping message from client connection {conn.connectionId} due to exceeding max data size.");
+		    try {
+			    if ((ulong)msg.Blob.DecompressedDataSize >= MaxBytesAtOnce) {
+				    Debug.LogWarning(
+					    $"Dropping message from client connection {conn.connectionId} due to exceeding max data size.");
+				    return;
+			    }
+		    } catch (ZstdException) { // TODO: temporary code to discard Zstd exceptions
 			    return;
 		    }
-		    
+
 		    var now = Time.realtimeSinceStartup;
 		    if (!_throttle.TryGetValue(conn.connectionId, out var throttle)) {
 			    // If we don't have a throttle key, that means the client isn't connected anymore and we are processing an old message.

package/Runtime/Code/Network/Simulation/AirshipSimulationManager.cs

@@ -205,10 +205,18 @@ namespace Code.Network.Simulation
 
             // Only resimulate once. Go back to the farthest back time that was requested.
             if (resimBackTo != tick) this.PerformResimulation(resimBackTo);
+
+            // Perform the standard tick behavior
+            OnTick?.Invoke(tick, time, false);
+            // Debug.Log($"Simulate call. Main tick {tick}");
+            Physics.Simulate(Time.fixedDeltaTime);
+            OnCaptureSnapshot?.Invoke(tick, time, false);
             
             // Process any lag compensation requests now that we have completed the ticking and snapshot creation
             // Note: This process is placed after snapshot processing so that changes made to physics (like an impulse)
-            // are processed on the _next_ tick. This is safe because the server never resimulates.
+            // are processed on the _next_ tick. This is safe because the server never resimulates. If lag compensation
+            // is placed before OnTick, lag compensation may overwrite changes that occured during Update() or LateUpdate()
+            // since we roll back to the last snapshot which will have occured before Update() and LateUpdate().
             var processedLagCompensation = false;
             foreach (var entry in this.lagCompensationRequests)
             {
@@ -216,9 +224,9 @@ namespace Code.Network.Simulation
                 {
                     processedLagCompensation = true;
                     // Debug.LogWarning("Server lag compensation rolling back for client " + entry.Key.connectionId);
-                    // commandBufferTime is the additional time we queue commands locally on the server before processing them
-                    var commandBufferTime = (NetworkServer.sendInterval * (entry.Key.bufferTimeMultiplier / 2f));
-                    OnLagCompensationCheck?.Invoke(entry.Key.connectionId, previousTicks[^1], previousTimes[^1], entry.Key.rtt / 2f, entry.Key.bufferTime + commandBufferTime);
+                    // inputBufferTime is the additional time we queue commands locally on the server before processing them
+                    // bufferTime is the observed player buffer size on the client
+                    OnLagCompensationCheck?.Invoke(entry.Key.connectionId, tick, time, entry.Key.rtt / 2f, entry.Key.bufferTime + entry.Key.inputBufferTime);
                     
                     var requests = entry.Value;
                     for (var i = 0; i < requests.Count; i++) {
@@ -236,7 +244,7 @@ namespace Code.Network.Simulation
             {
                 // Debug.LogWarning("Server completed " + this.lagCompensationRequests.Count + " lag compensation requests. Resetting to current tick (" + previousTimes[^1] + ") and finalizing.");
                 // Reset back to the server view of the world at the current time.
-                OnSetSnapshot?.Invoke(previousTicks[^1]);
+                OnSetSnapshot?.Invoke(tick);
                 Physics.SyncTransforms();
                 // Invoke all of the callbacks for modifying physics that should be applied in the next tick.
                 foreach (var entry in this.lagCompensationRequests)
@@ -255,12 +263,6 @@ namespace Code.Network.Simulation
                 }
                 this.lagCompensationRequests.Clear();
             }
-
-            // Perform the standard tick behavior
-            OnTick?.Invoke(tick, time, false);
-            // Debug.Log($"Simulate call. Main tick {tick}");
-            Physics.Simulate(Time.fixedDeltaTime);
-            OnCaptureSnapshot?.Invoke(tick, time, false);
             
             // Add our completed tick time into our history
             this.previousTicks.Add(tick);

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

@@ -68,16 +68,21 @@ namespace Code.Network.StateSystem
         private int serverLastProcessedCommandNumber;
         private int serverPredictedCommandCount = 0;
         private SortedList<int, Input> serverCommandBuffer = new SortedList<int, Input>();
+        // Used to flag if we have exhaused the command buffer and need to wait for it to reach target fill
+        private bool serverCommandBufferWait = true;
+        private int serverNextBufferCheckTick = 0;
 
         private int serverCommandBufferMaxSize = 0;
 
         // How many commands we should generally have in the command buffer
-        private int serverCommandBufferTargetSize = 0;
         private int serverCommandCatchUpRequired = 0;
+        private SimpleMovingAverage serverCommandBufferTargetSize;
+        private SimpleMovingAverage serverCommandBufferAvgSize;
 
         // 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>();
+        private int serverStatesReceivedThisFrame = 0;
         // Last observed state from OnTick when running as a non-auth server.
         private State serverLastObservedState;
 
@@ -203,10 +208,8 @@ namespace Code.Network.StateSystem
             // The client should also stop sending commands after 1 second's worth of unconfirmed commands.
             // This value is refreshed in auth server tick
             this.serverCommandBufferMaxSize = (int)(1f/ Time.fixedUnscaledDeltaTime);
-            // must convert send interval to scaled time because fixedDeltaTime is scaled
-            // This value is refreshed in auth server tick
-            this.serverCommandBufferTargetSize =Math.Min(this.serverCommandBufferMaxSize,
-                (int)Math.Ceiling(NetworkServer.sendInterval * bufferTimeMultiplier / Time.fixedUnscaledDeltaTime));
+            this.serverCommandBufferTargetSize = new SimpleMovingAverage(NetworkServer.sendRate);
+            this.serverCommandBufferAvgSize = new SimpleMovingAverage(NetworkServer.sendRate);
 
             this.inputHistory = new(1);
             this.stateHistory = new(1);
@@ -346,26 +349,44 @@ namespace Code.Network.StateSystem
                 this.Interpolate();
             }
 
-            // We check this in Update so that we have finished processing all required fixedUpdates before checking
-            // if we are behind. Next time fixed update runs, we will process the additional amount we need to catch up.
-            if (isServer && serverAuth) {
-                if (serverCommandBuffer.Count > serverCommandBufferTargetSize) {
-                    serverCommandCatchUpRequired = serverCommandBuffer.Count - serverCommandBufferTargetSize;
-                    // print($"Command catchup required for {this.name}: {serverCommandCatchUpRequired}");
-                }
-                else {
-                    serverCommandCatchUpRequired = 0;
-                }
+            // Server states are sent one at a time instead of as a group, but we track how many we receive per frame so we can adjust our
+            // target buffer size if the client is slow. This is similar to what we do for received input groups.
+            if (serverStatesReceivedThisFrame != 0) {
+                // var jitterTime = Math.Sqrt(this.connectionToClient.rttVariance) / Time.fixedUnscaledDeltaTime;
+                this.serverCommandBufferTargetSize.Add(serverStatesReceivedThisFrame);
+                serverStatesReceivedThisFrame = 0;
             }
-            
-            // Same as above, but for client authoritative systems
-            if (isServer && !serverAuth) {
-                if (serverReceivedStateBuffer.Count > serverCommandBufferTargetSize) {
-                    serverCommandCatchUpRequired = serverReceivedStateBuffer.Count - serverCommandBufferTargetSize;
-                    // print($"State catchup required for {this.name}: {serverCommandCatchUpRequired}");
+
+            if (AirshipSimulationManager.Instance.tick > this.serverNextBufferCheckTick) {
+                this.serverNextBufferCheckTick = AirshipSimulationManager.Instance.tick + NetworkServer.sendRate;
+                
+                // We check this in Update so that we have finished processing all required fixedUpdates before checking
+                // if we are behind. Next time fixed update runs, we will process the additional amount we need to catch up.
+                if (isServer && serverAuth) {
+                    if (serverCommandBuffer.Count > this.serverCommandBufferTargetSize.Value && Math.Floor(this.serverCommandBufferAvgSize.Value) > Math.Ceiling(this.serverCommandBufferTargetSize.Value)) {
+                        serverCommandCatchUpRequired = (int) Math.Round(Math.Floor(this.serverCommandBufferAvgSize.Value) - Math.Ceiling(this.serverCommandBufferTargetSize.Value));
+                        // print($"Command catchup required for {this.name}: {serverCommandCatchUpRequired}. {serverCommandBuffer.Count} in buffer {(int) Math.Round(this.serverCommandBufferTargetSize.Value)} target");
+                    } else if (this.serverCommandBufferAvgSize.Value * 2 < this.serverCommandBufferTargetSize.Value) {
+                        // This is a heuristic for if we are likely to have to predict more commands soon. Low buffer size means
+                        // we have less of a chance to recover dropped packets. It's probably better for us to wait for additional
+                        // inputs before we continue processing.
+                        // print($"Command delay required for {this.name}: {serverCommandBuffer.Count} in buffer, {this.serverCommandBufferAvgSize.Value} ema, {this.serverCommandBufferTargetSize.Value} target");
+                        this.serverCommandBufferWait = true;
+                    } else {
+                        serverCommandCatchUpRequired = 0;
+                    }
                 }
-                else {
-                    serverCommandCatchUpRequired = 0;
+                
+                // Same as above, but for client authoritative systems
+                if (isServer && !serverAuth) {
+                    if (serverReceivedStateBuffer.Count > this.serverCommandBufferTargetSize.Value && this.serverCommandBufferAvgSize.Value > this.serverCommandBufferTargetSize.Value) {
+                        serverCommandCatchUpRequired = (int) Math.Round(this.serverCommandBufferAvgSize.Value - this.serverCommandBufferTargetSize.Value);
+                        // print($"State catchup required for {this.name}: {serverCommandCatchUpRequired}");
+                    } else if (this.serverCommandBufferAvgSize.Value * 2 < this.serverCommandBufferTargetSize.Value) {
+                        this.serverCommandBufferWait = true;
+                    } else {
+                        serverCommandCatchUpRequired = 0;
+                    }
                 }
             }
         }
@@ -523,7 +544,7 @@ namespace Code.Network.StateSystem
 
         #region Authoritative Server Functions
 
-        public void AuthServerTick(int tick, double time, bool replay)
+        public void AuthServerTick(int tick, double time, bool replay) 
         {
             if (replay)
             {
@@ -544,30 +565,20 @@ namespace Code.Network.StateSystem
             
             // We must recalculate target size if the timescale has changed.
             this.serverCommandBufferMaxSize = (int)( 1 / Time.fixedUnscaledDeltaTime);
-            this.serverCommandBufferTargetSize =
-                Math.Min(this.serverCommandBufferMaxSize,
-                    (int)Math.Ceiling(NetworkServer.sendInterval * this.bufferTimeMultiplier / Time.fixedUnscaledDeltaTime));
             // Optimal max is when we will start processing extra commands.
-            // print($"{this.name} has {serverCommandBuffer.Count} entries in the buffer. Target is {this.serverCommandBufferTargetSize}");
-
-            // If we don't allow command catchup, drop commands to get to the target buffer size.
-            if (this.maxServerCommandCatchup == 0)
-            {
-                var dropCount = 0;
-                
-                while (serverCommandCatchUpRequired > 0 && dropCount < this.serverCommandBufferTargetSize)
-                {
-                    this.serverCommandBuffer.RemoveAt(0);
-                    dropCount++;
-                }
-                // print("Dropped " + dropCount + " command(s) from " + this.gameObject.name + " due to exceeding command buffer size.");
-            }
+            this.serverCommandBufferAvgSize.Add(this.serverCommandBuffer.Count);
+            this.connectionToClient.inputBufferTime = this.serverCommandBufferAvgSize.Value * Time.fixedUnscaledDeltaTime;
+            // print($"{this.name} has {serverCommandBuffer.Count} entries in the buffer. Target is {this.serverCommandBufferTargetSize.Value} Current Avg Fill: {this.serverCommandBufferAvgSize.Value}");
 
             // Delay processing until we have at least one send interval worth of commands to process.
-            if (this.serverCommandBuffer.Count == 0 || this.serverCommandBuffer.Count < Math.Ceiling(NetworkClient.sendInterval / Time.fixedUnscaledDeltaTime)) {
+            if (this.serverCommandBufferWait && this.serverCommandBuffer.Count < this.serverCommandBufferTargetSize.Value || this.serverCommandBuffer.Count == 0) {
                 // Debug.Log($"Waiting for additional commands for {this.name}. There are {this.serverCommandBuffer.Count} commands in the buffer.");
                 this.stateSystem.Tick(null, tick, time, false);
                 return;
+            } else {
+                // Start processing commands from the beginning of the buffer after waiting
+                this.serverLastProcessedCommandNumber = this.serverCommandBuffer.Values[0].commandNumber - 1;
+                this.serverCommandBufferWait = false;
             }
             
             var commandsProcessed = 0;
@@ -575,69 +586,62 @@ namespace Code.Network.StateSystem
                 commandsProcessed++;
 
                 // Attempt to get a new command out of the buffer.
-                var commandEntry = this.serverCommandBuffer.Count > 0 ? this.serverCommandBuffer.Values[0] : null;
-
-                // If we have a new command to process
-                if (commandEntry != null) {
+                var canPredictCommand = this.serverPredictedCommandCount < Math.Ceiling(
+                    this.maxServerCommandPrediction *
+                    (NetworkServer.sendInterval /
+                     Time.fixedUnscaledDeltaTime));
+                var expectedNextCommandNumber = this.serverLastProcessedCommandNumber + 1;
+                Input command = this.serverCommandBuffer.Count > 0 ? this.serverCommandBuffer.Values[0] : null;
+
+                // We have a valid command that is in sequence, or we reached our max predicted fill. Remove the next
+                // valid command from the buffer and process it.
+                if (command != null && (command.commandNumber == expectedNextCommandNumber || !canPredictCommand)) {
                     // Get the command to process
-                    var command = this.serverCommandBuffer.Values[0];
-                    // Get the expected next command number
-                    var expectedNextCommandNumber = this.serverLastProcessedCommandNumber + 1;
-
-                    // Check if that command is in sequence. If we have a gap of commands, we will fill it with the last
-                    // processed command up to the maxServerCommandPrediction size.
-                    // this.maxServerCommandPrediction * (1f / this.clientInputRate / Time.fixedDeltaTime)) is the number of
-                    // commands contained in a single input message
-                    if (this.lastProcessedCommand != null && command.commandNumber != expectedNextCommandNumber &&
-                        this.serverPredictedCommandCount < Math.Ceiling(this.maxServerCommandPrediction *
-                                                                        (NetworkServer.sendInterval /
-                                                                         Time.fixedUnscaledDeltaTime))) {
-                        // Debug.LogWarning("Missing command " + expectedNextCommandNumber +
-                        //                  " in the command buffer for " + this.name + ". Next command was: " +
-                        //                  command.commandNumber +
-                        //                  ". Predicted " +
-                        //                  (this.serverPredictedCommandCount + 1) + " command(s) so far.");
-                        this.serverLastProcessedCommandNumber = expectedNextCommandNumber;
-                        command = this.lastProcessedCommand;
-                        command.commandNumber = expectedNextCommandNumber;
-                        this.serverPredictedCommandCount++;
-                    }
-                    // We have a valid command that is in sequence, or we reached our max fill. Remove the next
-                    // valid command from the buffer and process it.
-                    else {
-                        // Debug.Log("Ticking next command in sequence: " + command.commandNumber);
-                        this.serverPredictedCommandCount = 0;
-                        this.serverCommandBuffer.RemoveAt(0);
-                        this.lastProcessedCommand = command;
-                        this.serverLastProcessedCommandNumber = command.commandNumber;
-                    }
-
-                    // tick command
-                    command.tick = tick; // Correct tick to local timeline for ticking on the server.
-                    this.stateSystem.Tick(command, tick, time, false);
+                    command = this.serverCommandBuffer.Values[0];
+                    this.serverCommandBuffer.RemoveAt(0);
+                    
+                    this.serverPredictedCommandCount = 0;
+                    this.lastProcessedCommand = command;
+                    this.serverLastProcessedCommandNumber = command.commandNumber; 
+                // We have an out of order command, or no command and we can predict the next command in sequence
+                } else if ((command != null && command.commandNumber != expectedNextCommandNumber ||
+                            this.serverCommandBuffer.Count == 0) && this.lastProcessedCommand != null && canPredictCommand) {
+                    command = this.lastProcessedCommand;
+                    
+                    this.serverLastProcessedCommandNumber = expectedNextCommandNumber;
+                    
+                    command.commandNumber = expectedNextCommandNumber;
+                    this.serverPredictedCommandCount++;
+                    // print("Reprocessing last command");
                 }
+                // we processed a command that never reached the server and we can't fill it or move on to a new command in the buffer.
+                // this means we've completely run out of inputs and we should wait for more.
                 else {
-                    // Ensure that we always tick the system even if there's no command to process.
-                    // Debug.LogWarning($"No commands left for {this.name}. Last command processed: " +
-                    //                  this.lastProcessedCommand);
-                    this.stateSystem.Tick(null, tick, time, false);
-                    // we processed a command that never reached the server, advance so the associated
-                    // command's tick result will be used to match up with state. The command that should have been used
-                    // here will be ignored when it arrives (if it ever does)
-                    this.serverLastProcessedCommandNumber += 1;
+                    // print("No command available for ticking");
+                    this.serverPredictedCommandCount = 0;
+                    this.serverCommandBufferWait = true;
+                }
+                
+                // tick command
+                // Ensure that we always tick the system even if there's no command to process.
+                if (command != null) {
+                    command.tick = tick; // Correct tick to local timeline for ticking on the server.
+                }
+
+                // We cannot tick more than once per FixedUpdate with our current implementation of character movement. A physics.simulate
+                // is required to apply the calculated velocities and move the character. We could work around this by pausing all other
+                // characters and then simulating forward once, but it would add a lot of complexity/processing power requirements.
+                // Instead we just drop the command and don't process it at all.
+                if (commandsProcessed == 1) {
+                    this.stateSystem.Tick(command, tick, time, false);
                 }
 
                 if (commandsProcessed > 1) {
                     serverCommandCatchUpRequired--;
+                    // print($"Processed additional command for catchup. {serverCommandCatchUpRequired} more required.");
                 }
                 
-            } while (commandsProcessed < 1 + this.maxServerCommandCatchup && serverCommandCatchUpRequired > 0);
-            // We add 1 to maxServerCommandCatchup because we always want to process at least 1 command per fixed update.
-
-            // if (commandsProcessed > 1)
-            // {
-            //     print("Processed " + commandsProcessed + " commands for " + this.gameObject.name + $". There are now {this.serverCommandBuffer.Count} commands in the buffer.");
-            // }
+            } while (commandsProcessed < 1 + (this.serverCommandBufferTargetSize.Value / 2) && serverCommandCatchUpRequired > 0);
         }
 
         public void AuthServerCaptureSnapshot(int tick, double time, bool replay)
@@ -751,17 +755,18 @@ namespace Code.Network.StateSystem
             }
             
             this.serverCommandBufferMaxSize = (int)( 1 / Time.fixedUnscaledDeltaTime);
-            this.serverCommandBufferTargetSize =
-                Math.Min(this.serverCommandBufferMaxSize,
-                    (int)Math.Ceiling(NetworkServer.sendInterval * bufferTimeMultiplier / Time.fixedUnscaledDeltaTime));
-            // print($"{this.name} {serverReceivedStateBuffer.Count}/{serverCommandBufferMaxSize} target {serverCommandBufferTargetSize}");
+            this.serverCommandBufferAvgSize.Add(this.serverReceivedStateBuffer.Count);
+            this.connectionToClient.inputBufferTime = this.serverCommandBufferAvgSize.Value * Time.fixedUnscaledDeltaTime;
+            // print($"{this.name} {serverReceivedStateBuffer.Count}/{serverCommandBufferMaxSize} target {serverCommandBufferTargetSize.Value} avg {serverCommandBufferAvgSize.Value}");
 
             // Delay processing until we have at least one send interval worth of commands to process.
-            if (this.serverReceivedStateBuffer.Count == 0 || this.serverReceivedStateBuffer.Count < (int)Math.Ceiling(NetworkClient.sendInterval / Time.fixedUnscaledDeltaTime)) {
+            if (this.serverCommandBufferWait && this.serverReceivedStateBuffer.Count < this.serverCommandBufferTargetSize.Value || this.serverReceivedStateBuffer.Count == 0) {
                 // Debug.Log($"Waiting for additional states for {this.name}. There are {this.serverReceivedStateBuffer.Count} states in the buffer.");
                 // no operation since there is no new state for us to use. Client authority means we use whatever the client sends us, even if that means
                 // seeing irregular physics movement.
                 return;
+            } else {
+                this.serverCommandBufferWait = false;
             }
             
             // Process the buffer of states that we've gotten from the authoritative client
@@ -781,14 +786,14 @@ namespace Code.Network.StateSystem
                     : null;
 
                 // If we have a new state to process, update our last processed command and then remove it.
+                // TODO: We could be a little more clever with gaps in received state. We could interpolate between last and next if one exists
                 if (latestState != null) {
                     // mark this as our latest state and remove it. We will do the real processing on the final
                     // state retrieved during this loop later.
                     this.serverLastProcessedCommandNumber = latestState.lastProcessedCommand;
                     this.serverReceivedStateBuffer.RemoveAt(0);
-                }
-                else {
-                    this.serverLastProcessedCommandNumber += 1;
+                } else {
+                    this.serverCommandBufferWait = true;
                 }
                 
                 if (statesProcessed > 1) {
@@ -797,7 +802,7 @@ namespace Code.Network.StateSystem
 
                 // If we don't have a new state to process, that's ok. It just means that the client hasn't sent us
                 // their updated state yet.
-            } while (statesProcessed < 1 + this.maxServerCommandCatchup && serverCommandCatchUpRequired > 0);
+            } while (statesProcessed < 1 + (this.serverCommandBufferTargetSize.Value / 2) && serverCommandCatchUpRequired > 0);
 
             // Commit the last processed snapshot to our state history
             if (latestState != null)
@@ -1103,6 +1108,7 @@ namespace Code.Network.StateSystem
             // interpolate over unscaledTime accurately. The remote timestamp is what the server was rendering
             // at that time, which may be the same tick twice (especially with modified timescales)
             if (!isOwned) {
+                // print($"Frame {Time.frameCount} received state for {state.time}");
                 this.observerHistory.Set(state.time, state);
             }
              
@@ -1220,8 +1226,10 @@ namespace Code.Network.StateSystem
             this.serverCommandBuffer.Add(command.commandNumber, command);
         }
 
-        private void ServerReceiveInputCommand(Input[] commands)
-        {
+        private void ServerReceiveInputCommand(Input[] commands) {
+            // var jitterTime = Math.Sqrt(this.connectionToClient.rttVariance) / Time.fixedUnscaledDeltaTime;
+            serverCommandBufferTargetSize.Add(commands.Length);
+            // print($"{commands.Length} + {jitterTime}");
             foreach (var command in commands)
             {
                 ProcessClientInputOnServer(command);
@@ -1229,8 +1237,9 @@ namespace Code.Network.StateSystem
          
         }
 
-        private void ServerReceiveSnapshot(State snapshot)
-        {
+        private void ServerReceiveSnapshot(State snapshot) {
+            serverStatesReceivedThisFrame++;
+            
             // Debug.Log("Server receive snapshot" + snapshot.lastProcessedCommand + " data: " + snapshot.ToString());
             // This should only occur if the server is not authoritative.
             if (serverAuth) return;

package/Runtime/Code/Player/Character/MovementSystems/Character/Structures/CharacterSnapshotData.cs

@@ -258,7 +258,7 @@ namespace Code.Player.Character.MovementSystems.Character
             // we could not do this optimization since there would be no way to know where the next packet starts.
             if (fullCustomData && other.customData != null) { // If we should send the full new data, send it, but only if we actually have data. null custom data shouldn't be sent.
                 writer.WriteBytes(other.customData.Data, 0, other.customData.Data.Length);
-            } else {
+            } else if (customDataDiff != null) {
                 writer.WriteBytes(customDataDiff, 0, customDataDiff.Length);
             }
             

package/Runtime/Code/Quality/QualityManager.cs

@@ -101,7 +101,7 @@ namespace Code.Quality {
         private int GetRealTargetFPS() {
             var targetFrameRate = Application.targetFrameRate;
             if (targetFrameRate < 0 || targetFrameRate > Screen.currentResolution.refreshRateRatio.value)
-                targetFrameRate = (int) (1.0 / Screen.currentResolution.refreshRateRatio.value);
+                targetFrameRate = (int) Screen.currentResolution.refreshRateRatio.value;
             return targetFrameRate;
         }
 
@@ -115,16 +115,16 @@ namespace Code.Quality {
             var avgFrameTimings = GetRecentAverageFrameTimings();
             
             // If our 5% is lower than 80% of target we should drop quality
-            if (currentFivePercent < 0.80 * targetFrameRate) {
+            if (currentFivePercent < 0.80 * Math.Min(targetFrameRate, 144)) {
                 frameHealth = FrameHealth.Unhealthy;
             }
 
             // print($"[Quality Check] 5%: {currentFivePercent}, 0.5%: {pointFivePercent}, health: {frameHealth}");
 
             if (this.tracer != null) {
-                this.tracer.SetMeasurement("fps_5_percent", currentFivePercent);
-                this.tracer.SetMeasurement("fps_0.5_percent", pointFivePercent);
-                this.tracer.SetMeasurement("target_fps", targetFrameRate);
+                this.tracer.SetMeasurement("spf_5_percent", 1f / Math.Max(0.01, currentFivePercent));
+                this.tracer.SetMeasurement("spf_0.5_percent", 1f / Math.Max(0.01, pointFivePercent));
+                this.tracer.SetMeasurement("target_spf", 1f / Math.Max(0.01, targetFrameRate));
                 this.tracer.SetMeasurement("cpu_main_avg", avgFrameTimings.cpuMainAvg);
                 this.tracer.SetMeasurement("cpu_render_avg", avgFrameTimings.cpuRenderAvg);
                 this.tracer.SetMeasurement("gpu_avg", avgFrameTimings.gpuAvg);

package/Runtime/Code/UI/Canvas/CanvasUIEventInterceptor.cs

@@ -6,35 +6,35 @@ using UnityEngine.EventSystems;
 public class CanvasUIEventInterceptor : MonoBehaviour {
 
 	/** Generic pointer event. */
-	public event Action<object, object, object> PointerEvent;
+	public event Action<int, int, int> PointerEvent;
 
 	/** Generic hover event. */
-	public event Action<object, object, object> HoverEvent;
+	public event Action<int, int, PointerEventData> HoverEvent;
 	
 	/** Params: InstanceId */
-	public event Action<object> SubmitEvent;
+	public event Action<int> SubmitEvent;
 
 	/** Params: InstanceId, string value */
-	public event Action<object, object> InputFieldSubmitEvent;
+	public event Action<int, string> InputFieldSubmitEvent;
 	
 	/** Params: InstanceId */
-	public event Action<object> SelectEvent;
+	public event Action<int> SelectEvent;
 	
 	/** Params: InstanceId */
-	public event Action<object> DeselectEvent;
+	public event Action<int> DeselectEvent;
 
-	public event Action<object> ClickEvent;
+	public event Action<int> ClickEvent;
 	
-	public event Action<object, object> ValueChangeEvent;
+	public event Action<int, float> ValueChangeEvent;
 
-	public event Action<object, object> ToggleValueChangeEvent;
+	public event Action<int, bool> ToggleValueChangeEvent;
 
-	public event Action<object, object> BeginDragEvent;
-	public event Action<object, object> EndDragEvent;
-	public event Action<object, object> DropEvent;
-	public event Action<object, object> DragEvent;
+	public event Action<int, PointerEventData> BeginDragEvent;
+	public event Action<int, PointerEventData> EndDragEvent;
+	public event Action<int, PointerEventData> DropEvent;
+	public event Action<int, PointerEventData> DragEvent;
 
-	public event Action<object, object> ScreenSizeChangeEvent;
+	public event Action<int, int> ScreenSizeChangeEvent;
 
 	/** Fires a pointer event for instance that corresponds to `instanceId`. Includes pointer button and direction. (up or down) */
 	public void FirePointerEvent(int instanceId, int direction, int button) {

package/Runtime/Code/VoxelWorld/VoxelBlockDefinition.cs

@@ -3,6 +3,7 @@ using UnityEngine;
 using UnityEditor;
 #endif
 
+[LuauAPI]
 [CreateAssetMenu(fileName = "VoxelBlockDefinition", menuName = "Airship/VoxelWorld/VoxelBlockDefinition")]
 public class VoxelBlockDefinition : ScriptableObject {
 

package/Runtime/Code/VoxelWorld/VoxelBlockDefinitionList.cs

@@ -9,6 +9,7 @@ using System.IO;
 using UnityEditor;
 #endif
 
+[LuauAPI]
 [CreateAssetMenu(fileName = "VoxelBlockDefinitionList", menuName = "Airship/VoxelWorld/VoxelBlockDefinitionList", order = 2)]
 public class VoxelBlockDefinitionList : ScriptableObject {
 

package/Runtime/Code/VoxelWorld/VoxelBlocks.cs

@@ -201,6 +201,7 @@ public class VoxelBlocks : MonoBehaviour {
         QuarterBlockTypes.DM,  //UN
     };
 
+    [LuauAPI]
     public class LodSet {
         public VoxelMeshCopy lod0;
         public VoxelMeshCopy lod1;
@@ -208,6 +209,7 @@ public class VoxelBlocks : MonoBehaviour {
     }
 
     //The runtime version of VoxelBlockDefinition, after everything is loaded in
+    [LuauAPI]
     public class BlockDefinition {
         /// <summary>
         /// The generated world id for this block

package/Runtime/Code/VoxelWorld/VoxelMeshProcessor.cs

@@ -1193,6 +1193,9 @@ namespace VoxelWorldStuff {
                 handledBlockFaces[i] = new HashSet<int>();
             }
 
+            // List used in internals of face expansion functions to avoid repeated non-main-thread allocations
+            var expandTempList = new List<int>();
+
             for (int x = 0; x < VoxelWorld.chunkSize; x++) {
                 for (int y = 0; y < VoxelWorld.chunkSize; y++) {
                     for (int z = 0; z < VoxelWorld.chunkSize; z++) {
@@ -1368,15 +1371,17 @@ namespace VoxelWorldStuff {
                             var zScale = 1;
                             // Only expand face in planes perpendicular to normal
                             var flooredNorm = Vector3Int.FloorToInt(faceNormal);
+                            Profiler.BeginSample("MeshFace");
                             if (Vector3.Dot(faceNormal, Vector3.right) == 0)
                                 while (ExpandFaceX(localVoxel, flooredNorm, faceIndex, blockIndex, damage,
                                            handledBlockFaces, xScale)) xScale++;
                             if (Vector3.Dot(faceNormal, Vector3.forward) == 0)
                                 while (ExpandFaceZ(localVoxel, flooredNorm, faceIndex, blockIndex, damage,
-                                           handledBlockFaces, new Vector3(xScale, yScale, zScale), zScale)) zScale++;
+                                           handledBlockFaces, expandTempList, new Vector3(xScale, yScale, zScale), zScale)) zScale++;
                             if (Vector3.Dot(faceNormal, Vector3.up) == 0)
                                 while (ExpandFaceY(localVoxel, flooredNorm, faceIndex, blockIndex, damage,
-                                           handledBlockFaces, new Vector3(xScale, yScale, zScale), yScale)) yScale++;
+                                           handledBlockFaces, expandTempList, new Vector3(xScale, yScale, zScale), yScale)) yScale++;
+                            Profiler.EndSample();
 
                             Rect uvRect = block.GetUvsForFace(faceIndex);
 
@@ -1545,10 +1550,10 @@ namespace VoxelWorldStuff {
             return true;
         }
         
-        private bool ExpandFaceY(Vector3Int localVoxel, Vector3Int normal, int faceIndex, ushort blockIndex, float damage, HashSet<int>[] handledBlockFaces, Vector3 size, int y) {
+        private bool ExpandFaceY(Vector3Int localVoxel, Vector3Int normal, int faceIndex, ushort blockIndex, float damage, HashSet<int>[] handledBlockFaces, List<int> expandChecks, Vector3 size, int y) {
             if (y + localVoxel.y >= chunkSize) return false;
 
-            var expandChecks = new List<int>();
+            expandChecks.Clear();
             for (var x = 0; x < size.x; x++) {
                 for (var z = 0; z < size.z; z++) {
                     var expandCheck = (ushort) ((localVoxel.x + x) + (localVoxel.y + y) * paddedChunkSize +
@@ -1579,10 +1584,10 @@ namespace VoxelWorldStuff {
             return true;
         }
         
-        private bool ExpandFaceZ(Vector3Int localVoxel, Vector3Int normal, int faceIndex, ushort blockIndex, float damage, HashSet<int>[] handledBlockFaces, Vector3 size, int z) {
+        private bool ExpandFaceZ(Vector3Int localVoxel, Vector3Int normal, int faceIndex, ushort blockIndex, float damage, HashSet<int>[] handledBlockFaces, List<int> expandChecks, Vector3 size, int z) {
             if (z + localVoxel.z >= chunkSize) return false;
 
-            var expandChecks = new List<int>();
+            expandChecks.Clear();
             for (var x = 0; x < size.x; x++) {
                 for (var y = 0; y < size.y; y++) {
                     var expandCheck = (ushort) ((localVoxel.x + x) + (localVoxel.y + y) * paddedChunkSize +

package/Runtime/Code/VoxelWorld/VoxelWorld.cs

@@ -1318,6 +1318,9 @@ public partial class VoxelWorld : MonoBehaviour {
                 dist += 250f / chunkSize;
             }
         }
+        
+        // Super prioritize priority updates
+        // if (chunk.GetPriorityUpdate()) dist -= 1000;
 
         return dist;
     }

package/Runtime/Plugins/Mac/LuauPlugin.bundle/Contents/Info.plist

@@ -3,7 +3,7 @@
 <plist version="1.0">
 <dict>
 	<key>BuildMachineOSBuild</key>
-	<string>24G231</string>
+	<string>24G325</string>
 	<key>CFBundleDevelopmentRegion</key>
 	<string>en</string>
 	<key>CFBundleExecutable</key>
@@ -27,19 +27,19 @@
 	<key>DTCompiler</key>
 	<string>com.apple.compilers.llvm.clang.1_0</string>
 	<key>DTPlatformBuild</key>
-	<string>25A352</string>
+	<string>25B74</string>
 	<key>DTPlatformName</key>
 	<string>macosx</string>
 	<key>DTPlatformVersion</key>
-	<string>26.0</string>
+	<string>26.1</string>
 	<key>DTSDKBuild</key>
-	<string>25A352</string>
+	<string>25B74</string>
 	<key>DTSDKName</key>
-	<string>macosx26.0</string>
+	<string>macosx26.1</string>
 	<key>DTXcode</key>
-	<string>2601</string>
+	<string>2611</string>
 	<key>DTXcodeBuild</key>
-	<string>17A400</string>
+	<string>17B100</string>
 	<key>LSMinimumSystemVersion</key>
 	<string>13.0</string>
 	<key>NSHumanReadableCopyright</key>

package/Runtime/Scenes/CoreScene.unity

@@ -3426,7 +3426,7 @@ MonoBehaviour:
   m_Name: 
   m_EditorClassIdentifier: 
   wrap: {fileID: 6429755776191137293}
-  latency: 166
+  latency: 100
   jitter: 0
   jitterSpeed: 1
   unreliableLoss: 0

package/ThirdParty/Mirror/Core/NetworkClient.cs

@@ -1587,12 +1587,18 @@ namespace Mirror
         // (we add this to the UnityEngine in NetworkLoop)
         internal static void NetworkEarlyUpdate()
         {
+            // EASYMOD: Moved above transport early update. UpdateTimeInterpolation() updates NetworkTime.time, so
+            // you would have NetworkTime.time one frame behind when processing snapshot updates compared to when FixedUpdate()/Update() runs.
+            // This throws off the localTimeline clock drift adjustment as it's operating on the previous NetworkTime.time when adjusting
+            // based on the received time snapshot. This causes you to jump ahead of the expected time when the timeline advances.
+            // If you had a low framerate, you may end up eating up all of the buffer time on this jump and even go ahead of the predicted server time, causing stuttering
+            // for observed objects that depend on NetworkTime.time being buffered to give extra time for packets to arrive.
+            // time snapshot interpolation
+            UpdateTimeInterpolation();
+            
             // process all incoming messages first before updating the world
             if (Transport.active != null)
                 Transport.active.ClientEarlyUpdate();
-
-            // time snapshot interpolation
-            UpdateTimeInterpolation();
         }
 
         // NetworkLateUpdate called after any Update/FixedUpdate/LateUpdate

package/ThirdParty/Mirror/Core/NetworkClient_TimeInterpolation.cs

@@ -142,7 +142,7 @@ namespace Mirror
                 snapshotSettings.catchupPositiveThreshold,
                 ref deliveryTimeEma);
 
-            // Debug.Log($"inserted TimeSnapshot remote={snap.remoteTime:F2} local={snap.localTime:F2} total={snapshots.Count}");
+            // Debug.Log($"inserted TimeSnapshot frame={Time.frameCount} remote={snap.remoteTime:F2} local={snap.localTime:F2} pred={localTimeline} diff={localTimeline - snap.remoteTime} total={snapshots.Count}");
         }
 
         // call this from early update, so the timeline is safe to use in update

package/ThirdParty/Mirror/Core/NetworkConnectionToClient.cs

@@ -37,6 +37,9 @@ namespace Mirror
         public double bufferTimeMultiplier = 2;
         public double bufferTime => NetworkServer.sendInterval * bufferTimeMultiplier;
 
+        // EASYMOD: This is a hack for us to be able to adjust lag comp requests per connection to account for the character input buffer. This is not used by anything in mirror.
+        public double inputBufferTime = 0;
+
         // <clienttime, snaps>
         readonly SortedList<double, TimeSnapshot> snapshots = new SortedList<double, TimeSnapshot>();
 
@@ -50,6 +53,9 @@ namespace Mirror
 
         /// <summary>Round trip time (in seconds) that it takes a message to go server->client->server.</summary>
         public double rtt => _rtt.Value;
+        /// <Summary>Round trip time variance aka jitter, in seconds.</Summary>
+        // "rttVariance" instead of "rttVar" for consistency with older versions.
+        public double rttVariance => _rtt.Variance;
 
         public NetworkConnectionToClient(int networkConnectionId, string clientAddress = "localhost")
             : base(networkConnectionId)

package/ThirdParty/Mirror/Core/NetworkServer.cs

@@ -2016,13 +2016,15 @@ namespace Mirror
                 fullUpdateDuration.Begin();
             }
 
-            // process all incoming messages first before updating the world
-            if (Transport.active != null)
-                Transport.active.ServerEarlyUpdate();
-
+            // EASYMOD: Moved ahead of transport early update for the same reason as
+            // described in NetworkClient.NetworkEarlyUpdate()
             // step each connection's local time interpolation in early update.
             foreach (NetworkConnectionToClient connection in connections.Values)
                 connection.UpdateTimeInterpolation();
+            
+            // process all incoming messages first before updating the world
+            if (Transport.active != null)
+                Transport.active.ServerEarlyUpdate();
 
             if (active) earlyUpdateDuration.End();
         }

package/ThirdParty/Mirror/Core/Tools/SimpleMovingAverage.cs

@@ -0,0 +1,42 @@
+// Simple Moving Average (SMA) implementation
+// Keeps a sliding window of the last n entries and drops older data
+// https://en.wikipedia.org/wiki/Moving_average#Simple_moving_average
+using System;
+using System.Collections.Generic;
+
+namespace Mirror
+{
+    public class SimpleMovingAverage
+    {
+        readonly int maxSamples;
+        readonly Queue<double> samples;
+        double sum;
+
+        public double Value => samples.Count > 0 ? sum / samples.Count : 0;
+        public int Count => samples.Count;
+
+        public SimpleMovingAverage(int n)
+        {
+            maxSamples = n;
+            samples = new Queue<double>(n + 1);
+            sum = 0;
+        }
+
+        public void Add(double newValue)
+        {
+            samples.Enqueue(newValue);
+            sum += newValue;
+
+            if (samples.Count > maxSamples)
+            {
+                sum -= samples.Dequeue();
+            }
+        }
+
+        public void Reset()
+        {
+            samples.Clear();
+            sum = 0;
+        }
+    }
+}

package/ThirdParty/Mirror/Core/Tools/SimpleMovingAverage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6f49e008a37547c2997bc58b2ec75034
+timeCreated: 1764715854

package/URP/AirshipURPAsset.asset

@@ -19,7 +19,7 @@ MonoBehaviour:
   m_RendererDataList:
   - {fileID: 11400000, guid: fd1b4d11df5dd4a378ed9d33fdae2dbf, type: 2}
   m_DefaultRendererIndex: 0
-  m_RequireDepthTexture: 0
+  m_RequireDepthTexture: 1
   m_RequireOpaqueTexture: 0
   m_OpaqueDownsampling: 1
   m_SupportsTerrainHoles: 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gg.easy.airship",
-  "version": "0.1.2194",
+  "version": "0.1.2195",
   "displayName": "Airship",
   "unity": "2021.3",
   "unityRelease": "12f1",