gg.easy.airship 0.1.2148 → 0.1.2149

package/Editor/Easy.Airship.Editor.asmdef

@@ -66,7 +66,8 @@
         "GUID:6e5063adab271564ba0098a06a8cebda",
         "GUID:3b5390adca4e2bb4791cb930316d6f3e",
         "GUID:725ee7191c021de4dbf9269590ded755",
-        "GUID:2a0340569ab0e1245a38e0d6c7b2529b"
+        "GUID:2a0340569ab0e1245a38e0d6c7b2529b",
+        "GUID:befe48b9a36afc04ea625c93daad910e"
     ],
     "includePlatforms": [
         "Editor"

package/Runtime/Code/Airship/Resources/Scripts/Editor/Airship.Airship.Editor.asmdef

@@ -58,7 +58,8 @@
         "GUID:3b5390adca4e2bb4791cb930316d6f3e",
         "GUID:725ee7191c021de4dbf9269590ded755",
         "GUID:77ccaf49895b0d64e87cd4b4faf83c49",
-        "GUID:2a0340569ab0e1245a38e0d6c7b2529b"
+        "GUID:2a0340569ab0e1245a38e0d6c7b2529b",
+        "GUID:befe48b9a36afc04ea625c93daad910e"
     ],
     "includePlatforms": [
         "Editor"

package/Runtime/Code/Airship/Resources/Scripts/MeshCombiner.cs

@@ -402,12 +402,14 @@ namespace Airship {
                     }
                 }
 
