gg.easy.airship 0.1.2147 → 0.1.2148

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

@@ -23,7 +23,8 @@
         "GUID:ec266f293c0b4f6c9d06847488a52a0c",
         "GUID:325984b52e4128546bc7558552f8b1d2",
         "GUID:befe48b9a36afc04ea625c93daad910e",
-        "GUID:21d1eb854b91ade49bc69a263d12bee2"
+        "GUID:21d1eb854b91ade49bc69a263d12bee2",
+        "GUID:d8b63aba1907145bea998dd612889d6b"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

package/Runtime/Code/Luau/LuauCoreCallbacks.cs

@@ -663,7 +663,7 @@ public partial class LuauCore : MonoBehaviour {
 
     private static T GetValue<T>(object instance, PropertyGetReflectionCache cacheData) {
         if (typeof(T) == typeof(object) || cacheData.IsNativeClass || cacheData.IsStruct) {
-            return (T) cacheData.propertyInfo.GetMethod.Invoke(instance, null);
+            return (T) cacheData.propertyInfo.GetValue(instance);
         }
     
         if (!cacheData.HasGetPropertyFunc) {

package/Runtime/Code/Luau/ReflectionList.cs

@@ -4,6 +4,7 @@ using System.Reflection;
 using ElRaccoone.Tweens;
 using Mirror;
 using TMPro;
+using Unity.Mathematics;
 using UnityEngine;
 using UnityEngine.AI;
 using UnityEngine.Animations.Rigging;
@@ -191,6 +192,8 @@ namespace Luau {
             [typeof(CurveUtility)] = LuauContextAll,
             [typeof(SplineUtility)] = LuauContextAll,
             [typeof(BezierKnot)] = LuauContextAll,
+            [typeof(float3)] = LuauContextAll,
+            [typeof(SplineAnimate)] = LuauContextAll,
 
             // Rigging
             [typeof(TwoBoneIKConstraint)] = LuauContextAll,

package/Runtime/Code/LuauAPI/BezierCurveAPI.cs

@@ -0,0 +1,9 @@
+using System;
+using UnityEngine.Splines;
+
+[LuauAPI]
+public class BezierCurveAPI : BaseLuaAPIClass {
+    public override Type GetAPIType() {
+        return typeof(BezierCurve);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 294404385e5240499d356c2e24be088f
+timeCreated: 1750789147

package/Runtime/Code/LuauAPI/BezierKnotAPI.cs

@@ -0,0 +1,9 @@
+using System;
+using UnityEngine.Splines;
+
+[LuauAPI]
+public class BezierKnotAPI : BaseLuaAPIClass {
+    public override Type GetAPIType() {
+        return typeof(BezierKnot);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 814c95bc6e2b4631a9a19eaff11f8306
+timeCreated: 1750799536

package/Runtime/Code/LuauAPI/Bridge.cs

@@ -6,6 +6,7 @@ using Airship.DevConsole;
 using Code.VoiceChat;
 using Mirror;
 using Tayx.Graphy;
+using Unity.Mathematics;
 using UnityEngine;
 using UnityEngine.Networking;
 using UnityEngine.SceneManagement;
@@ -448,6 +449,10 @@ public static class Bridge {
         return scenes.ToArray();
     }
 
+    public static float3 MakeFloat3(Vector3 v) {
+        return new float3(v.x, v.y, v.z);
+    }
+
     public static void SetSkyboxMaterial(Material material) {
         RenderSettings.skybox = material;
     }

package/Runtime/Code/LuauAPI/CurveUtilityAPI.cs

@@ -0,0 +1,9 @@
+using System;
+using UnityEngine.Splines;
+
+[LuauAPI]
+public class CurveUtilityAPI : BaseLuaAPIClass {
+    public override Type GetAPIType() {
+        return typeof(CurveUtility);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ca4d12d19ec44c70966123b460995fb6
+timeCreated: 1750792387

package/Runtime/Code/LuauAPI/Float3API.cs

@@ -0,0 +1,9 @@
+using System;
+using Unity.Mathematics;
+
+[LuauAPI]
+public class Float3API : BaseLuaAPIClass {
+    public override Type GetAPIType() {
+        return typeof(float3);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 58fe41b1a8c74415aa712ecc2c966548
+timeCreated: 1750789056

package/Runtime/Code/LuauAPI/SplineAPI.cs

@@ -0,0 +1,9 @@
+using System;
+using UnityEngine.Splines;
+
+[LuauAPI]
+public class SplineAPI : BaseLuaAPIClass {
+    public override Type GetAPIType() {
+        return typeof(Spline);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 97306bd413f14568b70abf904252b964
+timeCreated: 1750789235

package/Runtime/Code/LuauAPI/SplineUtilityAPI.cs

@@ -0,0 +1,52 @@
+using System;
+using Unity.Mathematics;
+using UnityEngine.Splines;
+
+[LuauAPI]
+public class SplineUtilityAPI : BaseLuaAPIClass {
+    public override Type GetAPIType() {
+        return typeof(SplineUtility);
+    }
+
+    // public override int OverrideStaticMethod(LuauContext context, IntPtr thread, string methodName, int numParameters,
+    //     ArraySegment<int> parameterDataPODTypes, ArraySegment<IntPtr> parameterDataPtrs, ArraySegment<int> parameterDataSizes) {
+    //     
+    //     if (methodName == "EvaluatePosition") {
+    //         var spline = (ISpline) LuauCore.GetParameterAsObject(0, numParameters, parameterDataPODTypes, parameterDataPtrs,
+    //             parameterDataSizes, thread);
+    //
+    //         var f = LuauCore.GetParameterAsFloat(1, numParameters, parameterDataPODTypes, parameterDataPtrs,
+    //             parameterDataSizes);
+    //
+    //         var result = SplineUtility.EvaluatePosition(spline, f);
+    //         LuauCore.WritePropertyToThread(thread, result, typeof(float3));
+    //         return 1;
+    //     }
+    //     
+    //     if (methodName == "EvaluateTangent") {
+    //         var spline = (ISpline) LuauCore.GetParameterAsObject(0, numParameters, parameterDataPODTypes, parameterDataPtrs,
+    //             parameterDataSizes, thread);
+    //
+    //         var f = LuauCore.GetParameterAsFloat(1, numParameters, parameterDataPODTypes, parameterDataPtrs,
+    //             parameterDataSizes);
+    //
+    //         var result = SplineUtility.EvaluateTangent(spline, f);
+    //         LuauCore.WritePropertyToThread(thread, result, typeof(float3));
+    //         return 1;
+    //     }
+    //     
+    //     if (methodName == "EvaluateUpVector") {
+    //         var spline = (ISpline) LuauCore.GetParameterAsObject(0, numParameters, parameterDataPODTypes, parameterDataPtrs,
+    //             parameterDataSizes, thread);
+    //
+    //         var f = LuauCore.GetParameterAsFloat(1, numParameters, parameterDataPODTypes, parameterDataPtrs,
+    //             parameterDataSizes);
+    //
+    //         var result = SplineUtility.EvaluateUpVector(spline, f);
+    //         LuauCore.WritePropertyToThread(thread, result, typeof(float3));
+    //         return 1;
+    //     }
+    //
+    //     return -1;
+    // }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 84255f56d8ff4318b10e0e2e848fc5b8
+timeCreated: 1750791244

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

@@ -1080,96 +1080,78 @@ namespace Code.Player.Character.MovementSystems.Character {
                         }
                     }
                 } else {
+                    //GRID BASED EDGE DETECTION
                     //Find the edge of the characters collider
-                    var axisAlignedDir = new Vector3(Mathf.Round(velocityNorm.x), 0, Mathf.Round(velocityNorm.z));
-                    // if (Mathf.Abs(axisAlignedDir.x) > Mathf.Abs(axisAlignedDir.z)) {
-                    //     axisAlignedDir.z = 0;
-                    // } else {
-                    //     axisAlignedDir.x = 0;
-                    // }
-
+                    var smallRadius = (characterRadius - forwardMargin) * .9f;
                     var projectedPosition = transform.position + new Vector3(0, .1f, 0) +
-                                            axisAlignedDir * distanceCheck +
                                             velocityNorm * velocityMag;
 
                     if (drawDebugGizmos_CROUCH) {
                         GizmoUtils.DrawSphere(transform.position + new Vector3(0, .1f, 0), .05f, Color.black, 4, .1f);
-                        GizmoUtils.DrawSphere(transform.position + new Vector3(0, .1f, 0) +
-                                              axisAlignedDir * distanceCheck, .08f, Color.gray, 4, .1f);
+                        //GizmoUtils.DrawSphere(transform.position + new Vector3(0, .1f, 0) +
+                        //axisAlignedDir * distanceCheck, .08f, Color.gray, 4, .1f);
                         GizmoUtils.DrawSphere(projectedPosition, .1f, Color.blue, 4, .1f);
                     }
 
-                    //Cast to see if there is ground where we want to walk (to handle cases where you can walk across gaps even if technically there is air in the voxel you are stepping onto)
-                    var hitGround = Physics.BoxCast(projectedPosition,
-                        new Vector3(characterRadius - forwardMargin, .05f, characterRadius - forwardMargin),
-                        Vector3.down, out var groundHitInfo, Quaternion.identity, .25f,
-                        movementSettings.groundCollisionLayerMask);
-
-                    if (drawDebugGizmos_CROUCH) {
-                        GizmoUtils.DrawBox(projectedPosition, Quaternion.identity,
-                            new Vector3(characterRadius, .05f, characterRadius), Color.white, .1f);
-                        Debug.DrawLine(projectedPosition, projectedPosition + Vector3.down * .25f,
-                            hitGround ? Color.white : Color.red, .1f);
+                    var validGround = false;
+                    var groundCheckI = 0;
+                    var groundCheckPositions = new[] { projectedPosition, projectedPosition, projectedPosition };
+                    var groundVelocities = new[] { newVelocity, newVelocity, newVelocity };
+                    if (Mathf.Abs(newVelocity.x) > Mathf.Abs(newVelocity.z)) {
+                        //Check X Dir first
+                        groundCheckPositions[1].z = transform.position.z;
+                        groundCheckPositions[2].x = transform.position.x;
+                        groundVelocities[1].z = 0;
+                        groundVelocities[2].x = 0;
+                    } else {
+                        //Check Z dir first
+                        groundCheckPositions[1].x = transform.position.x;
+                        groundCheckPositions[2].z = transform.position.z;
+                        groundVelocities[1].x = 0;
+                        groundVelocities[2].z = 0;
                     }
 
-                    if (hitGround) {
-                        //Raycast to see if there is a path to this ground we found
-                        var rayCheckPos = transform.position + new Vector3(0, .175f, 0);
-                        var endPos = projectedPosition + new Vector3(0, .175f, 0);
-                        var dist = Vector3.Distance(groundHitInfo.point, rayCheckPos);
-                        if (Physics.Raycast(rayCheckPos, endPos - rayCheckPos, dist)) {
-                            //Something is in the way of the ground
-                            hitGround = false;
-                        }
+                    do {
+                        //Cast to see if there is ground where we want to walk (to handle cases where you can walk across gaps even if technically there is air in the voxel you are stepping onto)
+                        validGround = Physics.BoxCast(groundCheckPositions[groundCheckI],
+                            new Vector3(smallRadius, .05f, smallRadius),
+                            Vector3.down, out var groundHitInfo, Quaternion.identity, .25f,
+                            movementSettings.groundCollisionLayerMask);
 
                         if (drawDebugGizmos_CROUCH) {
-                            Debug.DrawLine(rayCheckPos, rayCheckPos + (endPos - rayCheckPos) * dist,
-                                hitGround ? Color.green : Color.magenta, .1f);
-                            GizmoUtils.DrawSphere(groundHitInfo.point, .05f, hitGround ? Color.green : Color.magenta, 4,
-                                .1f);
+                            GizmoUtils.DrawBox(groundCheckPositions[groundCheckI], Quaternion.identity,
+                                new Vector3(characterRadius, .05f, characterRadius),
+                                validGround ? Color.white : Color.red, .1f);
                         }
-                    }
 
-                    //var hitGround = false;
-
-                    if (!hitGround) {
-                        // Block Movement by pushing to perpendicular directions
-                        // Find out which directions are empty air
-                        var dirDistance = characterRadius + forwardMargin;
-                        var cornerDistance = characterRadius - forwardMargin;
-                        var offsetDirs = new Vector3[] {
-                            new(-dirDistance, .1f, 0),
-                            new(dirDistance, .1f, 0),
-                            new(0, .1f, -dirDistance),
-                            new(0, .1f, dirDistance),
-                            new(cornerDistance, .1f, -cornerDistance),
-                            new(cornerDistance, .1f, cornerDistance),
-                            new(-cornerDistance, .1f, -cornerDistance),
-                            new(-cornerDistance, .1f, cornerDistance)
-                        };
-                        Vector3 currentDir;
-                        Color color;
-                        for (var i = 0; i < offsetDirs.Length; i++) {
-                            color = Color.green;
-                            currentDir = offsetDirs[i];
-                            var dot = Vector3.Dot(newVelocity, currentDir);
-                            if (dot > 0 && !Physics.Raycast(transform.position + currentDir, Vector3.down, .25f,
+                        if (validGround) {
+                            //Raycast to see if there is a path to this ground we found
+                            var rayCheckPos = transform.position + new Vector3(0, .175f, 0);
+                            var endPos = groundCheckPositions[groundCheckI] + new Vector3(0, .175f, 0);
+                            var dist = Vector3.Distance(groundHitInfo.point, rayCheckPos);
+                            if (Physics.Raycast(rayCheckPos, endPos - rayCheckPos, dist,
                                     movementSettings.groundCollisionLayerMask)) {
-                                //Empty air in this dir
-                                newVelocity.x = currentDir.x == 0
-                                    ? Mathf.Sign(newVelocity.x) * Mathf.Abs(newVelocity.x)
-                                    : 0;
-                                newVelocity.z = currentDir.z == 0
-                                    ? Mathf.Sign(newVelocity.z) * Mathf.Abs(newVelocity.z)
-                                    : 0;
-                                color = Color.red;
+                                //Something is in the way of the ground
+                                validGround = false;
                             }
 
                             if (drawDebugGizmos_CROUCH) {
-                                Debug.DrawLine(transform.position + currentDir,
-                                    transform.position + offsetDirs[i] - Vector3.down * .25f, color, .1f);
+                                Debug.DrawLine(rayCheckPos, rayCheckPos + (endPos - rayCheckPos) * dist,
+                                    validGround ? Color.green : Color.magenta, .1f);
+                                GizmoUtils.DrawSphere(groundHitInfo.point, .05f,
+                                    validGround ? Color.green : Color.magenta, 4,
+                                    .1f);
                             }
                         }
+
+                        groundCheckI++;
+                    } while (!validGround && groundCheckI < 3);
+
+                    if (validGround) {
+                        newVelocity = groundVelocities[groundCheckI - 1];
+                    } else {
+                        newVelocity.x = 0;
+                        newVelocity.z = 0;
                     }
                 }
             }

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

@@ -323,11 +323,21 @@ namespace CsToTs.TypeScript {
                 var commentLines = GetFunctionComment(method);
                 string generics = "";
                 if (method.IsGenericMethod) {
-                    var genericPrms = method.GetGenericArguments().Select(t => GetTypeRef(t, context));
+                    var genericPrms = method.GetGenericArguments().Select(t => {
+                        var baseStr = GetTypeRef(t, context);
+                        var constraints = t.GetGenericParameterConstraints().Where(c => c != typeof(ValueType)).ToArray();
+                        if (constraints.Length > 0) {
+                            baseStr = $"{baseStr} extends {string.Join(" & ", constraints.Select((constraintType) => GetTypeRef(constraintType, context)))}";
+                        }
+                        return baseStr;
+                    });
                     generics = $"<{string.Join(", ", genericPrms)}>";
                 }
 
-                var parameters = method.GetParameters()
+                var paramInfos = method.GetParameters();
+                if (paramInfos.Any(p => p.IsOut)) continue; // Skip over any out variable methods
+                
+                var parameters = paramInfos
                     .Select(p => new MemberDefinition(p.Name, GetTypeRef(p.ParameterType, context)));
                 
                 var decorators = useDecorators(method);
@@ -596,6 +606,10 @@ namespace CsToTs.TypeScript {
                 return $"{typeName}<{string.Join(", ", genericPrms)}>";
             }
 
+            // Clear off the ending "&" from type name. This exists for ref types (which we support)
+            // and for out types (which we exclude anyway, so this doesn't matter for those).
+            typeName = typeName.Replace("&", "");
+            
             return typeName;
         }
         

package/Runtime/Code/TSCodeGen/TypeGenerator.cs

@@ -47,6 +47,7 @@ using UnityEngine.VFX;
 using Code.Player.Accessories;
 using Code.Player.Character.MovementSystems.Character;
 using Code.Player.Character.NetworkedMovement;
+using Unity.Mathematics;
 using UnityEngine.Splines;
 
 public class TypeGenerator : MonoBehaviour
@@ -258,6 +259,7 @@ public class TypeGenerator : MonoBehaviour
             typeof(Spline),
             typeof(SplineAnimate),
             typeof(SplineUtility),
+            typeof(float3),
 
             // Airship
             typeof(AnimationEventData),

package/package.json

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