gg.easy.airship 0.1.2167 → 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");
@@ -297,7 +297,7 @@ public static class CreateAssetBundles {
 		// 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();
+		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

@@ -416,7 +416,7 @@ namespace Editor.Packages {
                 // 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();
+                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/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/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;
         }
     }
 }

package/Runtime/Code/Player/Character/MovementSystems/Character/CharacterMovement.cs

@@ -28,8 +28,13 @@ namespace Code.Player.Character.MovementSystems.Character {
             CharacterInputData> {
         [FormerlySerializedAs("rigidbody")] public Rigidbody rb;
         public Transform rootTransform;
-        public Transform airshipTransform; // The visual transform controlled by this script. This always has the exact rotations used for movement
-        public Transform graphicTransform; // A transform that games can animate. This may have slightly altered rotation for visuals
+
+        public Transform
+            airshipTransform; // The visual transform controlled by this script. This always has the exact rotations used for movement
+
+        public Transform
+            graphicTransform; // A transform that games can animate. This may have slightly altered rotation for visuals
+
         public CharacterMovementSettings movementSettings;
         public BoxCollider mainCollider;
 
@@ -66,7 +71,8 @@ namespace Code.Player.Character.MovementSystems.Character {
         [Tooltip("If true, the character body will automatically rotate in the direction of the look vector.")]
         public bool rotateAutomatically = true;
 
-        [Tooltip("If enabled, the head will be rotated to look in the same direction as the look vector. The body will rotate only when needed. \"Rotate Automatically\" must also be checked.")]
+        [Tooltip(
+            "If enabled, the head will be rotated to look in the same direction as the look vector. The body will rotate only when needed. \"Rotate Automatically\" must also be checked.")]
         public bool rotateHeadToLookVector = true;
 
         [Tooltip("How much influence the look vector has on the look rotation.")]
@@ -75,7 +81,7 @@ namespace Code.Player.Character.MovementSystems.Character {
 
         [Tooltip("How far the head can rotate before the body rotates in degrees.")] [Range(0, 180)]
         public int headRotationThreshold = 60;
-        
+
         [Tooltip(
             "If true animations will be played on the server. This should be true if you care about character movement animations server-side (like for hit boxes).")]
         public bool playAnimationOnServer = true;
@@ -225,7 +231,7 @@ namespace Code.Player.Character.MovementSystems.Character {
             }
 
             _rig = GetComponentInChildren<CharacterRig>();
-            
+
             // Verify rig is setup correctly for rotateHeadToLookVector
             if (rotateHeadToLookVector) {
                 if (_rig == null || _rig.head == null || _rig.spine == null) {
@@ -236,7 +242,7 @@ namespace Code.Player.Character.MovementSystems.Character {
                     initialHeadRotation = _rig.head.rotation;
                 }
             }
-            
+
             _cameraTransform = Camera.main.transform;
         }
 
@@ -302,9 +308,9 @@ namespace Code.Player.Character.MovementSystems.Character {
             if (!rb.isKinematic) {
                 rb.linearVelocity = snapshot.velocity;
             }
-            
+
             HandleCharacterRotation(snapshot.lookVector);
-            
+
             OnSetSnapshot?.Invoke(snapshot);
         }
 
@@ -455,18 +461,15 @@ namespace Code.Player.Character.MovementSystems.Character {
                 currentMoveSnapshot.canJump = (byte)Math.Max(currentMoveSnapshot.canJump - 1, 0);
             }
 
-            var groundSlopeDir = detectedGround
-                ? Vector3.Cross(Vector3.Cross(groundHit.normal, Vector3.down), groundHit.normal).normalized
-                : transform.forward;
-            var slopeDot = 1 - Mathf.Max(0, Vector3.Dot(groundHit.normal, Vector3.up));
 
             var canStand = physics.CanStand();
-
-            var normalizedMoveDir = Vector3.ClampMagnitude(command.moveDir, 1);
+            var originalMoveDir = Vector3.ClampMagnitude(command.moveDir, 1);
+            var normalizedMoveDir = originalMoveDir;
             var characterMoveVelocity = normalizedMoveDir;
             //Save the crouching var
             currentMoveSnapshot.isCrouching = command.crouch;
 
+
 #region GRAVITY
 
             if (movementSettings.useGravity) {
@@ -572,7 +575,7 @@ namespace Code.Player.Character.MovementSystems.Character {
              */
             var isMoving = currentVelocity.sqrMagnitude > .1f;
             var inAir = didJump || (!detectedGround && !currentMoveSnapshot.prevStepUp);
-            var tryingToSprint =  movementSettings.onlySprintForward
+            var tryingToSprint = movementSettings.onlySprintForward
                 ? command.sprint && airshipTransform.InverseTransformVector(command.moveDir).z > 0.1f
                 : //Only sprint if you are moving forward
                 command.sprint && command.moveDir.magnitude > 0.1f; //Only sprint if you are moving
@@ -706,6 +709,67 @@ namespace Code.Player.Character.MovementSystems.Character {
 
 #endregion
 
+            
+#region SLOPE
+
+            if (drawDebugGizmos_GROUND) {
+                GizmoUtils.DrawSphere(transform.position + new Vector3(0, 1, 0), .1f, inAir ? Color.cyan : Color.white,
+                4, 5);
+            }
+            if (movementSettings.detectSlopes && grounded) {
+                var groundSlopeDir = Vector3.Cross(Vector3.Cross(groundHit.normal, Vector3.down), groundHit.normal)
+                    .normalized;
+                var slopeDot = 1 - Mathf.Max(0, Vector3.Dot(groundHit.normal, Vector3.up));
+
+                if (drawDebugGizmos_GROUND) {
+                    Debug.DrawLine(rootPosition, rootPosition + groundSlopeDir, Color.black, 5);
+                }
+
+                //Push the character based on the slope amount
+                if (slopeDot < 1 && movementSettings.slopeForce > 0) {
+                    var slopeVel = groundSlopeDir.normalized * slopeDot * slopeDot * movementSettings.slopeForce;
+                    if (slopeDot > movementSettings.maxSlopeDelta) {
+                        slopeVel.y = 0;
+                    }
+
+                    newVelocity += slopeVel;
+                }
+
+                //Project movement onto the slope
+                if (characterMoveVelocity.sqrMagnitude > .1 && groundHit.normal.y > 0) {
+                    //Adjust movement based on the slope of the ground you are on
+                    var newMoveDir = Vector3.ProjectOnPlane(normalizedMoveDir, groundHit.normal);
+                    //Only adjust for downward slopes
+                    //newMoveVector.y = Mathf.Min(0, newMoveVector.y);
+                    
+                    //Ignore tiny float imprecision's
+                    if (Mathf.Abs(newMoveDir.y) > .1f) {
+                        //Take the new direction and make it as fast as the intended move velocity
+                        normalizedMoveDir = newMoveDir;
+                        characterMoveVelocity = newMoveDir;
+                        grounded = true;
+                        if (drawDebugGizmos_GROUND) {
+                            Debug.DrawLine(rootPosition, rootPosition + normalizedMoveDir * .5f, Color.magenta,
+                                5);
+                            Debug.DrawLine(groundHit.point, groundHit.point + groundHit.normal * .5f, Color.red,
+                                5);
+                        }
+                        //}
+                    }
+                }
+
+                if (useExtraLogging && characterMoveVelocity.y < 0) {
+                    //print("Move Vector After: " + characterMoveVelocity + " groundHit.normal: " + groundHit.normal + " hitGround: " + groundHit.collider.gameObject.name);
+                }
+
+                if (slopeVisualizer) {
+                    slopeVisualizer.LookAt(slopeVisualizer.position +
+                                           (groundSlopeDir.sqrMagnitude < .1f ? transform.forward : groundSlopeDir));
+                }
+            }
+
+#endregion
+            
 #region MOVEMENT
 
             // Find speed
@@ -744,7 +808,7 @@ namespace Code.Player.Character.MovementSystems.Character {
                             currentMoveSnapshot.velocity.z);
                         var draggedHorizontal = horizontalVelocity * additionalDragMultiplier;
 
-                        characterMoveVelocity = new Vector3(draggedHorizontal.x, currentMoveSnapshot.velocity.y,
+                        characterMoveVelocity = new Vector3(draggedHorizontal.x, 0,
                             draggedHorizontal.z);
                     } else {
                         var targetVelocity = normalizedMoveDir * currentMoveSnapshot.currentSpeed;
@@ -762,57 +826,20 @@ namespace Code.Player.Character.MovementSystems.Character {
                         var velocityChange = Vector3.ClampMagnitude(velocityDiff, maxDelta * reverseScale);
 
                         characterMoveVelocity = currentMoveSnapshot.velocity + velocityChange;
+                        characterMoveVelocity.y = 0;
                     }
                 } else {
                     characterMoveVelocity *= currentMoveSnapshot.currentSpeed;
                 }
             }
 
-#region SLOPE
-
-            if (movementSettings.detectSlopes && detectedGround) {
-                //On Ground and detecting slopes
-                if (slopeDot < 1 && slopeDot > movementSettings.minSlopeDelta) {
-                    var slopeVel = groundSlopeDir.normalized * slopeDot * slopeDot * movementSettings.slopeForce;
-                    if (slopeDot > movementSettings.maxSlopeDelta) {
-                        slopeVel.y = 0;
-                    }
-
-                    newVelocity += slopeVel;
-                }
-
-
-                //Project movement onto the slope
-                if (characterMoveVelocity.sqrMagnitude > 0 && groundHit.normal.y > 0) {
-                    //Adjust movement based on the slope of the ground you are on
-                    var newMoveVector = Vector3.ProjectOnPlane(characterMoveVelocity, groundHit.normal);
-                    newMoveVector.y = Mathf.Min(0, newMoveVector.y);
-                    characterMoveVelocity = newMoveVector;
-                    if (drawDebugGizmos_STEPUP) {
-                        Debug.DrawLine(rootPosition, rootPosition + characterMoveVelocity * 2, Color.red);
-                    }
-                    //characterMoveVector.y = Mathf.Clamp( characterMoveVector.y, 0, moveData.maxSlopeSpeed);
-                }
-
-                if (useExtraLogging && characterMoveVelocity.y < 0) {
-                    //print("Move Vector After: " + characterMoveVelocity + " groundHit.normal: " + groundHit.normal + " hitGround: " + groundHit.collider.gameObject.name);
-                }
-            }
-
-            if (slopeVisualizer) {
-                slopeVisualizer.LookAt(slopeVisualizer.position +
-                                       (groundSlopeDir.sqrMagnitude < .1f ? transform.forward : groundSlopeDir));
-            }
-
-#endregion
-
 
 #region MOVE_FORCE
 
             //Clamp directional movement to not add forces if you are already moving in that direction
             var flatVelocity = new Vector3(newVelocity.x, 0, newVelocity.z);
-            var tryingToMove = normalizedMoveDir.sqrMagnitude > .1f;
-            var rawMoveDot = Vector3.Dot(flatVelocity.normalized, normalizedMoveDir);
+            var tryingToMove = originalMoveDir.sqrMagnitude > .1f;
+            var rawMoveDot = Vector3.Dot(flatVelocity.normalized, originalMoveDir.normalized);
             //print("Directional Influence: " + (characterMoveVector - newVelocity) + " mag: " + (characterMoveVector - currentVelocity).magnitude);
             var bumpSize = characterRadius + .15f;
 
@@ -958,9 +985,16 @@ namespace Code.Player.Character.MovementSystems.Character {
                     // if(Mathf.Abs(characterMoveVelocity.z) > Mathf.Abs(newVelocity.z)){
                     // 	newVelocity.z = characterMoveVelocity.z;
                     // }
+
+                    //If our current flat velocity is less then our intended velocity we can use our move velocity
                     if (moveMagnitude + .5f >= flatVelMagnitude) {
+                        //Snap velocity to our target move velocity
                         newVelocity.x = characterMoveVelocity.x;
                         newVelocity.z = characterMoveVelocity.z;
+                        if (grounded && !didJump && !currentMoveSnapshot.airborneFromImpulse &&
+                            !currentMoveSnapshot.prevStepUp) {
+                            newVelocity.y = characterMoveVelocity.y;
+                        } 
                     }
                 }
             } else {
@@ -979,10 +1013,10 @@ namespace Code.Player.Character.MovementSystems.Character {
                     if (flatVelMagnitude + addedForce < currentMoveSnapshot.currentSpeed) {
                         forwardMod = 1;
                     }
-
+                
                     //Apply the force
                     newVelocity += normalizedMoveDir * forwardMod * addedForce;
-
+                
                     //Never get faster than you've been impulsed
                     var flatVel = Vector3.ClampMagnitude(new Vector3(newVelocity.x, 0, newVelocity.z),
                         Mathf.Max(addedForce, flatVelMagnitude));
@@ -1017,18 +1051,18 @@ namespace Code.Player.Character.MovementSystems.Character {
                         SnapToY(pointOnRamp.y);
                         //airshipTransform.position = Vector3.MoveTowards(oldPos, transform.position, deltaTime);
                     }
-
+                
                     //print("STEPPED UP. Vel before: " + newVelocity);
                     newVelocity = Vector3.ClampMagnitude(
                         new Vector3(stepUpVel.x, Mathf.Max(stepUpVel.y, newVelocity.y), stepUpVel.z),
                         newVelocity.magnitude);
                     //print("PointOnRamp: " + pointOnRamp + " position: " + rootPosition + " vel: " + newVelocity);
-
+                
                     if (drawDebugGizmos_STEPUP) {
                         GizmoUtils.DrawSphere(oldPos, .01f, Color.red, 4, 4);
                         GizmoUtils.DrawSphere(rootPosition + newVelocity, .03f, new Color(1, .5f, .5f), 4, 4);
                     }
-
+                
                     currentMoveSnapshot.state =
                         groundedState; //Force grounded state since we are in the air for the step up
                     grounded = true;
@@ -1202,7 +1236,7 @@ namespace Code.Player.Character.MovementSystems.Character {
                 var forwardVector = flatVelocity.normalized * Mathf.Max(forwardDistance, bumpSize);
                 //print("Forward vec: " + forwardVector);
 
-                //Do raycasting after we have claculated our move direction
+                //Do raycasting after we have calculated our move direction
                 var forwardHits =
                     physics.CheckAllForwardHits(rootPosition - flatVelocity.normalized * -forwardMargin, forwardVector,
                         true,
@@ -1364,6 +1398,8 @@ namespace Code.Player.Character.MovementSystems.Character {
             //Execute the forces onto the rigidbody
             // if (isImpulsing) print("Impulsed velocity resulted in " + newVelocity);
             rb.linearVelocity = newVelocity;
+            // Debug.DrawLine(transform.position, transform.position + rb.linearVelocity * Time.fixedDeltaTime,
+            //     Color.green, 5);
 
 #endregion
 
@@ -1478,7 +1514,7 @@ namespace Code.Player.Character.MovementSystems.Character {
                 return;
             }
 
-            HandleCharacterRotation(this.lookVector);
+            HandleCharacterRotation(lookVector);
         }
 
         /**
@@ -1486,7 +1522,10 @@ namespace Code.Player.Character.MovementSystems.Character {
          * transform and visual rotation based on the configuration of the character.
          */
         private void HandleCharacterRotation(Vector3 lookVector) {
-            if (!rotateAutomatically) return;
+            if (!rotateAutomatically) {
+                return;
+            }
+
             UpdateCharacterRotation(lookVector);
         }
 
@@ -1513,49 +1552,49 @@ namespace Code.Player.Character.MovementSystems.Character {
                 airshipTransform.rotation = Quaternion.LookRotation(lookTarget).normalized;
                 return;
             }
-            
+
             UpdateBodyRotation(lookTarget);
             UpdateHeadRotation(lookDirection);
         }
-        
+
         private void UpdateBodyRotation(Vector3 direction) {
             direction.y = 0; // Don't rotate the character off the ground
-            
+
             // If we are moving, start rotating towards the correct direction immediately. Don't negate any additional rotation
-            if (this.currentMoveSnapshot.velocity.magnitude > 0) {
+            if (currentMoveSnapshot.velocity.magnitude > 0) {
                 airshipTransform.rotation = Quaternion.LookRotation(direction).normalized;
-                graphicTransform.rotation = Quaternion.Slerp(graphicTransform.rotation, airshipTransform.rotation, smoothedRotationSpeed * Mathf.Deg2Rad * Time.deltaTime);
+                graphicTransform.rotation = Quaternion.Slerp(graphicTransform.rotation, airshipTransform.rotation,
+                    smoothedRotationSpeed * Mathf.Deg2Rad * Time.deltaTime);
                 return;
             }
-            
+
             // Since graphicTransform is a child of the airship transform, we "undo" the
             // change we are going to apply so that we can rotate the graphicTransform independently
-            Quaternion previousParentRotation = airshipTransform.rotation;
+            var previousParentRotation = airshipTransform.rotation;
             airshipTransform.rotation = Quaternion.LookRotation(direction).normalized;
-            Quaternion deltaRotation = airshipTransform.rotation * Quaternion.Inverse(previousParentRotation);
+            var deltaRotation = airshipTransform.rotation * Quaternion.Inverse(previousParentRotation);
             graphicTransform.rotation = Quaternion.Inverse(deltaRotation) * graphicTransform.rotation;
-            
+
             // Now calculate if we need to rotate the graphicTransform (body) or if the head
             // rotation will be enough.
-            Vector3 currentForward = graphicTransform.rotation * Vector3.forward;
+            var currentForward = graphicTransform.rotation * Vector3.forward;
             currentForward.y = 0;
-            
+
             currentForward.Normalize();
             direction.Normalize();
 
-            float angle = Vector3.SignedAngle(currentForward, direction, Vector3.up);
-            if (Mathf.Abs(angle) > headRotationThreshold)
-            {
-                float rotateAmount = Mathf.Abs(angle) - headRotationThreshold;
-                float sign = Mathf.Sign(angle);
+            var angle = Vector3.SignedAngle(currentForward, direction, Vector3.up);
+            if (Mathf.Abs(angle) > headRotationThreshold) {
+                var rotateAmount = Mathf.Abs(angle) - headRotationThreshold;
+                var sign = Mathf.Sign(angle);
 
                 // We only rotate just enough to allow us to not snap our neck, but don't rotate the body
                 // any more than that.
-                Quaternion partialRotation = Quaternion.AngleAxis(rotateAmount * sign, Vector3.up);
+                var partialRotation = Quaternion.AngleAxis(rotateAmount * sign, Vector3.up);
                 graphicTransform.rotation = partialRotation * graphicTransform.rotation;
             }
         }
-        
+
         /**
          * Sets the head look direction independently of the body using "Look Vector Influence". Does _NOT_ limit the
          * amount of rotation from the body forward direction. Use UpdateCharacterRotation for rotation that take the configured
@@ -1567,9 +1606,11 @@ namespace Code.Player.Character.MovementSystems.Character {
             if (direction.magnitude == 0) {
                 direction = new Vector3(0, 0, 0.01f);
             }
-            
+
             var characterUp = _rig.spine ? _rig.spine.up : Vector3.up;
-            var lerpedLookRotation = Vector3.Lerp(Quaternion.Inverse(initialHeadRotation) * _rig.head.rotation * Vector3.forward, direction, lookVectorInfluence);
+            var lerpedLookRotation
+                = Vector3.Lerp(Quaternion.Inverse(initialHeadRotation) * _rig.head.rotation * Vector3.forward,
+                    direction, lookVectorInfluence);
             _rig.head.rotation = initialHeadRotation * Quaternion.LookRotation(lerpedLookRotation, characterUp);
         }
 

package/Runtime/Code/Player/Character/MovementSystems/Character/CharacterMovementSettings.cs

@@ -164,15 +164,12 @@ namespace Code.Player.Character.MovementSystems.Character {
 
 
         [Header("Slopes")]
-        [Tooltip("Auto detect slopes to create a downward drag. Disable as an optimization to skip raycast checks")]
+        [Tooltip("Detect slopes for smooth movement on ramps. Disable as an optimization to skip raycast checks")]
         public bool detectSlopes = false;
 
-        [Tooltip("The maximum force that pushes against the character when on a slope")] [Min(0f)]
+        [Tooltip("Increase to have slopes push the character downhill")] [Min(0f)]
         public float slopeForce = 45;
 
-        [Tooltip("Slopes below this threshold will be ignored. O is flat ground, 1 is a vertical wall")] [Range(0, 1)]
-        public float minSlopeDelta = .1f;
-
         [Tooltip("Slopes above this threshold will be treated as walls")] [Range(0, 1)]
         public float maxSlopeDelta = .3f;
     }

package/Runtime/Code/Player/Character/MovementSystems/Character/CharacterPhysics.cs

@@ -88,6 +88,8 @@ namespace Code.Player.Character.MovementSystems.Character {
             Vector3 vel,
             Vector3 moveDir) {
             //start the cast slightly off to account for clipping into colliders when falling very fast 
+            var gravityDir = -_movement.transform.up;
+            var gravityDirOffset = gravityDir.normalized * .1f;
             var verticalOffset = 1 + Mathf.Max(-vel.y, 0);
             var intersectionMargin = .075f;
             var castDistance = .2f + verticalOffset;
@@ -99,8 +101,6 @@ namespace Code.Player.Character.MovementSystems.Character {
                 Mathf.Max(0, -vel.y) +
                 offsetMargin; // Mathf.Min(0, movement.transform.InverseTransformVector(vel).y); //Need this part of we change gravity dir
 
-            var gravityDir = -_movement.transform.up;
-            var gravityDirOffset = gravityDir.normalized * .1f;
 
             //Check directly below character as an early out and for comparison information
             if (Physics.Raycast(castStartPos, gravityDir, out var rayHitInfo, castDistance,
@@ -150,7 +150,7 @@ namespace Code.Player.Character.MovementSystems.Character {
                 if (!ignoredColliders.ContainsKey(hitInfo.collider.GetInstanceID())) {
                     //Physics Casts give you interpolated normals. This uses a ray to find an exact normal
                     hitInfo.normal = CalculateRealNormal(hitInfo.normal,
-                        hitInfo.point + gravityDirOffset + moveDir.normalized * .01f, gravityDir, .11f,
+                        currentPos, hitInfo.point - currentPos, .11f,
                         _movement.movementSettings.groundCollisionLayerMask);
 
                     if (_movement.drawDebugGizmos_GROUND) {

package/Runtime/Code/TSCodeGen/Editor/CsToTs/TypeScript/Helper.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using System.Xml;
 using Code.Luau;
 using HandlebarsDotNet;
+using Luau;
 using Unity.VisualScripting;
 using UnityEditor;
 using UnityEngine;
@@ -570,6 +571,10 @@ namespace CsToTs.TypeScript {
                 return enumDef != null ? enumDef.Name : "unknown";
             }
 
+            if (type == typeof(LuauBuffer)) {
+                return "buffer";
+            }
+
             var typeCode = Type.GetTypeCode(type);
             if (typeCode != TypeCode.Object) 
                 return GetPrimitiveMemberType(typeCode, context.Options);

package/package.json

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