@nice2dev/game-engine 1.0.5 → 1.0.10

package/dist/cjs/unity-integration/UnityImport.js

@@ -0,0 +1,1252 @@
+'use strict';
+
+/**
+ * @file UnityImport.ts
+ * @description Unity Project Import system for Nice2Dev Game Engine
+ * PRO-1.8.1: Unity Project Import
+ *
+ * Features:
+ * - Unity Project Importer (scene, prefab, hierarchy, components)
+ * - Unity Asset Database Integration (meta files, GUIDs, dependencies)
+ * - Unity Animation Import (clips, controllers, masks, events)
+ * - Unity Script Import (MonoBehaviour parsing, SerializeField extraction)
+ */
+function parseUnityYAML(content) {
+    const documents = [];
+    // Unity YAML uses --- !u! markers
+    const docRegex = /--- !u!(\d+) &(\d+)(?:\s+stripped)?/g;
+    const matches = [...content.matchAll(docRegex)];
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        const classID = parseInt(match[1], 10);
+        const fileID = parseInt(match[2], 10);
+        // Find content between this document and next
+        const startIdx = match.index + match[0].length;
+        const endIdx = i < matches.length - 1 ? matches[i + 1].index : content.length;
+        const docContent = content.slice(startIdx, endIdx).trim();
+        // Parse YAML content (simplified parser)
+        const data = parseUnityYAMLContent(docContent);
+        documents.push({
+            fileID,
+            classID,
+            stripped: match[0].includes('stripped'),
+            data,
+        });
+    }
+    return documents;
+}
+function parseUnityYAMLContent(content) {
+    const result = {};
+    const lines = content.split('\n');
+    const stack = [
+        { obj: result, indent: -1 },
+    ];
+    for (const line of lines) {
+        if (!line.trim() || line.trim().startsWith('#')) {
+            continue;
+        }
+        const indent = line.search(/\S/);
+        const trimmed = line.trim();
+        // Pop stack until we find parent with smaller indent
+        while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+            stack.pop();
+        }
+        const parent = stack[stack.length - 1].obj;
+        // Check for key: value
+        const colonIdx = trimmed.indexOf(':');
+        if (colonIdx > 0) {
+            const key = trimmed.slice(0, colonIdx).trim();
+            const value = trimmed.slice(colonIdx + 1).trim();
+            if (value === '' || value === '{}') {
+                // Nested object
+                const nested = {};
+                parent[key] = nested;
+                stack.push({ obj: nested, indent });
+            }
+            else if (value.startsWith('{') && value.endsWith('}')) {
+                // Inline object like {fileID: 0}
+                parent[key] = parseInlineYAML(value);
+            }
+            else if (value.startsWith('[') && value.endsWith(']')) {
+                // Inline array
+                parent[key] = parseInlineArray(value);
+            }
+            else {
+                // Simple value
+                parent[key] = parseYAMLValue(value);
+            }
+        }
+        else if (trimmed.startsWith('- ')) {
+            // Array element
+            trimmed.slice(2).trim();
+        }
+    }
+    return result;
+}
+function parseInlineYAML(inline) {
+    const result = {};
+    // Remove braces
+    const content = inline.slice(1, -1).trim();
+    if (!content) {
+        return result;
+    }
+    // Split by comma (simplified, doesn't handle nested)
+    const pairs = content.split(',');
+    for (const pair of pairs) {
+        const [key, value] = pair.split(':').map((s) => s.trim());
+        if (key && value !== undefined) {
+            result[key] = parseYAMLValue(value);
+        }
+    }
+    return result;
+}
+function parseInlineArray(inline) {
+    const content = inline.slice(1, -1).trim();
+    if (!content) {
+        return [];
+    }
+    // Simplified array parsing
+    return content.split(',').map((s) => parseYAMLValue(s.trim()));
+}
+function parseYAMLValue(value) {
+    // Remove quotes if present
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    // Boolean
+    if (value === 'true' || value === '1') {
+        return true;
+    }
+    if (value === 'false' || value === '0') {
+        return false;
+    }
+    // Null
+    if (value === 'null' || value === '~' || value === '') {
+        return null;
+    }
+    // Number
+    const num = parseFloat(value);
+    if (!isNaN(num) && isFinite(num)) {
+        return num;
+    }
+    return value;
+}
+function parseUnityMeta(content) {
+    // Meta files are simpler YAML
+    const lines = content.split('\n');
+    const meta = {
+        guid: '',
+        importerType: 'unknown',
+        importSettings: {},
+    };
+    for (const line of lines) {
+        if (line.startsWith('guid:')) {
+            meta.guid = line.slice(5).trim();
+        }
+        else if (line.includes('Importer:') || line.includes('importer:')) {
+            meta.importerType = line.split(':')[0].trim();
+        }
+        else if (line.startsWith('timeCreated:')) {
+            meta.timestamp = parseInt(line.slice(12).trim(), 10);
+        }
+        else if (line.startsWith('userData:')) {
+            meta.userData = line.slice(9).trim();
+        }
+    }
+    return meta;
+}
+// ============================================================
+// Unity Class ID Mapping
+// ============================================================
+const UNITY_CLASS_IDS = {
+    1: 'GameObject',
+    2: 'Component',
+    3: 'LevelGameManager',
+    4: 'Transform',
+    20: 'Camera',
+    21: 'Material',
+    23: 'MeshRenderer',
+    25: 'Renderer',
+    28: 'Texture2D',
+    33: 'MeshFilter',
+    43: 'Mesh',
+    48: 'Shader',
+    49: 'TextAsset',
+    54: 'Rigidbody',
+    56: 'Collider',
+    61: 'BoxCollider',
+    64: 'MeshCollider',
+    65: 'SphereCollider',
+    82: 'AudioSource',
+    83: 'AudioClip',
+    84: 'RenderTexture',
+    87: 'MeshAnimator',
+    89: 'Cubemap',
+    91: 'AnimationClip',
+    93: 'RuntimeAnimatorController',
+    95: 'Animator',
+    104: 'RenderSettings',
+    108: 'Light',
+    109: 'CGProgram',
+    111: 'Animation',
+    114: 'MonoBehaviour',
+    115: 'MonoScript',
+    120: 'LineRenderer',
+    122: 'TrailRenderer',
+    124: 'Behaviour',
+    128: 'Font',
+    134: 'PhysicMaterial',
+    135: 'SphereCollider',
+    136: 'CapsuleCollider',
+    137: 'SkinnedMeshRenderer',
+    142: 'AssetBundle',
+    143: 'Prefab',
+    150: 'PreviewAnimationClip',
+    152: 'AudioListener',
+    156: 'Terrain',
+    157: 'TerrainCollider',
+    158: 'TerrainData',
+    177: 'VideoClip',
+    181: 'VideoPlayer',
+    183: 'Sprite',
+    184: 'CachedSpriteAtlas',
+    186: 'ReflectionProbe',
+    187: 'ReflectionProbes',
+    188: 'Terrain',
+    189: 'LightProbes',
+    191: 'LightProbeGroup',
+    192: 'SpriteAtlas',
+    193: 'SpriteAtlasDatabase',
+    195: 'NavMeshArea',
+    196: 'NavMeshAgent',
+    198: 'ParticleSystem',
+    199: 'ParticleSystemRenderer',
+    200: 'ShaderVariantCollection',
+    205: 'LODGroup',
+    206: 'BlendTree',
+    207: 'AudioMixer',
+    208: 'AudioMixerController',
+    212: 'SpriteRenderer',
+    213: 'Tilemap',
+    218: 'AudioMixerGroup',
+    220: 'CinemachineVirtualCamera',
+    221: 'AnimatorOverrideController',
+    222: 'Canvas',
+    223: 'CanvasRenderer',
+    224: 'RectTransform',
+    225: 'CanvasGroup',
+    226: 'BillboardAsset',
+    227: 'BillboardRenderer',
+    228: 'SpeedTreeWindAsset',
+    229: 'AnchoredJoint2D',
+    230: 'Joint2D',
+    231: 'SpringJoint2D',
+    232: 'DistanceJoint2D',
+    233: 'HingeJoint2D',
+    234: 'SliderJoint2D',
+    235: 'WheelJoint2D',
+    238: 'NavMeshData',
+    240: 'AudioMixerSnapshot',
+    241: 'AudioMixerEffectController',
+    243: 'PhysicsMaterial2D',
+    244: 'Rigidbody2D',
+    245: 'Collider2D',
+    246: 'BoxCollider2D',
+    247: 'CircleCollider2D',
+    248: 'CompositeCollider2D',
+    249: 'EdgeCollider2D',
+    250: 'PolygonCollider2D',
+    251: 'CapsuleCollider2D',
+    328: 'VideoClip',
+    334: 'PlayerSettings',
+    367: 'VideoPlayer',
+};
+function getUnityClassName(classID) {
+    return UNITY_CLASS_IDS[classID] ?? `Unknown_${classID}`;
+}
+class UnityProjectImporter {
+    constructor() {
+        this.callbacks = {};
+    }
+    // ─── Project Scanning ──────────────────────────────────
+    async scanProject(projectPath) {
+        this.project = {
+            name: this.extractProjectName(projectPath),
+            path: projectPath,
+            unityVersion: '',
+            renderPipeline: 'builtin',
+            assets: new Map(),
+            scenes: [],
+            prefabs: [],
+            scripts: [],
+            materials: [],
+            missingRefs: [],
+        };
+        // Detect Unity version from ProjectSettings
+        this.project.unityVersion = await this.detectUnityVersion(projectPath);
+        // Detect render pipeline
+        this.project.renderPipeline = await this.detectRenderPipeline(projectPath);
+        // Scan Assets folder
+        await this.scanAssetsFolder(`${projectPath}/Assets`);
+        // Build dependency graph
+        this.buildDependencyGraph();
+        // Detect missing references
+        this.detectMissingReferences();
+        this.callbacks.onProjectScanned?.(this.project);
+        return this.project;
+    }
+    extractProjectName(path) {
+        const parts = path.replace(/\\/g, '/').split('/');
+        return parts[parts.length - 1] || 'UnknownProject';
+    }
+    async detectUnityVersion(projectPath) {
+        // Read ProjectSettings/ProjectVersion.txt
+        // In real implementation, read from file system
+        // Format: m_EditorVersion: 2022.3.10f1
+        return '2022.3.10f1';
+    }
+    async detectRenderPipeline(projectPath) {
+        // Check for URP/HDRP packages in Packages/manifest.json
+        // Or check QualitySettings for render pipeline asset
+        return 'builtin';
+    }
+    async scanAssetsFolder(assetsPath) {
+        // In real implementation, use file system to scan
+        // For now, simulate scanning
+        this.callbacks.onScanProgress?.('Scanning assets...', 0);
+        // This would recursively scan directories and process:
+        // - .meta files for GUIDs
+        // - .unity files for scenes
+        // - .prefab files for prefabs
+        // - .cs files for scripts
+        // - .mat files for materials
+        // - etc.
+    }
+    // ─── Scene Import ──────────────────────────────────────
+    async importScene(scenePath, sceneContent) {
+        const documents = parseUnityYAML(sceneContent);
+        const scene = {
+            name: this.extractFileName(scenePath),
+            path: scenePath,
+            objects: new Map(),
+            roots: [],
+        };
+        // First pass: create all objects
+        for (const doc of documents) {
+            const typeName = getUnityClassName(doc.classID);
+            scene.objects.set(doc.fileID, {
+                fileID: doc.fileID,
+                type: typeName,
+                classID: doc.classID,
+                data: doc.data,
+            });
+            // Extract settings
+            if (typeName === 'RenderSettings') {
+                scene.renderSettings = doc.data;
+            }
+            else if (typeName === 'LightmapSettings') {
+                scene.lightmapSettings = doc.data;
+            }
+            else if (typeName === 'NavMeshSettings') {
+                scene.navMeshSettings = doc.data;
+            }
+            else if (typeName === 'OcclusionCullingSettings') {
+                scene.occlusionSettings = doc.data;
+            }
+        }
+        // Second pass: find root objects
+        for (const obj of scene.objects.values()) {
+            if (obj.type === 'Transform') {
+                const transform = obj.data['Transform'];
+                if (transform) {
+                    const parent = transform['m_Father'];
+                    if (!parent || parent.fileID === 0) {
+                        // This is a root transform, find its GameObject
+                        const goRef = transform['m_GameObject'];
+                        if (goRef?.fileID) {
+                            scene.roots.push(goRef.fileID);
+                        }
+                    }
+                }
+            }
+        }
+        this.callbacks.onSceneImported?.(scene);
+        return scene;
+    }
+    extractFileName(path) {
+        const parts = path.replace(/\\/g, '/').split('/');
+        const filename = parts[parts.length - 1];
+        return filename.replace(/\.[^/.]+$/, '');
+    }
+    // ─── Prefab Import ─────────────────────────────────────
+    async importPrefab(prefabPath, prefabContent, guid) {
+        const documents = parseUnityYAML(prefabContent);
+        const prefab = {
+            name: this.extractFileName(prefabPath),
+            guid,
+            path: prefabPath,
+            rootFileID: 0,
+            objects: new Map(),
+            isVariant: false,
+        };
+        // Check if it's a prefab variant
+        for (const doc of documents) {
+            const typeName = getUnityClassName(doc.classID);
+            if (typeName === 'PrefabInstance') {
+                prefab.isVariant = true;
+                const prefabInstance = doc.data['PrefabInstance'];
+                if (prefabInstance) {
+                    const sourceRef = prefabInstance['m_SourcePrefab'];
+                    if (sourceRef?.guid) {
+                        prefab.basePrefabGUID = sourceRef.guid;
+                    }
+                }
+            }
+            prefab.objects.set(doc.fileID, {
+                fileID: doc.fileID,
+                type: typeName,
+                classID: doc.classID,
+                data: doc.data,
+            });
+        }
+        // Find root transform
+        for (const obj of prefab.objects.values()) {
+            if (obj.type === 'Transform') {
+                const transform = obj.data['Transform'];
+                if (transform) {
+                    const parent = transform['m_Father'];
+                    if (!parent || parent.fileID === 0) {
+                        const goRef = transform['m_GameObject'];
+                        if (goRef?.fileID) {
+                            prefab.rootFileID = goRef.fileID;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        this.callbacks.onPrefabImported?.(prefab);
+        return prefab;
+    }
+    // ─── Script Import ─────────────────────────────────────
+    parseScript(scriptPath, scriptContent, guid) {
+        const scriptInfo = {
+            guid,
+            path: scriptPath,
+            type: 'script',
+            className: '',
+            isMonoBehaviour: false,
+            isScriptableObject: false,
+            serializedFields: [],
+            publicMethods: [],
+            unityMessages: [],
+            dependencies: [],
+            dependents: [],
+        };
+        // Parse C# content
+        scriptContent.split('\n');
+        // Extract namespace
+        const namespaceMatch = scriptContent.match(/namespace\s+([\w.]+)/);
+        if (namespaceMatch) {
+            scriptInfo.namespace = namespaceMatch[1];
+        }
+        // Extract class declaration
+        const classMatch = scriptContent.match(/class\s+(\w+)\s*(?::\s*([\w,\s<>]+))?/);
+        if (classMatch) {
+            scriptInfo.className = classMatch[1];
+            const baseClasses = classMatch[2]?.split(',').map((s) => s.trim()) ?? [];
+            scriptInfo.isMonoBehaviour = baseClasses.some((b) => b === 'MonoBehaviour' || b.includes('MonoBehaviour'));
+            scriptInfo.isScriptableObject = baseClasses.some((b) => b === 'ScriptableObject' || b.includes('ScriptableObject'));
+        }
+        // Parse fields and methods
+        const fieldRegex = /\[SerializeField\][\s\S]*?(?:private|protected)?\s*([\w<>[\],\s]+)\s+(\w+)\s*[;=]/g;
+        const publicFieldRegex = /public\s+([\w<>[\],\s]+)\s+(\w+)\s*[;=]/g;
+        const methodRegex = /(?:public|private|protected)\s+(?:override\s+)?(?:virtual\s+)?(?:async\s+)?(\w+(?:<[\w,\s]+>)?)\s+(\w+)\s*\(/g;
+        // Extract SerializeField fields
+        let fieldMatch;
+        while ((fieldMatch = fieldRegex.exec(scriptContent)) !== null) {
+            const field = this.parseFieldDeclaration(fieldMatch[1], fieldMatch[2], false, true);
+            scriptInfo.serializedFields.push(field);
+        }
+        // Extract public fields (auto-serialized)
+        while ((fieldMatch = publicFieldRegex.exec(scriptContent)) !== null) {
+            const field = this.parseFieldDeclaration(fieldMatch[1], fieldMatch[2], true, false);
+            // Exclude static fields
+            if (!scriptContent
+                .slice(Math.max(0, fieldMatch.index - 20), fieldMatch.index)
+                .includes('static')) {
+                scriptInfo.serializedFields.push(field);
+            }
+        }
+        // Extract methods
+        let methodMatch;
+        while ((methodMatch = methodRegex.exec(scriptContent)) !== null) {
+            const methodName = methodMatch[2];
+            // Check if it's a Unity message
+            if (UNITY_MESSAGES.includes(methodName)) {
+                scriptInfo.unityMessages.push(methodName);
+            }
+            // Check if public
+            const methodContext = scriptContent.slice(Math.max(0, methodMatch.index - 10), methodMatch.index);
+            if (methodContext.includes('public')) {
+                scriptInfo.publicMethods.push(methodName);
+            }
+        }
+        // Extract attributes (Header, Tooltip, Range)
+        this.parseFieldAttributes(scriptContent, scriptInfo.serializedFields);
+        this.callbacks.onScriptParsed?.(scriptInfo);
+        return scriptInfo;
+    }
+    parseFieldDeclaration(typeStr, name, isPublic, hasSerializeField) {
+        const cleanType = typeStr.trim();
+        const isArray = cleanType.endsWith('[]') || cleanType.includes('List<');
+        return {
+            name,
+            type: this.mapCSharpType(cleanType),
+            customType: this.isCustomType(cleanType) ? cleanType : undefined,
+            isArray,
+            isPublic,
+            hasSerializeField,
+        };
+    }
+    mapCSharpType(typeStr) {
+        const baseType = typeStr
+            .replace('[]', '')
+            .replace(/List<(.+)>/, '$1')
+            .trim();
+        const typeMap = {
+            int: 'int',
+            Int32: 'int',
+            float: 'float',
+            Single: 'float',
+            double: 'float',
+            bool: 'bool',
+            Boolean: 'bool',
+            string: 'string',
+            String: 'string',
+            Vector2: 'Vector2',
+            Vector3: 'Vector3',
+            Vector4: 'Vector4',
+            Quaternion: 'Quaternion',
+            Color: 'Color',
+            Color32: 'Color',
+            LayerMask: 'LayerMask',
+            AnimationCurve: 'AnimationCurve',
+            Gradient: 'Gradient',
+            GameObject: 'Object',
+            Transform: 'Object',
+            Sprite: 'Object',
+            Texture: 'Object',
+            Texture2D: 'Object',
+            Material: 'Object',
+            AudioClip: 'Object',
+        };
+        return typeMap[baseType] ?? 'Custom';
+    }
+    isCustomType(typeStr) {
+        const knownTypes = [
+            'int',
+            'float',
+            'double',
+            'bool',
+            'string',
+            'Vector2',
+            'Vector3',
+            'Vector4',
+            'Quaternion',
+            'Color',
+            'Color32',
+            'LayerMask',
+            'AnimationCurve',
+            'Gradient',
+            'GameObject',
+            'Transform',
+            'Sprite',
+            'Texture',
+            'Texture2D',
+            'Material',
+            'AudioClip',
+            'Rigidbody',
+            'Collider',
+        ];
+        const baseType = typeStr
+            .replace('[]', '')
+            .replace(/List<(.+)>/, '$1')
+            .trim();
+        return !knownTypes.includes(baseType);
+    }
+    parseFieldAttributes(scriptContent, fields) {
+        for (const field of fields) {
+            // Find field in content and check preceding attributes
+            const fieldPattern = new RegExp(`((?:\\[.*?\\]\\s*)*?)(?:public|private|protected)?\\s*\\w+\\s+${field.name}\\s*[;=]`, 's');
+            const match = scriptContent.match(fieldPattern);
+            if (!match) {
+                continue;
+            }
+            const attrBlock = match[1];
+            // Header
+            const headerMatch = attrBlock.match(/\[Header\("([^"]+)"\)\]/);
+            if (headerMatch) {
+                field.header = headerMatch[1];
+            }
+            // Tooltip
+            const tooltipMatch = attrBlock.match(/\[Tooltip\("([^"]+)"\)\]/);
+            if (tooltipMatch) {
+                field.tooltip = tooltipMatch[1];
+            }
+            // Range
+            const rangeMatch = attrBlock.match(/\[Range\(([^,]+),\s*([^\)]+)\)\]/);
+            if (rangeMatch) {
+                field.range = {
+                    min: parseFloat(rangeMatch[1]),
+                    max: parseFloat(rangeMatch[2]),
+                };
+            }
+        }
+    }
+    // ─── Material Import ───────────────────────────────────
+    parseMaterial(matPath, matContent, guid) {
+        const documents = parseUnityYAML(matContent);
+        const matInfo = {
+            guid,
+            path: matPath,
+            type: 'material',
+            shaderName: 'Standard',
+            textures: {},
+            floats: {},
+            colors: {},
+            vectors: {},
+            renderQueue: 2000,
+            keywords: [],
+            dependencies: [],
+            dependents: [],
+        };
+        for (const doc of documents) {
+            if (getUnityClassName(doc.classID) === 'Material') {
+                const material = doc.data['Material'];
+                if (!material) {
+                    continue;
+                }
+                // Shader reference
+                const shaderRef = material['m_Shader'];
+                if (shaderRef?.guid) {
+                    matInfo.shaderGUID = shaderRef.guid;
+                }
+                // Shader name from saved properties (if built-in shader)
+                const shaderKeywords = material['m_ShaderKeywords'];
+                if (shaderKeywords) {
+                    matInfo.keywords = shaderKeywords.split(' ').filter(Boolean);
+                }
+                // Texture properties
+                const texEnvs = material['m_TexEnvs'];
+                if (texEnvs) {
+                    for (const texEnv of texEnvs) {
+                        const name = Object.keys(texEnv)[0];
+                        const data = texEnv[name];
+                        const texRef = data?.['m_Texture'];
+                        matInfo.textures[name] = texRef?.guid ?? null;
+                    }
+                }
+                // Float properties
+                const floats = material['m_Floats'];
+                if (floats) {
+                    for (const floatProp of floats) {
+                        const name = Object.keys(floatProp)[0];
+                        matInfo.floats[name] = floatProp[name];
+                    }
+                }
+                // Color properties
+                const colors = material['m_Colors'];
+                if (colors) {
+                    for (const colorProp of colors) {
+                        const name = Object.keys(colorProp)[0];
+                        const c = colorProp[name];
+                        matInfo.colors[name] = {
+                            r: c.r ?? 0,
+                            g: c.g ?? 0,
+                            b: c.b ?? 0,
+                            a: c.a ?? 1,
+                        };
+                    }
+                }
+                // Render queue
+                if (typeof material['m_CustomRenderQueue'] === 'number') {
+                    matInfo.renderQueue = material['m_CustomRenderQueue'];
+                }
+            }
+        }
+        this.callbacks.onMaterialParsed?.(matInfo);
+        return matInfo;
+    }
+    // ─── Animation Import ──────────────────────────────────
+    parseAnimationClip(clipPath, clipContent, guid) {
+        const documents = parseUnityYAML(clipContent);
+        const clipInfo = {
+            guid,
+            path: clipPath,
+            name: this.extractFileName(clipPath),
+            length: 0,
+            frameRate: 60,
+            wrapMode: 'Default',
+            isLooping: false,
+            curves: [],
+            events: [],
+        };
+        for (const doc of documents) {
+            if (getUnityClassName(doc.classID) === 'AnimationClip') {
+                const clip = doc.data['AnimationClip'];
+                if (!clip) {
+                    continue;
+                }
+                clipInfo.name = clip['m_Name'] ?? clipInfo.name;
+                const settings = clip['m_AnimationClipSettings'];
+                if (settings) {
+                    clipInfo.length = settings['m_StopTime'] ?? 0;
+                    clipInfo.isLooping = settings['m_LoopTime'] ?? false;
+                }
+                clipInfo.frameRate = clip['m_SampleRate'] ?? 60;
+                // Parse curves
+                const positionCurves = clip['m_PositionCurves'];
+                const rotationCurves = clip['m_RotationCurves'];
+                const scaleCurves = clip['m_ScaleCurves'];
+                const floatCurves = clip['m_FloatCurves'];
+                if (positionCurves) {
+                    for (const curve of positionCurves) {
+                        clipInfo.curves.push(this.parseCurve(curve, 'position'));
+                    }
+                }
+                if (rotationCurves) {
+                    for (const curve of rotationCurves) {
+                        clipInfo.curves.push(this.parseCurve(curve, 'rotation'));
+                    }
+                }
+                if (scaleCurves) {
+                    for (const curve of scaleCurves) {
+                        clipInfo.curves.push(this.parseCurve(curve, 'scale'));
+                    }
+                }
+                if (floatCurves) {
+                    for (const curve of floatCurves) {
+                        clipInfo.curves.push(this.parseCurve(curve, 'float'));
+                    }
+                }
+                // Parse events
+                const events = clip['m_Events'];
+                if (events) {
+                    for (const event of events) {
+                        clipInfo.events.push(this.parseAnimationEvent(event));
+                    }
+                }
+            }
+        }
+        return clipInfo;
+    }
+    parseCurve(curve, type) {
+        return {
+            path: curve['path'] ?? '',
+            propertyName: curve['attribute'] ?? type,
+            type,
+            keyframes: [], // Would parse m_Curve keyframes
+        };
+    }
+    parseAnimationEvent(event) {
+        return {
+            time: event['time'] ?? 0,
+            functionName: event['functionName'] ?? '',
+            stringParameter: event['data'],
+            floatParameter: event['floatParameter'],
+            intParameter: event['intParameter'],
+            objectReferenceParameter: event['objectReferenceParameter']?.guid,
+        };
+    }
+    parseAnimatorController(controllerPath, controllerContent, guid) {
+        const documents = parseUnityYAML(controllerContent);
+        const controllerInfo = {
+            guid,
+            path: controllerPath,
+            name: this.extractFileName(controllerPath),
+            parameters: [],
+            layers: [],
+        };
+        const states = new Map();
+        const transitions = new Map();
+        for (const doc of documents) {
+            const typeName = getUnityClassName(doc.classID);
+            if (typeName === 'AnimatorController') {
+                const controller = doc.data['AnimatorController'];
+                if (controller) {
+                    controllerInfo.name = controller['m_Name'] ?? controllerInfo.name;
+                    // Parse parameters
+                    const params = controller['m_AnimatorParameters'];
+                    if (params) {
+                        for (const param of params) {
+                            const p = param;
+                            const defaultVal = p['m_DefaultFloat'] ?? p['m_DefaultInt'] ?? p['m_DefaultBool'];
+                            controllerInfo.parameters.push({
+                                name: p['m_Name'] ?? '',
+                                type: this.mapAnimatorParameterType(p['m_Type']),
+                                defaultValue: typeof defaultVal === 'number' || typeof defaultVal === 'boolean'
+                                    ? defaultVal
+                                    : 0,
+                            });
+                        }
+                    }
+                }
+            }
+            else if (typeName === 'AnimatorStateMachine') {
+                const stateMachine = doc.data['AnimatorStateMachine'];
+                if (stateMachine) {
+                    const layer = {
+                        name: stateMachine['m_Name'] ?? 'Base Layer',
+                        stateMachine: {
+                            fileID: doc.fileID,
+                            states: [],
+                            transitions: [],
+                            defaultStateIndex: 0,
+                        },
+                        weight: 1,
+                        blendingMode: 'Override',
+                    };
+                    controllerInfo.layers.push(layer);
+                }
+            }
+            else if (typeName === 'AnimatorState') {
+                const state = doc.data['AnimatorState'];
+                if (state) {
+                    const stateInfo = {
+                        fileID: doc.fileID,
+                        name: state['m_Name'] ?? '',
+                        speed: state['m_Speed'] ?? 1,
+                        motionGUID: state['m_Motion']?.guid,
+                        transitions: [],
+                    };
+                    states.set(doc.fileID, stateInfo);
+                }
+            }
+            else if (typeName === 'AnimatorStateTransition') {
+                const transition = doc.data['AnimatorStateTransition'];
+                if (transition) {
+                    const transInfo = {
+                        fileID: doc.fileID,
+                        destinationStateID: transition['m_DstState']?.fileID ?? 0,
+                        hasExitTime: transition['m_HasExitTime'] ?? false,
+                        exitTime: transition['m_ExitTime'] ?? 0.9,
+                        duration: transition['m_TransitionDuration'] ?? 0.25,
+                        conditions: [],
+                    };
+                    const conditions = transition['m_Conditions'];
+                    if (conditions) {
+                        for (const cond of conditions) {
+                            const c = cond;
+                            transInfo.conditions.push({
+                                parameter: c['m_ConditionEvent'] ?? '',
+                                mode: this.mapConditionMode(c['m_ConditionMode']),
+                                threshold: c['m_EventTreshold'] ?? 0,
+                            });
+                        }
+                    }
+                    transitions.set(doc.fileID, transInfo);
+                }
+            }
+        }
+        // Link states and transitions to layers
+        // (Simplified - real implementation would trace m_ChildStates references)
+        return controllerInfo;
+    }
+    mapAnimatorParameterType(type) {
+        const types = {
+            1: 'Float',
+            3: 'Int',
+            4: 'Bool',
+            9: 'Trigger',
+        };
+        return types[type] ?? 'Float';
+    }
+    mapConditionMode(mode) {
+        const modes = {
+            1: 'If',
+            2: 'IfNot',
+            3: 'Greater',
+            4: 'Less',
+            6: 'Equals',
+            7: 'NotEquals',
+        };
+        return modes[mode] ?? 'If';
+    }
+    // ─── Dependency Graph ──────────────────────────────────
+    buildDependencyGraph() {
+        // For each asset, find what it references and update dependents
+        for (const [guid, asset] of this.project.assets) {
+            for (const depGUID of asset.dependencies) {
+                const depAsset = this.project.assets.get(depGUID);
+                if (depAsset && !depAsset.dependents.includes(guid)) {
+                    depAsset.dependents.push(guid);
+                }
+            }
+        }
+    }
+    detectMissingReferences() {
+        for (const [guid, asset] of this.project.assets) {
+            for (const depGUID of asset.dependencies) {
+                if (!this.project.assets.has(depGUID)) {
+                    this.project.missingRefs.push({
+                        assetGUID: guid,
+                        assetPath: asset.path,
+                        missingGUID: depGUID,
+                        propertyPath: 'unknown', // Would need context to determine
+                    });
+                }
+            }
+        }
+    }
+    // ─── Conversion to Nice2Dev ────────────────────────────
+    convertSceneToNice2Dev(scene) {
+        const nice2devScene = {
+            name: scene.name,
+            entities: [],
+            cameras: [],
+            lights: [],
+        };
+        // Convert each root and its children
+        for (const rootID of scene.roots) {
+            const entity = this.convertGameObject(scene, rootID);
+            if (entity) {
+                nice2devScene.entities.push(entity);
+            }
+        }
+        return nice2devScene;
+    }
+    convertGameObject(scene, fileID) {
+        const goObj = scene.objects.get(fileID);
+        if (!goObj || goObj.type !== 'GameObject') {
+            return null;
+        }
+        const goData = goObj.data['GameObject'];
+        if (!goData) {
+            return null;
+        }
+        const entity = {
+            name: goData['m_Name'] ?? 'GameObject',
+            active: goData['m_IsActive'] ?? true,
+            tag: goData['m_Tag'] ?? 'Untagged',
+            layer: goData['m_Layer'] ?? 0,
+            transform: {
+                position: { x: 0, y: 0, z: 0 },
+                rotation: { x: 0, y: 0, z: 0, w: 1 },
+                scale: { x: 1, y: 1, z: 1 },
+            },
+            components: [],
+            children: [],
+        };
+        // Find transform
+        const components = goData['m_Component'];
+        if (components) {
+            for (const compRef of components) {
+                if (compRef.component.fileID === undefined) {
+                    continue;
+                }
+                const compObj = scene.objects.get(compRef.component.fileID);
+                if (!compObj) {
+                    continue;
+                }
+                if (compObj.type === 'Transform' || compObj.type === 'RectTransform') {
+                    const transform = compObj.data[compObj.type];
+                    if (transform) {
+                        const pos = transform['m_LocalPosition'];
+                        const rot = transform['m_LocalRotation'];
+                        const scale = transform['m_LocalScale'];
+                        if (pos) {
+                            entity.transform.position = { x: pos.x, y: pos.y, z: pos.z };
+                        }
+                        if (rot) {
+                            entity.transform.rotation = { x: rot.x, y: rot.y, z: rot.z, w: rot.w };
+                        }
+                        if (scale) {
+                            entity.transform.scale = { x: scale.x, y: scale.y, z: scale.z };
+                        }
+                        // Get children
+                        const children = transform['m_Children'];
+                        if (children) {
+                            for (const childRef of children) {
+                                if (childRef.fileID === undefined) {
+                                    continue;
+                                }
+                                const childTransform = scene.objects.get(childRef.fileID);
+                                if (childTransform) {
+                                    const childGO = childTransform.data['Transform']?.['m_GameObject'];
+                                    if (childGO?.fileID) {
+                                        const childEntity = this.convertGameObject(scene, childGO.fileID);
+                                        if (childEntity) {
+                                            entity.children.push(childEntity);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    // Convert other components
+                    const compData = this.convertComponent(compObj);
+                    if (compData) {
+                        entity.components.push(compData);
+                    }
+                }
+            }
+        }
+        return entity;
+    }
+    convertComponent(compObj) {
+        const typeName = compObj.type;
+        const data = compObj.data[typeName];
+        if (!data) {
+            return null;
+        }
+        switch (typeName) {
+            case 'Camera':
+                return {
+                    type: 'Camera',
+                    data: {
+                        fieldOfView: data['field of view'] ?? 60,
+                        nearClip: data['near clip plane'] ?? 0.3,
+                        farClip: data['far clip plane'] ?? 1000,
+                        orthographic: data['orthographic'] ?? false,
+                        orthographicSize: data['orthographic size'] ?? 5,
+                    },
+                };
+            case 'Light':
+                return {
+                    type: 'Light',
+                    data: {
+                        type: this.mapLightType(data['m_Type']),
+                        color: data['m_Color'] ?? { r: 1, g: 1, b: 1, a: 1 },
+                        intensity: data['m_Intensity'] ?? 1,
+                        range: data['m_Range'] ?? 10,
+                        spotAngle: data['m_SpotAngle'] ?? 30,
+                        shadows: data['m_Shadows'] !== 0,
+                    },
+                };
+            case 'MeshRenderer':
+            case 'SkinnedMeshRenderer':
+                return {
+                    type: 'MeshRenderer',
+                    data: {
+                        enabled: data['m_Enabled'] ?? true,
+                        castShadows: data['m_CastShadows'] ?? true,
+                        receiveShadows: data['m_ReceiveShadows'] ?? true,
+                        materials: [], // Would resolve material GUIDs
+                    },
+                };
+            case 'SpriteRenderer':
+                return {
+                    type: 'SpriteRenderer',
+                    data: {
+                        color: data['m_Color'] ?? { r: 1, g: 1, b: 1, a: 1 },
+                        flipX: data['m_FlipX'] ?? false,
+                        flipY: data['m_FlipY'] ?? false,
+                        sortingLayer: data['m_SortingLayer'] ?? 0,
+                        sortingOrder: data['m_SortingOrder'] ?? 0,
+                    },
+                };
+            case 'Rigidbody':
+                return {
+                    type: 'Rigidbody3D',
+                    data: {
+                        mass: data['m_Mass'] ?? 1,
+                        drag: data['m_Drag'] ?? 0,
+                        angularDrag: data['m_AngularDrag'] ?? 0.05,
+                        useGravity: data['m_UseGravity'] ?? true,
+                        isKinematic: data['m_IsKinematic'] ?? false,
+                    },
+                };
+            case 'Rigidbody2D':
+                return {
+                    type: 'Rigidbody2D',
+                    data: {
+                        bodyType: this.mapRigidBodyType(data['m_BodyType']),
+                        mass: data['m_Mass'] ?? 1,
+                        linearDrag: data['m_LinearDrag'] ?? 0,
+                        angularDrag: data['m_AngularDrag'] ?? 0.05,
+                        gravityScale: data['m_GravityScale'] ?? 1,
+                    },
+                };
+            case 'BoxCollider':
+                return {
+                    type: 'BoxCollider3D',
+                    data: {
+                        isTrigger: data['m_IsTrigger'] ?? false,
+                        center: data['m_Center'] ?? { x: 0, y: 0, z: 0 },
+                        size: data['m_Size'] ?? { x: 1, y: 1, z: 1 },
+                    },
+                };
+            case 'BoxCollider2D':
+                return {
+                    type: 'BoxCollider2D',
+                    data: {
+                        isTrigger: data['m_IsTrigger'] ?? false,
+                        offset: data['m_Offset'] ?? { x: 0, y: 0 },
+                        size: data['m_Size'] ?? { x: 1, y: 1 },
+                    },
+                };
+            case 'CircleCollider2D':
+                return {
+                    type: 'CircleCollider2D',
+                    data: {
+                        isTrigger: data['m_IsTrigger'] ?? false,
+                        offset: data['m_Offset'] ?? { x: 0, y: 0 },
+                        radius: data['m_Radius'] ?? 0.5,
+                    },
+                };
+            case 'Animator':
+                return {
+                    type: 'Animator',
+                    data: {
+                        controllerGUID: data['m_Controller']?.guid,
+                        applyRootMotion: data['m_ApplyRootMotion'] ?? false,
+                        updateMode: data['m_UpdateMode'] ?? 0,
+                        cullingMode: data['m_CullingMode'] ?? 0,
+                    },
+                };
+            case 'AudioSource':
+                const panCurve = data['panLevelCustomCurve'];
+                const curveData = panCurve?.['m_Curve'];
+                return {
+                    type: 'AudioSource',
+                    data: {
+                        clipGUID: data['m_audioClip']?.guid,
+                        playOnAwake: data['m_PlayOnAwake'] ?? true,
+                        loop: data['Loop'] ?? false,
+                        volume: data['m_Volume'] ?? 1,
+                        pitch: data['m_Pitch'] ?? 1,
+                        spatialBlend: curveData?.[0]?.value ?? 0,
+                    },
+                };
+            case 'ParticleSystem':
+                return {
+                    type: 'ParticleSystem',
+                    data: {
+                        // Particle systems are complex, just mark as present
+                        hasEmission: true,
+                    },
+                };
+            case 'MonoBehaviour':
+                return {
+                    type: 'Script',
+                    data: {
+                        scriptGUID: data['m_Script']?.guid,
+                        serializedData: this.extractMonoBehaviourData(data),
+                    },
+                };
+            default:
+                return {
+                    type: 'Unknown',
+                    data: { originalType: typeName },
+                };
+        }
+    }
+    mapLightType(type) {
+        const types = {
+            0: 'spot',
+            1: 'directional',
+            2: 'point',
+            3: 'area',
+        };
+        return types[type] ?? 'point';
+    }
+    mapRigidBodyType(type) {
+        const types = {
+            0: 'dynamic',
+            1: 'kinematic',
+            2: 'static',
+        };
+        return types[type] ?? 'dynamic';
+    }
+    extractMonoBehaviourData(data) {
+        const result = {};
+        // Extract all non-internal properties
+        for (const [key, value] of Object.entries(data)) {
+            if (!key.startsWith('m_') ||
+                [
+                    'm_Enabled',
+                    'm_Script',
+                    'm_Name',
+                    'm_EditorHideFlags',
+                    'm_GameObject',
+                    'm_EditorClassIdentifier',
+                ].includes(key)) {
+                continue;
+            }
+            // Remove m_ prefix and convert to camelCase
+            const propName = key.slice(2, 3).toLowerCase() + key.slice(3);
+            result[propName] = value;
+        }
+        return result;
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+// ============================================================
+// Unity Messages List
+// ============================================================
+const UNITY_MESSAGES = [
+    'Awake',
+    'Start',
+    'Update',
+    'FixedUpdate',
+    'LateUpdate',
+    'OnEnable',
+    'OnDisable',
+    'OnDestroy',
+    'OnTriggerEnter',
+    'OnTriggerStay',
+    'OnTriggerExit',
+    'OnTriggerEnter2D',
+    'OnTriggerStay2D',
+    'OnTriggerExit2D',
+    'OnCollisionEnter',
+    'OnCollisionStay',
+    'OnCollisionExit',
+    'OnCollisionEnter2D',
+    'OnCollisionStay2D',
+    'OnCollisionExit2D',
+    'OnMouseDown',
+    'OnMouseUp',
+    'OnMouseEnter',
+    'OnMouseExit',
+    'OnMouseOver',
+    'OnMouseDrag',
+    'OnGUI',
+    'OnDrawGizmos',
+    'OnDrawGizmosSelected',
+    'OnBecameVisible',
+    'OnBecameInvisible',
+    'OnPreCull',
+    'OnPreRender',
+    'OnPostRender',
+    'OnRenderImage',
+    'OnRenderObject',
+    'OnWillRenderObject',
+    'OnAnimatorMove',
+    'OnAnimatorIK',
+    'OnApplicationFocus',
+    'OnApplicationPause',
+    'OnApplicationQuit',
+    'OnValidate',
+    'Reset',
+];
+// ============================================================
+// Factory Functions
+// ============================================================
+function createUnityProjectImporter() {
+    return new UnityProjectImporter();
+}
+
+exports.UnityProjectImporter = UnityProjectImporter;
+exports.createUnityProjectImporter = createUnityProjectImporter;
+exports.getUnityClassName = getUnityClassName;
+exports.parseUnityMeta = parseUnityMeta;
+exports.parseUnityYAML = parseUnityYAML;
+//# sourceMappingURL=UnityImport.js.map