gg.easy.airship 0.1.2162 → 0.1.2163

package/Editor/BuildMenu.cs

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

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

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

package/Runtime/Code/Bootstrap/AirshipEntryPoint.cs

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

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

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

package/Runtime/Code/Bootstrap/AirshipLogHandler.cs

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

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

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

package/Runtime/Code/Bootstrap/SignalHandler.cs

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

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

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

package/Runtime/Code/Luau/LuauCoreCallbacks.cs

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

package/Runtime/Code/LuauAPI/FrameTimingManagerAPI.cs

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

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

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

package/Runtime/Code/Network/AirshipNetworkManager.cs

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

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

@@ -246,10 +246,6 @@ namespace Code.Network.StateSystem
                     if (commands.Length > 0) {
                         this.clientLastSentLocalTick = this.inputHistory.Keys[^1];
                     }
-                    else {
-                        Debug.LogWarning(
-                            $"Sending no commands on interval. Last local tick: {clientLastSentLocalTick}. Local command history size: {this.inputHistory.Keys.Count}");
-                    }
                     
                     // print($"Sending {commands.Length} cmds to the server");
 
@@ -341,7 +337,7 @@ namespace Code.Network.StateSystem
             if (isServer && serverAuth) {
                 if (serverCommandBuffer.Count > serverCommandBufferTargetSize) {
                     serverCommandCatchUpRequired = serverCommandBuffer.Count - serverCommandBufferTargetSize;
-                    print($"Command catchup required for {this.name}: {serverCommandCatchUpRequired}");
+                    // print($"Command catchup required for {this.name}: {serverCommandCatchUpRequired}");
                 }
                 else {
                     serverCommandCatchUpRequired = 0;
@@ -352,7 +348,7 @@ namespace Code.Network.StateSystem
             if (isServer && !serverAuth) {
                 if (serverReceivedStateBuffer.Count > serverCommandBufferTargetSize) {
                     serverCommandCatchUpRequired = serverReceivedStateBuffer.Count - serverCommandBufferTargetSize;
-                    print($"State catchup required for {this.name}: {serverCommandCatchUpRequired}");
+                    // print($"State catchup required for {this.name}: {serverCommandCatchUpRequired}");
                 }
                 else {
                     serverCommandCatchUpRequired = 0;
@@ -518,18 +514,10 @@ namespace Code.Network.StateSystem
             var totalBuffer = (latency * 2) + bufferTime + commandBufferTime;
             var lagCompensatedTime = currentTime - totalBuffer;
             var lagCompensatedTick = AirshipSimulationManager.Instance.GetNearestTickForUnscaledTime(lagCompensatedTime);
-            // It seems like we can get better results by doing a combination of adding 1 send rate and/or 1 tick time
-            // This test was with .34 timescale and 1/40 send rate
-            // 12.9068027064583 - (13.1350901077098 - ((0.0275639141664629 * 2) + 0.0500000007450581 + 0.025 + (0.07352941 * .34) + 0.07352941)) = 0.00036983722
-            // 16.074496323404 - (16.296857560941 - ((0.0142610969939435 * 2) + 0.0500000007450581 + 0.025 + (0.07352941 * 0.34) + 0.07352941 + 0.025)) = 0.00469036659
-            // 19.2368007725462 - (19.4586250708617 - ((0.0123929982200843 * 2) + 0.0500000007450581 + 0.025 + (0.07352941 * 0.34) + 0.07352941 + 0.025)) = 0.00149110826
-            // 22.5390862366273 - (22.7674515306122 - ((0.0122401664944862 * 2) + 0.0500000007450581 + 0.025 + (0.07352941 * 0.34) + 0.07352941 + .025)) = -0.00535555085
-            // print($"CLIENTTIME - ({currentTime} - (({latency} * 2) + {bufferTime} + {NetworkServer.sendInterval} + ({Time.fixedUnscaledDeltaTime} * {commandsInOneInterval})))");
+            
             // print($"CLIENTTIME - ({currentTime} - (({latency} * 2) + {bufferTime} + {commandBufferTime}))");
             // print($"CLIENTTIME - {lagCompensatedTime}");
             // print($"Rolling back to {lagCompensatedTick} using total rollback of {totalBuffer}");
-            // print(
-            //     $"{currentTime} - (({latency} * 2) + {bufferTime} + ({tickGenerationTime} * {commandsInOneInterval} * 2)) = {lagCompensatedTime} ({lagCompensatedTick})");
             this.OnSetSnapshot(lagCompensatedTick);
         }
 
@@ -574,12 +562,12 @@ namespace Code.Network.StateSystem
                     this.serverCommandBuffer.RemoveAt(0);
                     dropCount++;
                 }
-                print("Dropped " + dropCount + " command(s) from " + this.gameObject.name + " due to exceeding command buffer size.");
+                // print("Dropped " + dropCount + " command(s) from " + this.gameObject.name + " due to exceeding command buffer size.");
             }
 
             // 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)) {
-                Debug.Log($"Waiting for additional commands for {this.name}. There are {this.serverCommandBuffer.Count} commands in the buffer.");
+                // 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;
             }