+                var isClient = RunCore.IsClient();
+                
                 // Copy the materials to the renderer
                 Material[] finalMaterials = new Material[finalSkinnedMeshCopy.subMeshes.Count];
                 for (int i = 0; i < finalSkinnedMeshCopy.subMeshes.Count; i++) {
                     finalMaterials[i] = finalSkinnedMeshCopy.subMeshes[i].material;
 
-                    if (!finalMaterials[i].shader.isSupported) {
+                    if (isClient && !finalMaterials[i].shader.isSupported) {
                         finalMaterials[i].shader = Shader.Find("Universal Render Pipeline/Lit");
                     }
                     // finalMaterials[i].shader = 1(finalMaterials[i].shader.name);

package/Runtime/Code/Airship/Resources/Scripts/MeshCopy.cs

@@ -239,19 +239,22 @@ namespace Code.Airship.Resources.Scripts {
 
             // int instancePropertyID = Shader.PropertyToID("_BaseColor");
 
+            bool isClient = RunCore.IsClient();
             for (int i = 0; i < mesh.subMeshCount; i++) {
                 SubMesh subMesh = new();
 
-                Material mat = null;
-                if (i < materials.Length) {
-                    mat = materials[i];
-                }
-                else {
-                    //default material
-                    mat = new Material(Shader.Find("Universal Render Pipeline/Lit"));
+                if (isClient) {
+                    Material mat = null;
+                    if (i < materials.Length) {
+                        mat = materials[i];
+                    }
+                    else {
+                        //default material
+                        mat = new Material(Shader.Find("Universal Render Pipeline/Lit"));
+                    }
+                    subMesh.material = mat;
                 }
-                subMesh.material = mat;
-
+                
                 //id if the material is batchable
 
                 /*
@@ -781,9 +784,11 @@ namespace Code.Airship.Resources.Scripts {
 
             }
 
+            var isClient = RunCore.IsClient();
+
             for (int i = 0; i < source.subMeshes.Count; i++) {
                 SubMesh sourceMesh = source.subMeshes[i];
-                if (sourceMesh.material == null) {
+                if (isClient && sourceMesh.material == null) {
                     sourceMesh.material = new Material(Shader.Find("Universal Render Pipeline/Lit"));
                 }
 

package/Runtime/Code/AirshipConst.cs

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

package/Runtime/Code/Bootstrap/ServerBootstrap.cs

@@ -257,7 +257,7 @@ public class ServerBootstrap : MonoBehaviour
 		if (this.allocatedByAgones) return;
 		var annotations = server.ObjectMeta.Annotations;
 		if (annotations.ContainsKey("GameId") && annotations.ContainsKey("JWT") && annotations.ContainsKey("RequiredPackages")) {
-			Debug.Log($"[Agones]: Server will run game {annotations["GameId"]} with (Assets v{annotations["GameAssetVersion"]}) and (Code v{annotations["GameCodeVersion"]})");
+			Debug.Log($"[Agones]: Server {annotations["ServerId"]} will run game {annotations["GameId"]} with (Assets v{annotations["GameAssetVersion"]}) and (Code v{annotations["GameCodeVersion"]})");
 			this.allocatedByAgones = true;
 			startupConfig.GameBundleId = annotations["GameId"];
 			startupConfig.GameAssetVersion = annotations["GameAssetVersion"];

package/Runtime/Code/Bundles/Airship.Bundles.asmdef

@@ -19,7 +19,8 @@
         "GUID:30817c1a0e6d646d99c048fc403f5979",
         "GUID:ec266f293c0b4f6c9d06847488a52a0c",
         "GUID:325984b52e4128546bc7558552f8b1d2",
-        "GUID:72872094b21c16e48b631b2224833d49"
+        "GUID:72872094b21c16e48b631b2224833d49",
+        "GUID:befe48b9a36afc04ea625c93daad910e"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

package/Runtime/Code/Crc32/Crc32Algorithm.cs

@@ -0,0 +1,192 @@
+using System;
+using System.Security.Cryptography;
+
+namespace Force.Crc32
+{
+	/// <summary>
+	/// Implementation of CRC-32.
+	/// This class supports several convenient static methods returning the CRC as UInt32.
+	/// </summary>
+	public class Crc32Algorithm : HashAlgorithm
+	{
+		private uint _currentCrc;
+
+		private readonly bool _isBigEndian = true;
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="Crc32Algorithm"/> class. 
+		/// </summary>
+		public Crc32Algorithm()
+		{
+#if !NETCORE13
+			HashSizeValue = 32;
+#endif
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="Crc32Algorithm"/> class. 
+		/// </summary>
+		/// <param name="isBigEndian">Should return bytes result as big endian or little endian</param>
+		// Crc32 by dariogriffo uses big endian, so, we need to be compatible and return big endian as default
+		public Crc32Algorithm(bool isBigEndian = true)
+			: this()
+		{
+			_isBigEndian = isBigEndian;
+		}
+
+		/// <summary>
+		/// Computes CRC-32 from multiple buffers.
+		/// Call this method multiple times to chain multiple buffers.
+		/// </summary>
+		/// <param name="initial">
+		/// Initial CRC value for the algorithm. It is zero for the first buffer.
+		/// Subsequent buffers should have their initial value set to CRC value returned by previous call to this method.
+		/// </param>
+		/// <param name="input">Input buffer with data to be checksummed.</param>
+		/// <param name="offset">Offset of the input data within the buffer.</param>
+		/// <param name="length">Length of the input data in the buffer.</param>
+		/// <returns>Accumulated CRC-32 of all buffers processed so far.</returns>
+		public static uint Append(uint initial, byte[] input, int offset, int length)
+		{
+			if (input == null)
+				throw new ArgumentNullException("input");
+			if (offset < 0 || length < 0 || offset + length > input.Length)
+				throw new ArgumentOutOfRangeException("length");
+			return AppendInternal(initial, input, offset, length);
+		}
+
+		/// <summary>
+		/// Computes CRC-32 from multiple buffers.
+		/// Call this method multiple times to chain multiple buffers.
+		/// </summary>
+		/// <param name="initial">
+		/// Initial CRC value for the algorithm. It is zero for the first buffer.
+		/// Subsequent buffers should have their initial value set to CRC value returned by previous call to this method.
+		/// </param>
+		/// <param name="input">Input buffer containing data to be checksummed.</param>
+		/// <returns>Accumulated CRC-32 of all buffers processed so far.</returns>
+		public static uint Append(uint initial, byte[] input)
+		{
+			if (input == null)
+				throw new ArgumentNullException();
+			return AppendInternal(initial, input, 0, input.Length);
+		}
+
+		/// <summary>
+		/// Computes CRC-32 from input buffer.
+		/// </summary>
+		/// <param name="input">Input buffer with data to be checksummed.</param>
+		/// <param name="offset">Offset of the input data within the buffer.</param>
+		/// <param name="length">Length of the input data in the buffer.</param>
+		/// <returns>CRC-32 of the data in the buffer.</returns>
+		public static uint Compute(byte[] input, int offset, int length)
+		{
+			return Append(0, input, offset, length);
+		}
+
+		/// <summary>
+		/// Computes CRC-32 from input buffer.
+		/// </summary>
+		/// <param name="input">Input buffer containing data to be checksummed.</param>
+		/// <returns>CRC-32 of the buffer.</returns>
+		public static uint Compute(byte[] input)
+		{
+			return Append(0, input);
+		}
+
+		/// <summary>
+		/// Computes CRC-32 from input buffer and writes it after end of data (buffer should have 4 bytes reserved space for it). Can be used in conjunction with <see cref="IsValidWithCrcAtEnd(byte[],int,int)"/>
+		/// </summary>
+		/// <param name="input">Input buffer with data to be checksummed.</param>
+		/// <param name="offset">Offset of the input data within the buffer.</param>
+		/// <param name="length">Length of the input data in the buffer.</param>
+		/// <returns>CRC-32 of the data in the buffer.</returns>
+		public static uint ComputeAndWriteToEnd(byte[] input, int offset, int length)
+		{
+			if (length + 4 > input.Length)
+				throw new ArgumentOutOfRangeException("length", "Length of data should be less than array length - 4 bytes of CRC data");
+			var crc = Append(0, input, offset, length);
+			var r = offset + length;
+			input[r] = (byte)crc;
+			input[r + 1] = (byte)(crc >> 8);
+			input[r + 2] = (byte)(crc >> 16);
+			input[r + 3] = (byte)(crc >> 24);
+			return crc;
+		}
+
+		/// <summary>
+		/// Computes CRC-32 from input buffer - 4 bytes and writes it as last 4 bytes of buffer. Can be used in conjunction with <see cref="IsValidWithCrcAtEnd(byte[])"/>
+		/// </summary>
+		/// <param name="input">Input buffer with data to be checksummed.</param>
+		/// <returns>CRC-32 of the data in the buffer.</returns>
+		public static uint ComputeAndWriteToEnd(byte[] input)
+		{
+			if (input.Length < 4)
+				throw new ArgumentOutOfRangeException("input", "Input array should be 4 bytes at least");
+			return ComputeAndWriteToEnd(input, 0, input.Length - 4);
+		}
+
+		/// <summary>
+		/// Validates correctness of CRC-32 data in source buffer with assumption that CRC-32 data located at end of buffer in reverse bytes order. Can be used in conjunction with <see cref="ComputeAndWriteToEnd(byte[],int,int)"/>
+		/// </summary>
+		/// <param name="input">Input buffer with data to be checksummed.</param>
+		/// <param name="offset">Offset of the input data within the buffer.</param>
+		/// <param name="lengthWithCrc">Length of the input data in the buffer with CRC-32 bytes.</param>
+		/// <returns>Is checksum valid.</returns>
+		public static bool IsValidWithCrcAtEnd(byte[] input, int offset, int lengthWithCrc)
+		{
+			return Append(0, input, offset, lengthWithCrc) == 0x2144DF1C;
+		}
+
+		/// <summary>
+		/// Validates correctness of CRC-32 data in source buffer with assumption that CRC-32 data located at end of buffer in reverse bytes order. Can be used in conjunction with <see cref="ComputeAndWriteToEnd(byte[],int,int)"/>
+		/// </summary>
+		/// <param name="input">Input buffer with data to be checksummed.</param>
+		/// <returns>Is checksum valid.</returns>
+		public static bool IsValidWithCrcAtEnd(byte[] input)
+		{
+			if (input.Length < 4)
+				throw new ArgumentOutOfRangeException("input", "Input array should be 4 bytes at least");
+			return Append(0, input, 0, input.Length) == 0x2144DF1C;
+		}
+
+		/// <summary>
+		/// Resets internal state of the algorithm. Used internally.
+		/// </summary>
+		public override void Initialize()
+		{
+			_currentCrc = 0;
+		}
+
+		/// <summary>
+		/// Appends CRC-32 from given buffer
+		/// </summary>
+		protected override void HashCore(byte[] input, int offset, int length)
+		{
+			_currentCrc = AppendInternal(_currentCrc, input, offset, length);
+		}
+
+		/// <summary>
+		/// Computes CRC-32 from <see cref="HashCore"/>
+		/// </summary>
+		protected override byte[] HashFinal()
+		{
+			if (_isBigEndian)
+				return new[] { (byte)(_currentCrc >> 24), (byte)(_currentCrc >> 16), (byte)(_currentCrc >> 8), (byte)_currentCrc };
+			else
+				return new[] { (byte)_currentCrc, (byte)(_currentCrc >> 8), (byte)(_currentCrc >> 16), (byte)(_currentCrc >> 24) };
+		}
+
+		private static readonly SafeProxy _proxy = new SafeProxy();
+
+		private static uint AppendInternal(uint initial, byte[] input, int offset, int length)
+		{
+			if (length > 0)
+			{
+				return _proxy.Append(initial, input, offset, length);
+			}
+			else
+				return initial;
+		}
+	}
+}

package/Runtime/Code/Crc32/Crc32Algorithm.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 41a97d10936043dcbe8cac06d90707e1
+timeCreated: 1748982351

package/Runtime/Code/Crc32/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 force
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Runtime/Code/Crc32/LICENSE.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a38985e4d8b54263a4fed1ccdc6b7863
+timeCreated: 1748982576

package/Runtime/Code/Crc32/SafeProxy.cs

@@ -0,0 +1,76 @@
+/* This is .NET safe implementation of Crc32 algorithm.
+ * This implementation was investigated as fastest from different variants. It based on Robert Vazan native implementations of Crc32C
+ * Also, it is good for x64 and for x86, so, it seems, there is no sense to do 2 different realizations.
+ * 
+ * Addition: some speed increase was found with splitting xor to 4 independent blocks. Also, some attempts to optimize unaligned tails was unsuccessfull (JIT limitations?).
+ * 
+ * 
+ * Max Vysokikh, 2016-2017
+ */
+
+namespace Force.Crc32
+{
+	internal class SafeProxy
+	{
+		private const uint Poly = 0xedb88320u;
+
+		private readonly uint[] _table = new uint[16 * 256];
+
+		internal SafeProxy()
+		{
+			Init(Poly);
+		}
+
+		protected void Init(uint poly)
+		{
+			var table = _table;
+			for (uint i = 0; i < 256; i++)
+			{
+				uint res = i;
+				for (int t = 0; t < 16; t++)
+				{
+					for (int k = 0; k < 8; k++) res = (res & 1) == 1 ? poly ^ (res >> 1) : (res >> 1);
+					table[(t * 256) + i] = res;
+				}
+			}
+		}
+
+		public uint Append(uint crc, byte[] input, int offset, int length)
+		{
+			uint crcLocal = uint.MaxValue ^ crc;
+
+			uint[] table = _table;
+			while (length >= 16)
+			{
+				var a = table[(3 * 256) + input[offset + 12]]
+					^ table[(2 * 256) + input[offset + 13]]
+					^ table[(1 * 256) + input[offset + 14]]
+					^ table[(0 * 256) + input[offset + 15]];
+
+				var b = table[(7 * 256) + input[offset + 8]]
+					^ table[(6 * 256) + input[offset + 9]]
+					^ table[(5 * 256) + input[offset + 10]]
+					^ table[(4 * 256) + input[offset + 11]];
+
+				var c = table[(11 * 256) + input[offset + 4]] 
+					^ table[(10 * 256) + input[offset + 5]] 
+					^ table[(9 * 256) + input[offset + 6]] 
+					^ table[(8 * 256) + input[offset + 7]];
+
+				var d = table[(15 * 256) + ((byte)crcLocal ^ input[offset])]
+					^ table[(14 * 256) + ((byte)(crcLocal >> 8) ^ input[offset + 1])]
+					^ table[(13 * 256) + ((byte)(crcLocal >> 16) ^ input[offset + 2])]
+					^ table[(12 * 256) + ((crcLocal >> 24) ^ input[offset + 3])];
+
+				crcLocal = d ^ c ^ b ^ a;
+				offset += 16;
+				length -= 16;
+			}
+
+			while (--length >= 0)
+				crcLocal = table[(byte)(crcLocal ^ input[offset++])] ^ crcLocal >> 8;
+
+			return crcLocal ^ uint.MaxValue;
+		}
+	}
+}

package/Runtime/Code/Crc32/SafeProxy.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bfc1464e65e44f218cc5e843516449fc
+timeCreated: 1748982368

package/Runtime/Code/Crc32.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0d1768ef9c4b447c8ea42b782c41338d
+timeCreated: 1748982299

package/Runtime/Code/Luau/Airship.LuauCore.asmdef

@@ -23,6 +23,7 @@
         "GUID:ec266f293c0b4f6c9d06847488a52a0c",
         "GUID:325984b52e4128546bc7558552f8b1d2",
         "GUID:befe48b9a36afc04ea625c93daad910e",
+        "GUID:47a57257b08841e9a7b6a61ce7119d42",
         "GUID:21d1eb854b91ade49bc69a263d12bee2",
         "GUID:d8b63aba1907145bea998dd612889d6b"
     ],

package/Runtime/Code/Luau/AirshipComponent.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
 using Assets.Code.Luau;
+using Code.Luau;
 using JetBrains.Annotations;
 using Luau;
 using UnityEngine;
@@ -57,7 +58,7 @@ internal delegate void ReconcileAirshipComponent(AirshipReconcileEventData data)
 [AddComponentMenu("Airship/Airship Component")]
 [HelpURL("https://docs.airship.gg/typescript/airshipbehaviour")]
 [LuauAPI(LuauContext.Protected)]
-public class AirshipComponent : MonoBehaviour {
+public class AirshipComponent : MonoBehaviour, ITriggerReceiver {
 	internal static bool UsePostCompileReconciliation { get; set; } = true;
 	private const bool ElevateToProtectedWithinCoreScene = true;
 	
@@ -230,6 +231,7 @@ public class AirshipComponent : MonoBehaviour {
 		LuauCore.onResetInstance += OnLuauReset;
 
 		InitAirshipComponent();
+		InitTriggerEvents();
 	}
 
 	private unsafe void InitAirshipComponent() {
@@ -287,6 +289,13 @@ public class AirshipComponent : MonoBehaviour {
 		InitStringPtrs.Clear();
 	}
 
+	private void InitTriggerEvents() {
+		if (HasAirshipMethod(AirshipComponentUpdateType.AirshipTriggerStay)) {
+			var triggerEvent = gameObject.AddComponent<AirshipComponentTriggerEvents>();
+			triggerEvent.AttachReceiver(this);
+		}
+	}
+
 	private void Start() {
 		if (thread == IntPtr.Zero || !LuauCore.IsReady) return;
 		
@@ -367,11 +376,11 @@ public class AirshipComponent : MonoBehaviour {
 		
 		InvokeAirshipCollision(AirshipComponentUpdateType.AirshipTriggerEnter, other);
 	}
-	
-	private void OnTriggerStay(Collider other) {
+
+	public void OnTriggerStayReceiver(Collider other) {
 		if (thread == IntPtr.Zero || !LuauCore.IsReady) return;
 		
-		InvokeAirshipCollision(AirshipComponentUpdateType.AirshipTriggerStay, other);
+		InvokeAirshipCollision(AirshipComponentUpdateType.AirshipTriggerStay, other);	
 	}
 	
 	private void OnTriggerExit(Collider other) {

package/Runtime/Code/Luau/AirshipComponentTriggerEvents.cs

@@ -0,0 +1,20 @@
+using System;
+using UnityEngine;
+
+namespace Code.Luau {
+    public interface ITriggerReceiver {
+        public void OnTriggerStayReceiver(Collider other);
+    }
+    
+    public class AirshipComponentTriggerEvents : MonoBehaviour {
+        private ITriggerReceiver receiver;
+        
+        public void AttachReceiver(ITriggerReceiver receiver) {
+            this.receiver = receiver;
+        }
+        
+        private void OnTriggerStay(Collider other) {
+            this.receiver.OnTriggerStayReceiver(other);
+        }
+    }
+}

package/Runtime/Code/Luau/AirshipComponentTriggerEvents.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b3c2c140914f04a538637672395ffb4d

package/Runtime/Code/Luau/BinaryBlob.cs

@@ -1,11 +1,7 @@
 using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Text;
-using Code.Zstd;
+using Mirror;
+using Code.Util;
 using UnityEngine;
-using UnityEngine.Serialization;
-using static LuauCore;
 
 namespace Assets.Luau {
     [Serializable]
@@ -29,5 +25,103 @@ namespace Assets.Luau {
         public bool Equals(BinaryBlob other) {
             return this.dataSize == other?.dataSize;
         }
+
+        public byte[] CreateDiff(BinaryBlob other) {
+            int length = Math.Max(other.data.Length, data.Length);
+            var neededBytes = (int) Math.Ceiling(length / 8f);
+            byte[] changeBytes = new byte[neededBytes];
+            var writer = NetworkWriterPool.Get();
+            writer.WriteByte((byte) changeBytes.Length);
+
+            var changedByteWriter = NetworkWriterPool.Get();
+            for (int i = 0; i < length; i++) {
+                int bitIndex = i % 8;
+                int byteIndex = i / 8;
+                
+                // We ran out of new data. we will continue to write changed bits, but we will not write byte data
+                if (i > other.data.Length - 1) {
+                    BitUtil.SetBit(ref changeBytes[byteIndex], bitIndex, true);
+                    continue;
+                }
+
+                // We ran out of base data. We will continue to write change bits and the new data
+                if (i > data.Length - 1) {
+                    BitUtil.SetBit(ref changeBytes[byteIndex], bitIndex, true);
+                    changedByteWriter.Write(other.data[i]);
+                    continue;
+                }
+
+                // We have values to compare
+                if (other.data[i] == data[i]) {
+                    // Byte values are equal. No need to write a new value
+                    BitUtil.SetBit(ref changeBytes[byteIndex], bitIndex, false);
+                } else {
+                    // Byte values don't match. Write new value 
+                    BitUtil.SetBit(ref changeBytes[byteIndex], bitIndex, true);
+                    changedByteWriter.Write(other.data[i]);
+                }
+            }
+
+            writer.WriteBytes(changeBytes, 0, changeBytes.Length);
+            var newByteValues = changedByteWriter.ToArray();
+            writer.WriteBytes(newByteValues, 0 ,newByteValues.Length);
+            var bytes = writer.ToArray();
+            
+            NetworkWriterPool.Return(writer);
+            NetworkWriterPool.Return(changedByteWriter);
+            
+            // Debug.Log($"Final diff is {bytes.Length} bytes");
+            return bytes;
+        }
+
+        public BinaryBlob ApplyDiff(byte[] bytes) {
+            // first byte in bytes will be the number of bytes to read as the change bit flags.
+            // Each bit of the change flag bytes refers to the index of the base byte array
+            // ie. bit 0 is byte zero of the base data. If the flag is true, we should read
+            // a byte from the diff data and replace index 0 with the new byte data.
+            byte changedLength = bytes[0];
+            if (changedLength == 0) return new BinaryBlob() {
+                dataSize = dataSize,
+                data = (byte[]) data.Clone(),
+            };
+            
+            var byteWriter = NetworkWriterPool.Get();
+            var diffReadIndex = changedLength + 1; // + 1 for the byte used to encode the data size
+            for (byte curByte = 0; curByte < changedLength; curByte++) {
+                byte flags = bytes[curByte + 1];
+                for (byte curBitOfByte = 0; curBitOfByte < 8; curBitOfByte++) {
+                    // The index into the existing byte array that the bit flag refers to.
+                    var existingByteIndex = curBitOfByte + (curByte * 8);
+                    
+                    // Should we update the byte at the current position?
+                    bool update = BitUtil.GetBit(flags, curBitOfByte);
+                    
+                    // If we have run out of diff data, but the bit flag says we should update the position,
+                    // we are going to delete the remaining bytes by not writing them. This happens when
+                    // the diff is supposed to shorten the base data.
+                    if (diffReadIndex > (bytes.Length - 1) && update) {
+                        // The absence of a write here "removes" data from the end of the base data.
+                        continue;
+                    }
+
+                    // If we run out of base data, but update wasn't set, it means we've reached the end of the changed flags. This happens when you have
+                    // 7 bytes of data, but you have to include 1 full byte of change flags (8 bits). The last bit will be zero since there's no associated byte for that flag.
+                    if (existingByteIndex > (data.Length - 1) && !update) {
+                        // We do nothing since this bit flag is meaningless.
+                        continue;
+                    }
+                    
+                    byteWriter.Write(update ? bytes[diffReadIndex] : data[existingByteIndex]);
+                    if (update) diffReadIndex++; // Move our read pointer forward since we read a byte from our diff data.
+                }
+            }
+            
+            var newBlob = new BinaryBlob() {
+                data = byteWriter.ToArray(), // new byte array with the diff applied
+                dataSize = byteWriter.Position // size of new byte array
+            };
+            NetworkWriterPool.Return(byteWriter);
+            return newBlob;
+        }
     }
 }

package/Runtime/Code/Luau/LuauCompiler.cs

@@ -7,7 +7,7 @@ using Debug = UnityEngine.Debug;
 
 public class LuauCompiler {
     // Any globals in Luau that have values that change need to be added to this list (e.g. "Time" because "Time.time" changes):
-    public static readonly string[] MutableGlobals = {"Time", "NetworkTime", "Physics", "Screen", "Input"};
+    public static readonly string[] MutableGlobals = {"Time", "NetworkTime", "Physics", "Screen", "Input", "AirshipSimulationManager"};
 
     public struct CompilationResult {
         public IntPtr Data;

package/Runtime/Code/Luau/LuauCoreCallbacks.cs

@@ -990,6 +990,7 @@ public partial class LuauCore : MonoBehaviour {
     }
     
     public static string GetRequirePath(string originalScriptPath, string fileNameStr) {
+        Profiler.BeginSample("GetRequirePath");
         if (!string.IsNullOrEmpty(originalScriptPath)) {
             if (!fileNameStr.Contains("/")) {
                 // Get a stripped name
@@ -1026,6 +1027,7 @@ public partial class LuauCore : MonoBehaviour {
         //Fully qualify it
         fileNameStr = GetTidyPathNameForLuaFile(fileNameStr);
 
+        Profiler.EndSample();
         return fileNameStr;
     }