gg.easy.airship 0.1.2166 → 0.1.2168

package/Editor/AirAsset/AirAssetBundleEditor.cs

@@ -158,7 +158,7 @@ namespace Editor.AirAsset {
             var buildOutputFile = $"bundles/airassetbundle/{airId}_{AirshipPlatformUtil.GetStringName(platform)}.bundle";
             var sourceFolderPath = Path.GetRelativePath(".", Directory.GetParent(AssetDatabase.GetAssetPath(airAssetBundle))!.FullName);
 
-            List<AssetBundleBuild> builds = CreateAssetBundles.GetPackageAssetBundleBuilds();
+            List<AssetBundleBuild> builds = CreateAssetBundles.GetPackageAssetBundleBuilds(false);
 
             var assetGuids = AssetDatabase.FindAssets("*", new string[] {sourceFolderPath}).ToList();
             var assetPaths = assetGuids

package/Editor/CreateAssetBundles.cs

@@ -173,7 +173,7 @@ public static class CreateAssetBundles {
 	/// Creates an AssetBundleBuild for every AirshipPackage in the project.
 	/// </summary>
 	/// <returns></returns>
-	public static List<AssetBundleBuild> GetPackageAssetBundleBuilds() {
+	public static List<AssetBundleBuild> GetPackageAssetBundleBuilds(bool compileURPShaders) {
 		List<AssetBundleBuild> builds = new();
 
 		if (!Directory.Exists(Path.Join("Assets", "AirshipPackages"))) {
@@ -197,7 +197,7 @@ public static class CreateAssetBundles {
 						assetGuids.AddRange(urpGuids);
 					});
 
-					if (!EditorIntegrationsConfig.instance.selfCompileAllShaders) {
+					if (!compileURPShaders) {
 						Debug.Log("Adding URP assets to CoreMaterials bundle.");
 						addUrpFiles("Packages/com.unity.render-pipelines.universal/Shaders");
 						addUrpFiles("Packages/com.unity.render-pipelines.universal/ShaderLibrary");
@@ -294,7 +294,10 @@ public static class CreateAssetBundles {
 		Debug.Log($"[Editor]: Building {platform} asset bundles...");
 		Debug.Log("[Editor]: Build path: " + buildPath);
 
-		List<AssetBundleBuild> builds = GetPackageAssetBundleBuilds();
+		// Act as if we are building all asset bundles (including CoreMaterials).
+		// This is so our current build target will have references to those asset bundles.
+		// This is paired with changes to Scriptable Build Pipeline that prevent these bundles from actually being built.
+		List<AssetBundleBuild> builds = GetPackageAssetBundleBuilds(gameConfig.compileURPShaders);
 
 		// Make a fake asset bundle with all package content. This makes the build have the correct dependency data.
 		// {

package/Editor/EditorIntegrationsConfig.cs

@@ -39,8 +39,6 @@ public class EditorIntegrationsConfig : ScriptableSingleton<EditorIntegrationsCo
     [SerializeField] 
     public bool safeguardBundleModification = true;
 
-    [SerializeField] public bool selfCompileAllShaders = false;
-
     [SerializeField] internal bool useProjectReconcileOption = false;
     [FormerlySerializedAs("reconcilerVersion")] [SerializeField] internal ReconcilerVersion projectReconcilerVersion = ReconcilerVersion.Default;
     

package/Editor/GameConfig/GameConfigEditor.cs

@@ -18,6 +18,7 @@ public class GameConfigEditor : UnityEditor.Editor {
     private Action requestRefresh;
 
     private SerializedProperty supportsMobile;
+    private SerializedProperty compileURPShaders;
 
     Rect buttonRect;
     public override void OnInspectorGUI() {
@@ -51,6 +52,12 @@ public class GameConfigEditor : UnityEditor.Editor {
         EditorGUILayout.PropertyField(this.supportsMobile, new GUIContent("Mobile"));
         GUILayout.Space(20);
 
+        EditorGUILayout.LabelField("Shaders", EditorStyles.boldLabel);
+        EditorGUILayout.PropertyField(this.compileURPShaders, new GUIContent("Compile URP Shaders") {
+            tooltip = "By default, your game will use a precompiled set of URP shaders for basic usage. Checking this box will compile URP shaders specifically for your game. If you have any advanced URP materials (or notice invisible materials on published games), you should check this box."
+        });
+        GUILayout.Space(20);
+
         foreach (var field in typeof(GameConfig).GetFields()) {
             if (field.Name is "gameId" or "gameLayers" || Attribute.IsDefined(field, typeof(HideInInspector))) continue; // Rendered above
 
@@ -107,6 +114,7 @@ public class GameConfigEditor : UnityEditor.Editor {
         }
 
         this.supportsMobile = serializedObject.FindProperty("supportsMobile");
+        this.compileURPShaders = serializedObject.FindProperty("compileURPShaders");
         
         updateSelectedGame += (update) => {
             var gameId = update.gameId;

package/Editor/Packages/AirshipPackagesWindow.cs

@@ -396,8 +396,8 @@ namespace Editor.Packages {
             // Uncomment to just build iOS
             if (isCoreMaterials) {
                 platforms.Clear();
-                // platforms.Add(AirshipPlatform.iOS);
-                platforms.Add(AirshipPlatform.Android);
+                platforms.Add(AirshipPlatform.iOS);
+                // platforms.Add(AirshipPlatform.Android);
                 // platforms.Add(AirshipPlatform.Windows);
                 // platforms.Add(AirshipPlatform.Mac);
             }
@@ -413,7 +413,10 @@ namespace Editor.Packages {
                 Repaint();
                 yield return null; // give time to repaint
 
-                List<AssetBundleBuild> builds = CreateAssetBundles.GetPackageAssetBundleBuilds();
+                // Act as if we are building all asset bundles (including CoreMaterials).
+                // This is so our current build target will have references to those asset bundles.
+                // This is paired with changes to Scriptable Build Pipeline that prevent these bundles from actually being built.
+                List<AssetBundleBuild> builds = CreateAssetBundles.GetPackageAssetBundleBuilds(true);
 
                 foreach (var platform in platforms) {
                     var st = Stopwatch.StartNew();

package/Editor/Settings/AirshipSettingsProvider.cs

@@ -153,8 +153,7 @@ public class AirshipSettingsProvider : SettingsProvider
             EditorIntegrationsConfig.instance.autoUpdatePackages = EditorGUILayout.Toggle(new GUIContent("Auto Update Packages", "Airship Packages will automatically update whenever a new update is available."), EditorIntegrationsConfig.instance.autoUpdatePackages);
             EditorIntegrationsConfig.instance.enableMainMenu = EditorGUILayout.Toggle(new GUIContent("Enable Main Menu", "When true, the main menu will show when pressing [Escape]."), EditorIntegrationsConfig.instance.enableMainMenu);
             EditorIntegrationsConfig.instance.buildWithoutUpload = EditorGUILayout.Toggle(new GUIContent("Build Without Upload", "When publishing, this will build the asset bundles but won't upload them to Airship. This is useful for testing file sizes with AssetBundle Browser."), EditorIntegrationsConfig.instance.buildWithoutUpload);
-            EditorIntegrationsConfig.instance.selfCompileAllShaders = EditorGUILayout.Toggle(new GUIContent("Self Compile All Shaders", "Instead of using pre-compiled shaders from CoreMaterials, you will compile all needed URP shaders when publishing. This makes publishing take significantly longer but reduces shader stripping issues."), EditorIntegrationsConfig.instance.selfCompileAllShaders);
-            
+
             // EditorIntegrationsConfig.instance.manageTypescriptProject = EditorGUILayout.Toggle(new GUIContent("Manage Typescript Projects", "Automatically update Typescript configuration files. (package.json, tsconfig.json)"), EditorIntegrationsConfig.instance.manageTypescriptProject);
 
             // EditorIntegrationsConfig.instance.typescriptAutostartCompiler = EditorGUILayout.Toggle(

package/Runtime/Code/Bootstrap/AirshipEntryPoint.cs

@@ -8,6 +8,8 @@ using UnityEngine;
 /// </summary>
 public class AirshipEntryPoint : Singleton<AirshipEntryPoint> {
     private void Start() {
+#if AIRSHIP_PLAYER
         Debug.unityLogger.logHandler = new AirshipLogHandler();
+#endif
     }
 }

package/Runtime/Code/Bundles/SystemRoot.cs

@@ -200,6 +200,9 @@ public class SystemRoot : Singleton<SystemRoot> {
 			enums.Add(this.UnloadBundleAsync(loadedBundle, keepCodeZip));
 		}
 		yield return this.WaitAll(enums.ToArray());
+		var unloadSW = Stopwatch.StartNew();
+		yield return Resources.UnloadUnusedAssets();
+		print("Unloaded unused assets in " + unloadSW.ElapsedMilliseconds + " ms.");
 
 		// code.zip
 		bool openCodeZips = RunCore.IsServer() || compileLuaOnClient;

package/Runtime/Code/GameConfig/GameConfig.cs

@@ -6,6 +6,7 @@ using Code.GameBundle;
 using UnityEditor;
 #endif
 using UnityEngine;
+using UnityEngine.Serialization;
 using Object = UnityEngine.Object;
 
 [CreateAssetMenu(fileName = "GameConfig", menuName = "Airship/GameConfig", order = 100)]
@@ -38,6 +39,8 @@ public class GameConfig : ScriptableObject
 
     [HideInInspector] public bool supportsMobile;
 
+    [HideInInspector] public bool compileURPShaders = false;
+
     private const string TagPrefix = "AirshipTag";
     public const int MaximumTags = 64;
 

package/Runtime/Code/Luau/LuauBuffer.cs

@@ -0,0 +1,17 @@
+namespace Luau {
+	/// <summary>
+	/// Represents a Luau buffer value. Any C# method that takes LuauBuffer as a parameter
+	/// will automatically accept "buffer" types from Luau. Similarly, any C# method that
+	/// returns a LuauBuffer will return a buffer type to Luau.
+	/// </summary>
+	public struct LuauBuffer {
+		public readonly byte[] Data;
+
+		public LuauBuffer(byte[] data) {
+			Data = data;
+		}
+		
+		public static implicit operator byte[](LuauBuffer buffer) => buffer.Data;
+		public static implicit operator LuauBuffer(byte[] data) => new (data);
+	}
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e4fff37edb924b9885f68d18cf643b6a
+timeCreated: 1754634257

package/Runtime/Code/Luau/LuauCore.cs

@@ -44,6 +44,7 @@ public partial class LuauCore : MonoBehaviour {
         POD_VECTOR4 = 15,
         POD_FLOAT = 16,
         POD_AIRSHIP_COMPONENT = 17,
+        POD_BUFFER = 18,
     };
 
     private static bool s_shutdown = false;
@@ -80,6 +81,7 @@ public partial class LuauCore : MonoBehaviour {
     private static Type planeType = typeof(UnityEngine.Plane);
     private static Type colorType = typeof(UnityEngine.Color);
     private static Type binaryBlobType = typeof(Assets.Luau.BinaryBlob);
+    private static Type luauBufferType = typeof(LuauBuffer);
     private static Type actionType = typeof(Action);
 
     private static readonly string[] protectedScenesNames = {

package/Runtime/Code/Luau/LuauCoreCallbacks.cs

@@ -639,6 +639,19 @@ public partial class LuauCore : MonoBehaviour {
                         }
                         break;
                     }
+
+                    case PODTYPE.POD_BUFFER: {
+                        if (t.IsAssignableFrom(luauBufferType)) {
+                            if (field != null) {
+                                field.SetValue(objectReference, NewLuauBufferFromPointer(propertyData, propertyDataSize));
+                            } else {
+                                SetValue<LuauBuffer>(objectReference, NewLuauBufferFromPointer(propertyData, propertyDataSize), property);
+                            }
+
+                            return 0;
+                        }
+                        break;
+                    }
                 }
             }
 

package/Runtime/Code/Luau/LuauCoreReflection.cs

@@ -471,6 +471,14 @@ public partial class LuauCore : MonoBehaviour
             WritePropertyToThreadInt32(thread, (int) value);
             return true;
         }
+        
+        if (t == luauBufferType) {
+            var buf = (LuauBuffer)value;
+            fixed (byte* bytesPtr = buf.Data) {
+                LuauPlugin.LuauPushValueToThread(thread, (int)PODTYPE.POD_BUFFER, new IntPtr(bytesPtr), buf.Data.Length);
+            }
+            return true;
+        }
 
         if (t.IsEnum) {
             System.Int32 integer = (System.Int32)value;
@@ -1011,6 +1019,10 @@ public partial class LuauCore : MonoBehaviour
                     parsedData[paramIndex] = NewMatrixFromPointer(intPtrs[i]);
                     continue;
                 }
+                case PODTYPE.POD_BUFFER: {
+                    parsedData[paramIndex] = NewLuauBufferFromPointer(intPtrs[i], sizes[i]);
+                    continue;
+                }
             }
 
             Debug.LogError("Param " + paramIndex + " " + podTypes[i] + " not valid type for this parameter/unhandled so far.");
@@ -1373,6 +1385,11 @@ public partial class LuauCore : MonoBehaviour
                         continue;
                     }
                     break;
+                case PODTYPE.POD_BUFFER:
+                    if (sourceParamType.IsAssignableFrom(luauBufferType)) {
+                        continue;
+                    }
+                    break;
             }
             return false;
         }
@@ -1563,6 +1580,12 @@ public partial class LuauCore : MonoBehaviour
         return 16 * sizeof(float);
     }
 
+    public static LuauBuffer NewLuauBufferFromPointer(IntPtr data, int size) {
+        var bytes = new byte[size];
+        Marshal.Copy(data, bytes, 0, size);
+        return new LuauBuffer(bytes);
+    }
+
     public static Plane NewPlaneFromPointer(IntPtr data) {
         Marshal.Copy(data, VectorData, 0, 4);
         return new Plane(new Vector3(VectorData[0], VectorData[1], VectorData[2]), VectorData[3]);

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

@@ -14,29 +14,23 @@ namespace Code.Network.Simulation
      * This component is used to allow lag compensation, prediction, and other networked state systems to
      * work with a networked object controlled by the server.
      *
-     * When this component is placed on a object being networked with Mirror, the server can include it
+     * When this component is placed on a object, the server can include it
      * in lag compensation and clients can resimulate their predictions more accurately.
      */
-    public class AirshipNetworkedObject : NetworkBehaviour
-    {
+    public class AirshipNetworkedObject : MonoBehaviour {
+        
+        [Tooltip("Adjusts the lag compensation timing by this amount in seconds. Useful to add or remove additional delay on the lag compensation request. Ex. Removing observer buffer delay for non-buffered entities.")]
+        [Range(-1, 1)]
+        public float bufferAdjustment = 0;
+        
         private History<TransformSnapshot> history;
 
         private void Start()
         {
-            if (isServer && authority)
-            {
-                history = new History<TransformSnapshot>(NetworkServer.sendRate);
-                AirshipSimulationManager.Instance.OnCaptureSnapshot += this.CaptureSnapshot;
-                AirshipSimulationManager.Instance.OnSetSnapshot += this.SetSnapshot;
-                AirshipSimulationManager.Instance.OnLagCompensationCheck += this.LagCompensationCheck;
-            }
-
-            if (isClient && !authority)
-            {
-                history = new History<TransformSnapshot>(NetworkClient.sendRate);
-                AirshipSimulationManager.Instance.OnCaptureSnapshot += this.CaptureSnapshot;
-                AirshipSimulationManager.Instance.OnSetSnapshot += this.SetSnapshot;
-            }
+            history = new History<TransformSnapshot>(1);
+            AirshipSimulationManager.Instance.OnCaptureSnapshot += this.CaptureSnapshot;
+            AirshipSimulationManager.Instance.OnSetSnapshot += this.SetSnapshot;
+            AirshipSimulationManager.Instance.OnLagCompensationCheck += this.LagCompensationCheck;
         }
 
         private void OnDestroy() {
@@ -74,10 +68,14 @@ namespace Code.Network.Simulation
             }
         }
 
-        private void LagCompensationCheck(int clientId, int tick, double time, double latency, double buffer)
+        private void LagCompensationCheck(int clientId, int tick, double time, double latency, double bufferTime)
         {
-            var bufferedTicks = Math.Round((latency - NetworkClient.bufferTime - Time.fixedDeltaTime) / Time.fixedDeltaTime);
-            this.SetSnapshot(tick - bufferedTicks);
+            var commandBufferTime = (NetworkServer.sendInterval * (NetworkClient.bufferTimeMultiplier / 2f));
+            
+            var totalBuffer = (latency * 2) + bufferTime + commandBufferTime;
+            var lagCompensatedTime = time - (totalBuffer + bufferAdjustment);
+            var lagCompensatedTick = AirshipSimulationManager.Instance.GetNearestTickForUnscaledTime(lagCompensatedTime);
+            this.SetSnapshot(lagCompensatedTick);
         }
     }
 }

package/Runtime/Code/Player/Character/Animation/CharacterAnimationHelper.cs

@@ -3,19 +3,16 @@ using Code.Player.Character.MovementSystems.Character;
 using Mirror;
 using UnityEngine;
 
-namespace Code.Player.Character.NetworkedMovement
-{
+namespace Code.Player.Character.NetworkedMovement {
     [LuauAPI]
-    public class CharacterAnimationHelper : MonoBehaviour
-    {
-        public enum CharacterAnimationLayer
-        {
+    public class CharacterAnimationHelper : MonoBehaviour {
+        public enum CharacterAnimationLayer {
             OVERRIDE_1 = 1,
             OVERRIDE_2 = 2,
             OVERRIDE_3 = 3,
             OVERRIDE_4 = 4,
             UPPER_BODY_1 = 5,
-            UPPER_BODY_2 = 6,
+            UPPER_BODY_2 = 6
         }
 
         [Header("References")]
@@ -39,6 +36,7 @@ namespace Code.Player.Character.NetworkedMovement
 
         [Header("Animation Calibration")]
         public float animWalkSpeed = 4.4444445f;
+
         public float animRunSpeed = 6.6666667f;
         public float animCrouchSpeed = 2.1233335f;
 
@@ -59,27 +57,22 @@ namespace Code.Player.Character.NetworkedMovement
 
         private void Awake() {
             // Make a new instance of the animator override controller
-            if (!this.animatorOverride)
-            {
-                if (this.animator.runtimeAnimatorController is AnimatorOverrideController over)
-                {
+            if (!animatorOverride) {
+                if (animator.runtimeAnimatorController is AnimatorOverrideController over) {
                     // Copy all the overrides if we already have an override controller in use
                     var overrides = new List<KeyValuePair<AnimationClip, AnimationClip>>(over.overridesCount);
                     over.GetOverrides(overrides);
-                    this.animatorOverride = new AnimatorOverrideController(animator.runtimeAnimatorController);
-                    this.animator.runtimeAnimatorController = this.animatorOverride;
-                    this.animatorOverride.ApplyOverrides(overrides);
-                }
-                else if (animator.runtimeAnimatorController)
-                {
-                    this.animatorOverride = new AnimatorOverrideController(animator.runtimeAnimatorController);
-                    this.animator.runtimeAnimatorController = this.animatorOverride;
+                    animatorOverride = new AnimatorOverrideController(animator.runtimeAnimatorController);
+                    animator.runtimeAnimatorController = animatorOverride;
+                    animatorOverride.ApplyOverrides(overrides);
+                } else if (animator.runtimeAnimatorController) {
+                    animatorOverride = new AnimatorOverrideController(animator.runtimeAnimatorController);
+                    animator.runtimeAnimatorController = animatorOverride;
                 }
             }
         }
 
-        private void Start()
-        {
+        private void Start() {
             // AnimatorOverrideController animatorOverrideController =
             //     new AnimatorOverrideController(this.animator.runtimeAnimatorController);
             // this.animator.runtimeAnimatorController = animatorOverrideController;
@@ -89,63 +82,51 @@ namespace Code.Player.Character.NetworkedMovement
             animator.SetFloat("AnimationOffset", offset);
         }
 
-        public void SetFirstPerson(bool firstPerson)
-        {
+        public void SetFirstPerson(bool firstPerson) {
             this.firstPerson = firstPerson;
-            if (this.firstPerson)
-            {
+            if (this.firstPerson) {
                 animator.SetLayerWeight(0, 0);
-            }
-            else
-            {
+            } else {
                 animator.SetLayerWeight(0, 1);
-                this.SetState(new() { state = this.currentState });
+                SetState(new CharacterAnimationSyncData { state = currentState });
             }
         }
 
-        private void LateUpdate()
-        {
+        private void LateUpdate() {
             UpdateAnimationState();
         }
 
-        private void OnEnable()
-        {
-            this.animator.Rebind();
+        private void OnEnable() {
+            animator.Rebind();
             GetRandomReactionLength();
 
             //Enter default state
             SetState(new CharacterAnimationSyncData());
         }
 
-        public bool IsInParticleDistance()
-        {
+        public bool IsInParticleDistance() {
             return true;
         }
 
-        private void UpdateAnimationState()
-        {
-            if (!enabled || !this.gameObject.activeInHierarchy)
-            {
+        private void UpdateAnimationState() {
+            if (!enabled || !gameObject.activeInHierarchy) {
                 return;
             }
 
             //Don't vary animation speeds if we are in the air or not moving
-            if (currentState == CharacterState.Airborne)
-            {
+            if (currentState == CharacterState.Airborne) {
                 targetPlaybackSpeed = 1;
-            }
-            else if ((currentState == CharacterState.Crouching && targetPlaybackSpeed < .1) ||
-                     targetPlaybackSpeed < .03)
-            {
+            } else if ((currentState == CharacterState.Crouching && targetPlaybackSpeed < .1) ||
+                       targetPlaybackSpeed < .03) {
                 targetVelNormalized = Vector2.zero;
                 targetPlaybackSpeed = 1;
             }
 
-            float currentMagnitude = currentVelNormalized.magnitude;
-            float targetMagnitude = targetVelNormalized.magnitude;
-            float blendMod = targetMagnitude > currentMagnitude
-                ? this.directionalBlendLerpMod
-                : this.directionalBlendLerpMod / 2f;
+            var currentMagnitude = currentVelNormalized.magnitude;
+            var targetMagnitude = targetVelNormalized.magnitude;
+            var blendMod = targetMagnitude > currentMagnitude
+                ? directionalBlendLerpMod
+                : directionalBlendLerpMod / 2f;
 
             //RUNNING SPEED
             //Speed up animations based on actual speed vs target speed
@@ -153,31 +134,28 @@ namespace Code.Player.Character.NetworkedMovement
             animator.SetFloat("MovementPlaybackSpeed", currentPlaybackSpeed);
 
             //Blend directional influence
-            float smoothXVelocity = 0f;
-            float smoothYVelocity = 0f;
-            float smoothTime = 0.025f;
+            var smoothXVelocity = 0f;
+            var smoothYVelocity = 0f;
+            var smoothTime = 0.025f;
 
             currentVelNormalized.x = Mathf.SmoothDamp(currentVelNormalized.x, targetVelNormalized.x,
                 ref smoothXVelocity, smoothTime, Mathf.Infinity, Time.deltaTime);
             currentVelNormalized.y = Mathf.SmoothDamp(currentVelNormalized.y, targetVelNormalized.y,
                 ref smoothYVelocity, smoothTime, Mathf.Infinity, Time.deltaTime);
-            float velX = Mathf.Abs(currentVelNormalized.x) < 0.01f ? 0 : currentVelNormalized.x;
-            float velZ = Mathf.Abs(currentVelNormalized.y) < 0.01f ? 0 : currentVelNormalized.y;
+            var velX = Mathf.Abs(currentVelNormalized.x) < 0.01f ? 0 : currentVelNormalized.x;
+            var velZ = Mathf.Abs(currentVelNormalized.y) < 0.01f ? 0 : currentVelNormalized.y;
             animator.SetFloat("VelX", velX);
             animator.SetFloat("VelY", Mathf.Lerp(animator.GetFloat("VelY"), verticalVel, Time.deltaTime * 1.5f));
             animator.SetFloat("VelZ", velZ);
             animator.SetFloat("Speed", targetMagnitude);
 
 
-            if (grounded)
-            {
+            if (grounded) {
                 lastGroundedTime = Time.time;
                 isSkidding = currentSpeed >= skiddingSpeed;
                 animator.SetBool("Skidding", isSkidding);
                 animator.SetBool("Airborne", false);
-            }
-            else
-            {
+            } else {
                 animator.SetBool("Skidding", false);
                 animator.SetBool("Airborne", Time.time - lastGroundedTime > minAirborneTime);
             }
@@ -196,65 +174,59 @@ namespace Code.Player.Character.NetworkedMovement
             // }
         }
 
-        private void GetRandomReactionLength()
-        {
-            nextIdleReactionLength = this.idleRectionLength +
-                                     Random.Range(-this.idleRectionLength / 2, this.idleRectionLength / 2);
+        private void GetRandomReactionLength() {
+            nextIdleReactionLength = idleRectionLength +
+                                     Random.Range(-idleRectionLength / 2, idleRectionLength / 2);
         }
 
-        public void SetVelocity(Vector3 localVel)
-        {
+        public void SetVelocity(Vector3 localVel) {
             currentSpeed = new Vector2(localVel.x, localVel.z).magnitude;
             //The target speed is the movement speed the animations were built for
             var targetSpeed = animWalkSpeed;
-            if (currentState == CharacterState.Sprinting)
-            {
+            if (currentState == CharacterState.Sprinting) {
                 if (currentSpeed < animWalkSpeed) {
                     //We will walk instead of run even though we are trying to run
                 } else {
                     targetSpeed = animRunSpeed;
                 }
-            }
-            else if (currentState == CharacterState.Crouching)
-            {
+            } else if (currentState == CharacterState.Crouching) {
                 targetSpeed = animCrouchSpeed;
             }
-            
+
             //Have to update sprinting state dynamically because low speeds can disable it
             animator.SetBool("Sprinting",
                 currentState == CharacterState.Sprinting && currentSpeed >= animWalkSpeed);
 
-            this.targetPlaybackSpeed = currentSpeed / targetSpeed;
+            targetPlaybackSpeed = currentSpeed / targetSpeed;
             targetVelNormalized = new Vector2(localVel.x, localVel.z).normalized;
             verticalVel = Mathf.Clamp(localVel.y, -10, 10);
             //print("currentSpeed: " + currentSpeed + " targetSpeed: " + targetSpeed + " playbackSpeed: " + targetPlaybackSpeed + " velNormalized: " + targetVelNormalized);
         }
 
-        public void SetState(CharacterAnimationSyncData syncedState)
-        {
-            if (!enabled || !this.gameObject.activeInHierarchy)
-            {
+        public void SetState(CharacterAnimationSyncData syncedState) {
+            if (!enabled || !gameObject.activeInHierarchy) {
                 return;
             }
 
             var newState = syncedState.state;
-            this.grounded = syncedState.grounded;
+            grounded = syncedState.grounded;
             animator.SetBool("Grounded", grounded);
+            // print("New State. Grounded: " + grounded + " state: " + syncedState.state + " Jumping: " +
+            //       syncedState.jumping);
             animator.SetBool("Crouching", syncedState.crouching || syncedState.state == CharacterState.Crouching);
 
             if (syncedState.jumping) {
                 SetTrigger("Jump");
             }
 
-            if (this.firstPerson)
-            {
+            if (firstPerson) {
                 animator.SetLayerWeight(0, 0);
             }
 
             lastStateTime = Time.time;
             currentState = newState;
 
-            this.SetVelocity(syncedState.localVelocity);
+            SetVelocity(syncedState.localVelocity);
             //print("Set state: " + currentState);
         }
 
@@ -267,16 +239,13 @@ namespace Code.Player.Character.NetworkedMovement
             animator.SetTrigger(trigger);
         }
 
-        public void SetLayerWeight(CharacterAnimationLayer layer, float weight)
-        {
+        public void SetLayerWeight(CharacterAnimationLayer layer, float weight) {
             var layerName = "Override" + (int)layer;
             animator.SetLayerWeight(animator.GetLayerIndex(layerName), weight);
         }
 
-        public void PlayAnimation(AnimationClip clip, CharacterAnimationLayer layer, float fixedTransitionDuration)
-        {
-            if (!enabled || !this.gameObject.activeInHierarchy)
-            {
+        public void PlayAnimation(AnimationClip clip, CharacterAnimationLayer layer, float fixedTransitionDuration) {
+            if (!enabled || !gameObject.activeInHierarchy) {
                 return;
             }
 
@@ -291,10 +260,8 @@ namespace Code.Player.Character.NetworkedMovement
                 animator.GetLayerIndex(stateName));
         }
 
-        public void StopAnimation(CharacterAnimationLayer layer, float fixedTransitionDuration)
-        {
-            if (!enabled || !this.gameObject.activeInHierarchy)
-            {
+        public void StopAnimation(CharacterAnimationLayer layer, float fixedTransitionDuration) {
+            if (!enabled || !gameObject.activeInHierarchy) {
                 return;
             }
 
@@ -302,9 +269,8 @@ namespace Code.Player.Character.NetworkedMovement
             animator.SetBool("Override" + (int)layer + "Looping", false);
         }
 
-        public float GetPlaybackSpeed()
-        {
-            return this.targetPlaybackSpeed;
+        public float GetPlaybackSpeed() {
+            return targetPlaybackSpeed;
         }
     }
 }