@@ -606,11 +594,11 @@ namespace Code.Network.StateSystem
                         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.");
+                        // 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;
@@ -632,8 +620,8 @@ namespace Code.Network.StateSystem
                 }
                 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);
+                    // 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
@@ -648,10 +636,10 @@ namespace Code.Network.StateSystem
             } 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.");
-            }
+            // if (commandsProcessed > 1)
+            // {
+            //     print("Processed " + commandsProcessed + " commands for " + this.gameObject.name + $". There are now {this.serverCommandBuffer.Count} commands in the buffer.");
+            // }
         }
 
         public void AuthServerCaptureSnapshot(int tick, double time, bool replay)
@@ -676,7 +664,7 @@ namespace Code.Network.StateSystem
             {
                 // In the case where there's no state to roll back to, we simply leave the state system where it is. This technically means
                 // that freshly spawned players will exist in rollback when they shouldn't but we won't handle that edge case for now.
-                Debug.LogWarning($"Set snapshot to {tick} resulted in null state for {this.name}. State history size is {this.stateHistory.Keys.Count}");
+                // Debug.LogWarning($"Set snapshot to {tick} resulted in null state for {this.name}. State history size is {this.stateHistory.Keys.Count}");
                 return;
             }
             this.stateSystem.SetCurrentState(state);
@@ -784,10 +772,10 @@ namespace Code.Network.StateSystem
             do
             {
                 statesProcessed++;
-                if (statesProcessed > 1)
-                {
-                    Debug.Log($"Processing additional client auth state for {this.name}. The server needs to catch up.");
-                }
+                // if (statesProcessed > 1)
+                // {
+                //     Debug.Log($"Processing additional client auth state for {this.name}. The server needs to catch up.");
+                // }
 
                 // Attempt to get a new state out of the buffer.
                 latestState = this.serverReceivedStateBuffer.Count > 0
@@ -1032,8 +1020,8 @@ namespace Code.Network.StateSystem
                 // On extremely high ping, this will mean that the local player will freeze in place while we wait for
                 // confirmation from the server.
                 // this.clientPausePrediction = true; // disabled for now
-                Debug.LogWarning(
-                    "We have a large number of unconfirmed commands to the server. Is there something wrong with the network or is the server lagging?");
+                // Debug.LogWarning(
+                //     "We have a large number of unconfirmed commands to the server. Is there something wrong with the network or is the server lagging?");
                 return;
             }
 
@@ -1059,7 +1047,7 @@ namespace Code.Network.StateSystem
                 // This may happen from time to time if the client clock gets out of sync with the server for a moment.
                 // Generally a situation like this is recoverable by processing an additional state snapshot from the
                 // server.
-                Debug.LogWarning("Couldn't find client predicted state for command " + state.lastProcessedCommand);
+                // Debug.LogWarning("Couldn't find client predicted state for command " + state.lastProcessedCommand);
                 return;
             }
 
@@ -1079,7 +1067,7 @@ namespace Code.Network.StateSystem
                 return;
             }
 
