gg.easy.airship 0.1.2195 → 0.1.2196

package/Editor/AirshipBuildInfoEditor.cs

@@ -0,0 +1,151 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Airship.Editor;
+using Code.Luau;
+using Editor.Packages;
+using Luau;
+using UnityEditor;
+using UnityEngine;
+
+[CustomEditor(typeof(AirshipBuildInfo))]
+
+public class AirshipBuildInfoEditor : UnityEditor.Editor {
+    private Vector2 pos = default;
+    private string searchText = "";
+
+    private Dictionary<string, bool> typeToExpandState = new();
+    
+    public void OnBehaviourMeta(AirshipBehaviourMeta airshipBehaviourMeta) {
+        var type = AirshipBuildInfo.Instance.GetTypeByPathAndName(airshipBehaviourMeta.assetPath, airshipBehaviourMeta.className);
+        if (type == null) return;
+        {
+            typeToExpandState.TryGetValue(type.UniqueId, out var toggleState);
+
+            var rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight);
+            var nextToggleState = EditorGUI.BeginFoldoutHeaderGroup(rect, toggleState, new GUIContent(ObjectNames.NicifyVariableName(type.Name)));
+            
+            EditorGUI.LabelField(new Rect(rect) { width = 200, x = rect.xMin + rect.width - 200 }, type.DeclarationType.ToString(),new GUIStyle(EditorStyles.label) {
+                alignment = TextAnchor.MiddleRight
+            });
+            
+            if (nextToggleState) {
+                EditorGUILayout.BeginVertical(new GUIStyle() {
+                    margin = new RectOffset(2, 2, 2, 2),
+                    // padding = new RectOffset(5,5,5,5),
+                    fixedWidth = 0,
+                });
+                {
+                    GUI.enabled = false;
+                    EditorGUILayout.EnumPopup("Declaration Type", type.DeclarationType);
+                    EditorGUILayout.LabelField("Asset Path", type.AssetPath);
+                    EditorGUILayout.LabelField("Runtime Path", type.RuntimePath.ToLower());
+                    EditorGUILayout.ObjectField("Script", type.Script, typeof(AirshipScript));
+                    
+                    if (airshipBehaviourMeta.extends.Count > 0) {
+                        AirshipEditorGUI.Heading(new GUIContent("Inherits"));
+                        foreach (var inheritance in airshipBehaviourMeta.extends) {
+                            EditorGUILayout.LabelField(inheritance);
+                        }
+                    }
+                    GUI.enabled = true;
+                }
+                EditorGUILayout.EndVertical();
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+            if (nextToggleState != toggleState) {
+                if (!typeToExpandState.TryAdd(type.UniqueId, nextToggleState)) {
+                    typeToExpandState[type.UniqueId] = nextToggleState;
+                }
+            }
+        }
+        
+    }
+    //
+    // public void OnType(AirshipType airshipType) {
+    //     EditorGUILayout.BeginHorizontal();
+    //     {
+    //         
+    //         EditorGUILayout.LabelField(ObjectNames.NicifyVariableName(airshipType.Name), airshipType.DeclarationType.ToString());
+    //     }
+    //     EditorGUILayout.EndHorizontal();
+    // }
+
+    private int packageId = 0;
+    public override void OnInspectorGUI() {
+        var buildInfo = (AirshipBuildInfo)target;
+
+        List<AirshipBehaviourMeta> gameMetas = new List<AirshipBehaviourMeta>();
+        List<AirshipBehaviourMeta> packageMetas = new List<AirshipBehaviourMeta>();
+        
+        
+        
+        foreach (var info in buildInfo.data.airshipBehaviourMetas) {
+            if (searchText != "" && !info.className.StartsWith(searchText, StringComparison.OrdinalIgnoreCase)) continue;
+            
+            if (info.assetPath.StartsWith("Assets/AirshipPackages/@Easy/Core")) {
+                packageMetas.Add(info);
+            } else {
+                gameMetas.Add(info);
+            }
+        }
+        
+        foreach (var info in buildInfo.data.airshipScriptableObjectMetas) {
+            if (searchText != "" && !info.className.StartsWith(searchText, StringComparison.OrdinalIgnoreCase)) continue;
+            
+            if (info.assetPath.StartsWith("Assets/AirshipPackages/@Easy/Core")) {
+                packageMetas.Add(info);
+            } else {
+                gameMetas.Add(info);
+            }
+        }
+        
+        var prevEnabled = GUI.enabled;
+        GUI.enabled = true;
+
+        List<string> items = new List<string>();
+        items.Add("Game");
+        
+        foreach (var package in GameConfig.Load().packages) {
+            items.Add(package.id);
+        }
+        
+        EditorGUILayout.BeginHorizontal();
+        searchText = EditorGUILayout.TextField(searchText, EditorStyles.toolbarSearchField);
+        EditorGUILayout.LabelField("Scope", GUILayout.Width(50));
+        packageId = EditorGUILayout.Popup(packageId, items.ToArray(), GUILayout.Width(150));
+        EditorGUILayout.EndHorizontal();
+
+        var selectedItem = items[packageId];
+        
+        // pos = EditorGUILayout.BeginScrollView(pos);
+        // {
+ 
+
+            if (selectedItem.StartsWith("@")) {
+                if (packageMetas.Count > 0) {
+                    foreach (var info in packageMetas) {
+                        if (info.assetPath.StartsWith("Assets/AirshipPackages/" + selectedItem)) OnBehaviourMeta(info);
+                    }
+                }      
+            } else {
+                if (gameMetas.Count > 0) {
+                    foreach (var info in gameMetas) {
+                        OnBehaviourMeta(info);
+                    }
+                }
+            }
+
+            
+            // AirshipEditorGUI.Heading(new GUIContent("Airship Scriptable Objects"));
+            // foreach (var info in buildInfo.data.airshipScriptableObjectMetas) {
+            //     OnBehaviourMeta(info);
+            // }
+        // }
+        // EditorGUILayout.EndScrollView();
+
+        GUI.enabled = prevEnabled;
+    }
+}
+#endif

package/Editor/AirshipBuildInfoEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 27b655bf3c554869bba1781e5c02eaca
+timeCreated: 1762759109

package/Editor/AirshipComponents/AirshipComponentHeaderHandler.cs

@@ -7,8 +7,10 @@ using UnityEngine.UIElements;
 [InitializeOnLoad]
 public class AirshipComponentHeaderHandler {
     static AirshipComponentHeaderHandler() {
+#if !AIRSHIP_PLAYER
         UnityEditor.Editor.finishedDefaultHeaderGUI -= AfterInspectorRootEditorHeaderGUI;
         UnityEditor.Editor.finishedDefaultHeaderGUI += AfterInspectorRootEditorHeaderGUI;
+#endif
     }
 
     private static void AfterGameObjectHeaderGUI(UnityEditor.Editor gameObjectEditor) {

package/Editor/AirshipEditors/AirshipCustomEditors.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
+using HandlebarsDotNet.PathStructure;
 using TypescriptAst;
 using Luau;
 using UnityEditor;
@@ -34,7 +35,7 @@ public static class AirshipCustomEditors {
     private static Dictionary<string, Type> decoratorNameToEditorType = new();
     
     internal const string inspectorModeKey = "AirshipBetaInspectorMode";
-    internal const EditorInspectorMode DefaultInspectorMode = EditorInspectorMode.UseLegacyInspector;
+    internal const EditorInspectorMode DefaultInspectorMode = EditorInspectorMode.UseNewInspector;
     #endregion
     
     #region Properties
@@ -88,7 +89,7 @@ public static class AirshipCustomEditors {
     
     private static bool RegisterEditor(Type editorType, CustomAirshipEditorAttribute editorAttribute) {
         var typeName = editorAttribute.TypeName;
-        var filePath = editorAttribute.FilePath;
+        var filePath = editorAttribute.AssetPath;
                 
         var pathType = string.IsNullOrEmpty(filePath) ? 
             AirshipBuildInfo.Instance.GetTypeByName(typeName) :  
@@ -202,22 +203,37 @@ public static class AirshipCustomEditors {
         return instances;
     }
     
-    internal static Type GetEditorTypeForTypeName(string typeName) {
+    internal static Type GetEditorTypeForTypeName(string typeName, AirshipDeclarationType? airshipDeclarationType = null) {
         if (!UseNewInspector) return null;
+      
         
         var pathType = AirshipBuildInfo.Instance.GetTypeByName(typeName);
         if (pathType == null) return null;
+
+        airshipDeclarationType ??= pathType.DeclarationType;
         
         if (airshipTypeToCustomEditor.TryGetValue(pathType, out var editorType)) {
             return editorType.EditorType;
         }
-
-        return typeof(DefaultAirshipComponentEditor);
+        
+        return airshipDeclarationType switch {
+            AirshipDeclarationType.Unknown => null,
+            AirshipDeclarationType.AirshipBehaviour => typeof(DefaultAirshipComponentEditor),
+            AirshipDeclarationType.Enum => null,
+            AirshipDeclarationType.AirshipScriptableObject => typeof(DefaultAirshipScriptableObjectEditor),
+            AirshipDeclarationType.SerializableClass => typeof(DefaultAirshipSerializableObjectEditor),
+            _ => null
+        };
     }
 
     internal static bool TryGetEditorForComponent(AirshipComponent component, Type type, out AirshipEditor editor) {
         return instanceToAirshipEditor.TryGetValue(component.GetInstanceID(), out editor);
     }
+
+    internal static bool TryGetEditorForScriptableObject(AirshipScriptableObject scriptableObject, Type type,
+        out AirshipEditor editor) {
+        return instanceToAirshipEditor.TryGetValue(scriptableObject.GetInstanceID(), out editor);
+    }
     
     internal static AirshipEditor GetEditorForComponent(AirshipComponent component, Type type, SerializedObject serializedObject) {
         if (instanceToAirshipEditor.TryGetValue(component.GetInstanceID(), out var editor)) {
@@ -232,8 +248,44 @@ public static class AirshipCustomEditors {
         instanceToAirshipEditor.Add(component.GetInstanceID(), editor);
         return editor;
     }
+    
+#if AIRSHIPEX_CLASS_OBJECT
+    internal static AirshipEditor GetEditorForClass(AirshipSerializableClassObject component, Type type, SerializedObject serializedObject) {
+        if (instanceToAirshipEditor.TryGetValue(component.GetInstanceID(), out var editor)) {
+            editor.serializedObject ??= new AirshipSerializedObject();
+            editor.serializedObject.Update(editor, serializedObject, component.metadata);
+            return editor;
+        }
 
+        editor = (AirshipEditor) ScriptableObject.CreateInstance(type);
+        editor.serializedObject ??= new AirshipSerializedObject();
+        editor.serializedObject.Update(editor, serializedObject, component.metadata);
+        instanceToAirshipEditor.Add(component.GetInstanceID(), editor);
+        return editor;
+    }
+#endif
+    
+    internal static AirshipEditor GetEditorForScriptableObject(AirshipScriptableObject scriptableObject, Type type, SerializedObject serializedObject) {
+        if (instanceToAirshipEditor.TryGetValue(scriptableObject.GetInstanceID(), out var editor)) {
+            editor.serializedObject ??= new AirshipSerializedObject(scriptableObject);
+            editor.serializedObject.Update(editor, serializedObject, scriptableObject.script.m_metadata);
+            return editor;
+        }
 
+        editor = (AirshipEditor) ScriptableObject.CreateInstance(type);
+        editor.serializedObject ??= new AirshipSerializedObject();
+        editor.serializedObject.Update(editor, serializedObject, scriptableObject.script.m_metadata);
+        instanceToAirshipEditor.Add(scriptableObject.GetInstanceID(), editor);
+        return editor;
+    }
+
+    internal static AirshipEditor GetScriptableObjectEditorForType(AirshipType airshipType, AirshipScriptableObject scriptableObject, AirshipSerializedObject serializedObject) {
+        if (airshipType.DeclarationType != AirshipDeclarationType.AirshipScriptableObject) return null;
+        var editorType = AirshipCustomEditors.GetEditorTypeForTypeName(airshipType.Name);
+        var editor = AirshipCustomEditors.GetEditorForScriptableObject(scriptableObject, editorType, serializedObject);
+        return editor;
+    }
+    
     internal static AirshipEditor GetComponentEditorForType(AirshipType airshipType, AirshipComponent component, AirshipSerializedObject serializedObject) {
         if (airshipType.DeclarationType != AirshipDeclarationType.AirshipBehaviour) return null;
         var editorType = AirshipCustomEditors.GetEditorTypeForTypeName(airshipType.Name);
@@ -298,6 +350,23 @@ public static class AirshipCustomEditors {
         return null;
     }
     
+    /// <summary>
+    /// Get the editor for the given AirshipScriptableObject
+    /// </summary>
+    /// <param name="scriptableObject">The scriptable object to get the editor for</param>
+    /// <returns>The editor, if it exists otherwise null</returns>
+    public static AirshipEditor GetEditor(AirshipScriptableObject scriptableObject) {
+        if (scriptableObject != null && scriptableObject.script != null) {
+            var airshipType = scriptableObject.GetAirshipType();
+            
+            var serializedObject = new AirshipSerializedObject();
+            serializedObject.Update(null, new SerializedObject(scriptableObject), serializedObject.metadata);
+            return GetScriptableObjectEditorForType(airshipType, scriptableObject, serializedObject);
+        }
+
+        return null;
+    }
+    
     #endregion
     
     private static void DestroyEditor(int editorId) {

package/Editor/AirshipEditors/AirshipCustomMenus.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using Editor.EditorInternal;
+using Luau;
+using UnityEditor;
+
+[FilePath("Temp/AirshipCustomMenuState", FilePathAttribute.Location.ProjectFolder)]
+internal class AirshipCustomMenus : ScriptableSingleton<AirshipCustomMenus> {
+    public Dictionary<string, string> assetPathToMenuItemPaths = new ();
+    
+    internal void AddCreateAssetMenu(string scriptPath, string fileName, string menuItem, int priority = 0) {
+        if (AirshipEditorInternals.HasUnityMenuItem(menuItem)) return;
+
+        if (assetPathToMenuItemPaths.TryGetValue(scriptPath, out var existingMenuItem)) {
+            if (existingMenuItem != menuItem) {
+                AirshipEditorInternals.RemoveUnityMenuItem(existingMenuItem);
+            }
+        }
+        
+        AirshipEditorInternals.AddUnityMenuItem(menuItem, "", false, priority, () => {
+            var asset = AssetDatabase.LoadAssetAtPath<AirshipScript>(scriptPath);
+            AirshipScriptableObjectEditor.CreateAirshipScriptableObject(asset, fileName);
+        }, () => true);
+        assetPathToMenuItemPaths.TryAdd(scriptPath, menuItem);
+    }
+    
+    internal void RegisterMenus() {
+        List<string> assetPathsToRemove = new List<string>();
+        foreach (var assetPathToMenuItemPath in assetPathToMenuItemPaths) {
+            var asset = AssetDatabase.LoadAssetAtPath<AirshipScript>(assetPathToMenuItemPath.Key);
+            if (asset == null) {
+                assetPathsToRemove.Add(assetPathToMenuItemPath.Key);
+            }
+        }
+
+        foreach (var assetPath in assetPathsToRemove) {
+            if (assetPathToMenuItemPaths.TryGetValue(assetPath, out var existingMenuItem)) {
+                AirshipEditorInternals.RemoveUnityMenuItem(existingMenuItem);
+            }
+
+            assetPathToMenuItemPaths.Remove(assetPath);
+        }
+    }
+
+    internal void Save() {
+        Save(false);
+    }
+}

package/Editor/AirshipEditors/AirshipCustomMenus.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4f27464a44bb46b1b6ac2426222535d7
+timeCreated: 1762754145

package/Editor/AirshipEditors/AirshipEditor.cs

@@ -37,6 +37,7 @@ public abstract class AirshipEditor : ScriptableObject {
     }
     
     public AirshipSerializedObject serializedObject { get; internal set; }
+    internal SerializedObject unitySerializedObject => serializedObject.serializedObject;
     public UnityEngine.Object target { get; internal set; }
     public AirshipScript script { get; internal set; }
 
@@ -121,7 +122,7 @@ public abstract class AirshipEditor : ScriptableObject {
     /// <summary>
     /// Draw the default properties for this inspector
     /// </summary>
-    private void DrawDefaultProperties() {
+    protected void DrawDefaultProperties() {
         // Draw each property
         foreach (var property in serializedObject.GetProperties()) {
             var shouldHideProperty = false;
@@ -141,7 +142,16 @@ public abstract class AirshipEditor : ScriptableObject {
             }
 
             if (shouldHideProperty) continue;
+            
             AirshipEditorGUI.PropertyField(property);
+            
+#if AIRSHIP_DEBUG
+            var propertyMetadata = property.scriptPropertyMetadata;
+            if (propertyMetadata.defaultValue != null) {
+                EditorGUILayout.LabelField(LuauMetadataPropertySerializer.SerializeAirshipProperty(propertyMetadata.defaultValue, propertyMetadata.ComponentType));
+            }
+            AirshipEditorGUI.HorizontalLine();
+#endif
         }
     }
 
@@ -159,20 +169,24 @@ public abstract class AirshipEditor : ScriptableObject {
 #if AIRSHIP_INTERNAL
     private void DrawInternalDebug() {
         if (Application.isPlaying) {
-            var binding = (AirshipComponent)target;
-            if (binding == null) return;
+            if (target is AirshipComponent component) {
+                AirshipEditorGUI.HorizontalLine();
+                EditorGUILayout.BeginHorizontal();
+                {
+                    EditorGUILayout.LabelField("GameObject Id", AirshipBehaviourRootV2.GetId(component.gameObject).ToString());
+                    EditorGUILayout.LabelField("Component Id", component.GetAirshipComponentId().ToString());
+                }
+                EditorGUILayout.EndHorizontal();
             
-            AirshipEditorGUI.HorizontalLine();
-            EditorGUILayout.BeginHorizontal();
-            {
-                EditorGUILayout.LabelField("GameObject Id", AirshipBehaviourRootV2.GetId(binding.gameObject).ToString());
-                EditorGUILayout.LabelField("Component Id", binding.GetAirshipComponentId().ToString());
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Context", component.context.ToString());
+                EditorGUILayout.EndHorizontal();
+            } else if (target is AirshipScriptableObject scriptableObject) {
+                if (AirshipScriptableObjectRoot.ContainsScriptableObject(scriptableObject)) {
+                    AirshipEditorGUI.HorizontalLine();
+                    EditorGUILayout.LabelField("Scriptable Id", AirshipScriptableObjectRoot.GetIdFromScriptableObject(scriptableObject).ToString());
+                }
             }
-            EditorGUILayout.EndHorizontal();
-            
-            EditorGUILayout.BeginHorizontal();
-            EditorGUILayout.LabelField("Context", binding.context.ToString());
-            EditorGUILayout.EndHorizontal();
         }
     }
 #endif

package/Editor/AirshipEditors/AirshipSerializedObject.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using JetBrains.Annotations;
 using Luau;
 using UnityEditor;
@@ -31,15 +33,23 @@ public class AirshipSerializedObject {
     internal SerializedProperty serializedProperties => serializedMetadata.FindPropertyRelative("properties");
     internal SerializedProperty serializedName => serializedObject.FindProperty("name");
     internal LuauMetadata metadata { get; private set; }
-    internal AirshipEditor editor { get; private set; }
+    internal AirshipEditor editor { get; set; }
 
     public AirshipType airshipType => AirshipBuildInfo.Instance.GetTypeByName(serializedName.stringValue);
+    [Obsolete]
     public AirshipComponent airshipComponent => (AirshipComponent)serializedObject.targetObject;
     public UnityEngine.Object targetObject => serializedObject.targetObject;
     
     internal AirshipSerializedObject() {}
     public AirshipSerializedObject(AirshipComponent component) => Update(null, new SerializedObject(component), component.metadata);
-    
+    public AirshipSerializedObject(AirshipScriptableObject scriptableObject) =>
+        Update(null, new SerializedObject(scriptableObject), scriptableObject.metadata);
+
+#if AIRSHIPEX_CLASS_OBJECT
+    public AirshipSerializedObject(AirshipSerializableClassObject luauObject) =>
+        Update(null, new SerializedObject(luauObject), luauObject.metadata);
+#endif    
+
     [CanBeNull]
     internal AirshipSerializedObject prefabAsset {
         get {
@@ -79,9 +89,7 @@ public class AirshipSerializedObject {
             var propertyName = property.FindPropertyRelative("name").stringValue;
             if (propertyName == targetPropertyName) {
                 var propertyMetadata = metadata.FindProperty(targetPropertyName);
-               
                 var airshipProperty = new AirshipSerializedProperty(this, property, propertyMetadata, this.editor);
-                // _propertyCache.Add(targetPropertyName, airshipProperty);
                 return airshipProperty;
             }
         }

package/Editor/AirshipEditors/CustomAirshipEditorAttribute.cs

@@ -8,12 +8,17 @@ using NUnit.Framework.Internal;
 [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
 public class CustomAirshipEditorAttribute : Attribute {
     public string TypeName { get; }
-    public string FilePath { get; set; }
+    public string AssetPath { get; set; }
     public int Priority { get; set; } = 0;
 
     public CustomAirshipEditorAttribute(string className) {
         TypeName = className;
     }
+
+    public CustomAirshipEditorAttribute(string className, string assetPath) {
+        TypeName = className;
+        AssetPath = assetPath;
+    }
 }
 
 [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]

package/Editor/AirshipEditors/DefaultAirshipComponentEditor.cs

@@ -12,4 +12,39 @@ public class DefaultAirshipComponentEditor : AirshipEditor {
         // By default we just draw the default inspector here.
         DrawDefaultInspector();
     }
+}
+
+/// <summary>
+/// The default editor for airship components
+/// </summary>
+public class DefaultAirshipScriptableObjectEditor : AirshipEditor {
+    private void OnScriptSelectionChanged(AirshipScript targetScript) {
+        unitySerializedObject.FindProperty("script").objectReferenceValue = targetScript;
+        unitySerializedObject.ApplyModifiedProperties();
+        unitySerializedObject.Update();
+    }
+    
+    public override void OnInspectorGUI() {
+        EditorGUILayout.Space(5);
+
+        if (script != null) {
+            GUI.enabled = script == null;
+            EditorGUILayout.ObjectField(new GUIContent("Script"), script, typeof(AirshipScript), false);
+            GUI.enabled = true;
+        } else {
+            var rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight);
+            AirshipEditorGUI.AirshipScriptField(rect, new GUIContent("Script"), script, OnScriptSelectionChanged, AirshipEditorGUI.ScriptExportType.ScriptableObject);
+        }
+        
+        EditorGUILayout.Space(5);
+        
+        DrawDefaultProperties();
+    }
+}
+
+public class DefaultAirshipSerializableObjectEditor : AirshipEditor {
+    public override void OnInspectorGUI() {
+        EditorGUILayout.HelpBox("Serializable Class Objects are not yet supported at Runtime", MessageType.Error);
+        DrawDefaultProperties();
+    }
 }

package/Editor/AirshipEditors/Properties/AirshipEditorExtensions.cs

@@ -16,7 +16,7 @@ public static class AirshipEditorExtensions {
     public static T GetObject<T>(this AirshipSerializedValue value) where T : UnityEngine.Object {
         return (T) GetObject(value);
     }
-
+    
     /// <summary>
     /// Grab the type of the given AirshipComponent
     /// </summary>
@@ -28,6 +28,34 @@ public static class AirshipEditorExtensions {
         return AirshipBuildInfo.Instance.GetTypeByName(component.script.m_metadata.name);
     }
 
+#if AIRSHIPEX_CLASS_OBJECT
+    public static AirshipType GetAirshipType(this AirshipSerializableClassObject luauObject) {
+        if (luauObject.metadata == null) return null;
+        return AirshipBuildInfo.Instance.GetTypeByName(luauObject.metadata.name);
+    }
+#endif
+
+    public static LuauMetadata GetMetadataForType(this AirshipType type) {
+        var script = type.Script;
+        if (script == null) return null;
+        if (script.m_metadata != null && script.m_metadata.name == type.Name) return script.m_metadata;
+        if (script.m_serializables != null) {
+            foreach (var serializable in script.m_serializables) {
+                if (serializable.name == type.Name) {
+                    return serializable;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public static AirshipType GetAirshipType(this AirshipScriptableObject scriptableObject) {
+        if (scriptableObject.script == null) return null;
+        if (scriptableObject.script.m_metadata == null) return null;
+        return AirshipBuildInfo.Instance.GetTypeByName(scriptableObject.script.m_metadata.name);
+    }
+
     private static IEnumerable<string> GetPathParts(Transform transform) {
         var parent = transform;
         while (parent != null) {
@@ -56,7 +84,7 @@ public static class AirshipEditorExtensions {
     public static AirshipType GetComponentType(this AirshipScript script) {
         // TODO: Get types by path
         if (script.m_metadata != null) {
-            return AirshipBuildInfo.Instance.GetTypeByPathAndName(script.assetPath, script.m_metadata.name);
+            return AirshipBuildInfo.Instance.GetTypeByPathAndName(script.assetPath, script.m_metadata.name) ?? AirshipBuildInfo.Instance.GetTypeByName(script.m_metadata.name);
         }
         
         return null;

package/Editor/AirshipEditors/Properties/AirshipSerializedArray.cs

@@ -6,19 +6,19 @@ using UnityEditor;
 using Object = UnityEngine.Object;
 
 public class AirshipSerializedArray {
+    private readonly SerializedProperty serializedItems;
+    private readonly SerializedProperty serializedObjects;
     public AirshipSerializedProperty property { get; }
     public AirshipSerializedType elementType =>
         AirshipSerializedValue.GetTypeFromTypeString(property.serializedItems.FindPropertyRelative("type").stringValue);
-
+    public bool isObjectArray => elementType is AirshipSerializedType.Object or AirshipSerializedType.AirshipBehaviour
+        or AirshipSerializedType.AirshipScriptableObject;
     public string elementObjectTypeString => property.serializedItems.FindPropertyRelative("objectType").stringValue;
     
     [CanBeNull]
     public Type elementObjectType => TypeReflection.GetTypeFromString(property.serializedItems.FindPropertyRelative("objectType").stringValue);
     [CanBeNull]
     public AirshipType elementAirshipType => AirshipBuildInfo.Instance.GetTypeByName(property.serializedItems.FindPropertyRelative("objectType").stringValue);
-    
-    private readonly SerializedProperty serializedItems;
-    private readonly SerializedProperty serializedObjects;
 
     public bool prefabOverride => serializedItems.prefabOverride || serializedObjects.prefabOverride;
 
@@ -70,9 +70,7 @@ public class AirshipSerializedArray {
     }
 
     public int size {
-        get {
-            return this.serializedItems.arraySize;
-        }
+        get => isObjectArray ? this.serializedObjects.arraySize : this.serializedItems.arraySize;
     }
     
     public AirshipSerializedArrayValue PushElement() {
@@ -83,17 +81,23 @@ public class AirshipSerializedArray {
     }
     
     public AirshipSerializedArrayValue InsertLastElement(Object obj) {
-        if (this.elementType == AirshipSerializedType.Object) {
-            var element = PushElement();
-            element.objectReferenceValue = obj;
-            return element;
-        } else if (this.elementType == AirshipSerializedType.AirshipBehaviour && obj is AirshipComponent component) {
-            var element = PushElement();
-            element.objectReferenceValue = component;
-            return element;
+        if (!isObjectArray) throw new ArgumentException("Cannot insert object into non-object array", nameof(obj));
+        var element = PushElement();
+        if (obj == null) return element;
+
+        var (isExpectedType, expectedTypeName) = elementType switch {
+            AirshipSerializedType.Object => (obj.GetType() == elementObjectType, obj.GetType().Name),
+            AirshipSerializedType.AirshipBehaviour => (obj is AirshipComponent ac && ac.GetAirshipType() == elementAirshipType, elementAirshipType!.Name),
+            AirshipSerializedType.AirshipScriptableObject => (obj is AirshipScriptableObject aso && aso.GetAirshipType() == elementAirshipType, elementAirshipType!.Name),
+            _ => (false, elementType.ToString()),
+        };
+
+        if (!isExpectedType) {
+            throw new ArgumentException($"Inserted value is not a {expectedTypeName}");
         }
-
-        return null;
+        
+        element.objectReferenceValue = obj;
+        return element;
     }
     
     public AirshipSerializedArrayValue GetElementAtIndex(int index) {
@@ -134,7 +138,7 @@ public class AirshipSerializedArray {
     }
 
     public static implicit operator SerializedProperty(AirshipSerializedArray array) {
-        if (array.elementType is AirshipSerializedType.Object or AirshipSerializedType.AirshipBehaviour) {
+        if (array.isObjectArray) {
             return array.serializedObjects;
         } else {
             return array.serializedItems;