-            Debug.LogWarning("Misprediction for " + this.name + " on cmd#" + state.lastProcessedCommand + ". Requesting resimulation.");
+            // Debug.LogWarning("Misprediction for " + this.name + " on cmd#" + state.lastProcessedCommand + ". Requesting resimulation.");
             
             // We use the client prediction time so we can act like we got this right in our history. Server gives us
             // a time value in its local timeline so the provided time is not useful to us.

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

@@ -73,36 +73,36 @@ namespace Code.Player.Character.MovementSystems.Character
             var isGroundedEqual = isGrounded == other.isGrounded;
             var stateEqual = state == other.state;
 
-            if (!lastProcessedCommandEqual)
-                message += $"lastProcessedCommand: {this.lastProcessedCommand} != {other.lastProcessedCommand}\n";
-            if (!positionEqual)
-                message += $"position: {this.position} != {other.position}\n";
-            if (!velocityEqual)
-                message += $"velocity: {this.velocity} != {other.velocity}\n";
-            if (!currentSpeedEqual)
-                message += $"currentSpeed: {this.currentSpeed} != {other.currentSpeed}\n";
-            if (!speedModifierEqual)
-                message += $"speedModifier: {this.speedModifier} != {other.speedModifier}\n";
-            if (!inputDisabledEqual)
-                message += $"inputDisabled: {inputDisabled} != {other.inputDisabled}\n";
-            if (!isFlyingEqual)
-                message += $"isFlying: {isFlying} != {other.isFlying}\n";
-            if (!isSprintingEqual)
-                message += $"isSprinting: {isSprinting} != {other.isSprinting}\n";
-            if (!jumpCountEqual)
-                message += $"jumpCount: {jumpCount} != {other.jumpCount}\n";
-            if (!airborneFromImpulseEqual)
-                message += $"airborneFromImpulse: {airborneFromImpulse} != {other.airborneFromImpulse}\n";
-            if (!alreadyJumpedEqual)
-                message += $"alreadyJumped: {alreadyJumped} != {other.alreadyJumped}\n";
-            if (!isCrouchingEqual)
-                message += $"prevCrouch: {isCrouching} != {other.isCrouching}\n";
-            if (!prevStepUpEqual)
-                message += $"prevStepUp: {prevStepUp} != {other.prevStepUp}\n";
-            if (!isGroundedEqual)
-                message += $"prevGrounded: {isGrounded} != {other.isGrounded}\n";
-            if (!stateEqual)
-                message += $"state: {state} != {other.state}\n";
+            // if (!lastProcessedCommandEqual)
+            //     message += $"lastProcessedCommand: {this.lastProcessedCommand} != {other.lastProcessedCommand}\n";
+            // if (!positionEqual)
+            //     message += $"position: {this.position} != {other.position}\n";
+            // if (!velocityEqual)
+            //     message += $"velocity: {this.velocity} != {other.velocity}\n";
+            // if (!currentSpeedEqual)
+            //     message += $"currentSpeed: {this.currentSpeed} != {other.currentSpeed}\n";
+            // if (!speedModifierEqual)
+            //     message += $"speedModifier: {this.speedModifier} != {other.speedModifier}\n";
+            // if (!inputDisabledEqual)
+            //     message += $"inputDisabled: {inputDisabled} != {other.inputDisabled}\n";
+            // if (!isFlyingEqual)
+            //     message += $"isFlying: {isFlying} != {other.isFlying}\n";
+            // if (!isSprintingEqual)
+            //     message += $"isSprinting: {isSprinting} != {other.isSprinting}\n";
+            // if (!jumpCountEqual)
+            //     message += $"jumpCount: {jumpCount} != {other.jumpCount}\n";
+            // if (!airborneFromImpulseEqual)
+            //     message += $"airborneFromImpulse: {airborneFromImpulse} != {other.airborneFromImpulse}\n";
+            // if (!alreadyJumpedEqual)
+            //     message += $"alreadyJumped: {alreadyJumped} != {other.alreadyJumped}\n";
+            // if (!isCrouchingEqual)
+            //     message += $"prevCrouch: {isCrouching} != {other.isCrouching}\n";
+            // if (!prevStepUpEqual)
+            //     message += $"prevStepUp: {prevStepUp} != {other.prevStepUp}\n";
+            // if (!isGroundedEqual)
+            //     message += $"prevGrounded: {isGrounded} != {other.isGrounded}\n";
+            // if (!stateEqual)
+            //     message += $"state: {state} != {other.state}\n";
 
             var same =
                 lastProcessedCommandEqual &&
@@ -127,10 +127,10 @@ namespace Code.Player.Character.MovementSystems.Character
                 movement.compareResult = true;
                 movement.FireTsCompare(this, other);
                 same = movement.compareResult;
-                if (same == false) message += $"customData: a != b";
+                // if (same == false) message += $"customData: a != b";
             }
             
-            if (message.Length != 0) Debug.Log(message.TrimEnd());
+            // if (message.Length != 0) Debug.Log(message.TrimEnd());
             return same;
         }
 
@@ -356,7 +356,7 @@ namespace Code.Player.Character.MovementSystems.Character
             if (crc32 != diff.crc32) {
                 // We return null here since we are essentially unable to construct a correct snapshot from the provided diff
                 // using this snapshot as the base.
-                Debug.LogWarning($"Applying diff failed CRC check. This may happen due to poor network conditions.");
+                // Debug.LogWarning($"Applying diff failed CRC check. This may happen due to poor network conditions.");
                 return null;
             }
 

package/Runtime/Code/TSCodeGen/TypeGenerator.cs

@@ -178,6 +178,7 @@ public class TypeGenerator : MonoBehaviour
             typeof(AirshipLongPress),
             typeof(DecalProjector),
             typeof(Time),
+            typeof(FrameTimingManager),
             //Collider 2D Types
             typeof(BoxCollider2D),
             typeof(CircleCollider2D),

package/Runtime/Code/VoxelWorld/Resources/VoxelWorldDefaultBlocks/DefaultDirt/DefaultDirt.asset

@@ -15,10 +15,12 @@ MonoBehaviour:
   blockName: DefaultDirt
   description: 
   contextStyle: 0
+  meshMaterial: {fileID: 0}
+  halfBlock: 0
   topTexture:
     material: {fileID: 0}
-    diffuse: {fileID: 2800000, guid: 2df3bfbc1f210ba438d26e9d2ddccb9c, type: 3}
-    normal: {fileID: 2800000, guid: 15303d969da939849bc2c5ad9bf3c29c, type: 3}
+    diffuse: {fileID: 2800000, guid: bd09fa45c18442546858afeccf4a5cc3, type: 3}
+    normal: {fileID: 2800000, guid: 0c33d3bfe43dead49b46acc3f45fe2cf, type: 3}
     smooth: {fileID: 0}
     metallic: {fileID: 0}
     emissive: {fileID: 0}
@@ -36,9 +38,28 @@ MonoBehaviour:
     smooth: {fileID: 0}
     metallic: {fileID: 0}
     emissive: {fileID: 0}
-  meshMaterial: {fileID: 0}
-  quarterBlockMesh: {fileID: 0}
-  meshPathLod: 
+  quarterBlockMeshes: []
+  prefab: {fileID: 0}
+  staticMeshLOD0: {fileID: 0}
+  staticMeshLOD1: {fileID: 0}
+  staticMeshLOD2: {fileID: 0}
+  meshTile1x1x1:
+    mesh_LOD0: {fileID: 0}
+    mesh_LOD1: {fileID: 0}
+    mesh_LOD2: {fileID: 0}
+  meshTile2x2x2:
+    mesh_LOD0: {fileID: 0}
+    mesh_LOD1: {fileID: 0}
+    mesh_LOD2: {fileID: 0}
+  meshTile3x3x3:
+    mesh_LOD0: {fileID: 0}
+    mesh_LOD1: {fileID: 0}
+    mesh_LOD2: {fileID: 0}
+  meshTile4x4x4:
+    mesh_LOD0: {fileID: 0}
+    mesh_LOD1: {fileID: 0}
+    mesh_LOD2: {fileID: 0}
+  rotatedPlacement: 0
   metallic: 0
   smoothness: 0
   normalScale: 1
@@ -47,4 +68,3 @@ MonoBehaviour:
   solid: 1
   collisionType: 1
   randomRotation: 0
-  minecraftIds: