@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/godot-integration/GodotImport.js

@@ -0,0 +1,1069 @@
+'use strict';
+
+/**
+ * @file GodotImport.ts
+ * @description Godot Engine Project Import for Nice2Dev Game Engine
+ * PRO-1.9.1: Godot Project Import
+ *
+ * Features:
+ * - .tscn (text scene) parsing
+ * - .scn (binary scene) detection
+ * - .tres resource parsing
+ * - GDScript parser and AST extraction
+ * - Node tree reconstruction
+ * - Signal/connection mapping
+ */
+// ============================================================
+// TSCN Parser
+// ============================================================
+/**
+ * Parses Godot's text scene format (.tscn)
+ */
+function parseGodotScene(content) {
+    const lines = content.split('\n');
+    const scene = {
+        header: { loadSteps: 0, format: 3 },
+        extResources: [],
+        subResources: [],
+        rootNode: null,
+        connections: [],
+        editable: [],
+    };
+    let currentSection = 'header';
+    let currentNode = null;
+    const nodeMap = new Map();
+    let currentSubResource = null;
+    let multiLineValue = '';
+    let multiLineKey = '';
+    let inMultiLine = false;
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        // Handle multi-line values (strings, arrays, etc.)
+        if (inMultiLine) {
+            multiLineValue += '\n' + line;
+            if (line.includes(']') || (line.includes('"') && line.trim().endsWith('"'))) {
+                if (currentNode) {
+                    currentNode.properties[multiLineKey] = parseGodotValue(multiLineValue);
+                }
+                else if (currentSubResource) {
+                    currentSubResource.properties[multiLineKey] = parseGodotValue(multiLineValue);
+                }
+                inMultiLine = false;
+                multiLineValue = '';
+                multiLineKey = '';
+            }
+            continue;
+        }
+        line = line.trim();
+        if (!line || line.startsWith(';')) {
+            continue;
+        }
+        // Section headers
+        if (line.startsWith('[')) {
+            const sectionMatch = line.match(/^\[(\w+)(?:\s+(.+))?\]$/);
+            if (sectionMatch) {
+                const sectionType = sectionMatch[1];
+                const sectionParams = sectionMatch[2] || '';
+                switch (sectionType) {
+                    case 'gd_scene':
+                        currentSection = 'header';
+                        scene.header = parseGodotSceneHeader(sectionParams);
+                        break;
+                    case 'ext_resource':
+                        currentSection = 'ext_resource';
+                        scene.extResources.push(parseExtResource(sectionParams));
+                        break;
+                    case 'sub_resource':
+                        currentSection = 'sub_resource';
+                        currentSubResource = parseSubResourceHeader(sectionParams);
+                        scene.subResources.push(currentSubResource);
+                        break;
+                    case 'node':
+                        currentSection = 'node';
+                        currentNode = parseNodeHeader(sectionParams);
+                        if (!currentNode.parent) {
+                            // Root node
+                            scene.rootNode = currentNode;
+                            nodeMap.set('.', currentNode);
+                        }
+                        else {
+                            // Find parent and add as child
+                            const parentPath = currentNode.parent;
+                            const parentNode = nodeMap.get(parentPath);
+                            if (parentNode) {
+                                parentNode.children.push(currentNode);
+                            }
+                            // Calculate this node's path
+                            const nodePath = parentPath === '.' ? currentNode.name : `${parentPath}/${currentNode.name}`;
+                            nodeMap.set(nodePath, currentNode);
+                        }
+                        break;
+                    case 'connection':
+                        currentSection = 'connection';
+                        scene.connections.push(parseConnectionHeader(sectionParams));
+                        break;
+                    case 'editable':
+                        currentSection = 'editable';
+                        const pathMatch = sectionParams.match(/path="([^"]+)"/);
+                        if (pathMatch) {
+                            scene.editable.push(pathMatch[1]);
+                        }
+                        break;
+                }
+                continue;
+            }
+        }
+        // Property assignment
+        if (line.includes('=')) {
+            const eqIndex = line.indexOf('=');
+            const key = line.substring(0, eqIndex).trim();
+            const valueStr = line.substring(eqIndex + 1).trim();
+            // Check for multi-line value start
+            if ((valueStr.startsWith('[') && !valueStr.includes(']')) ||
+                (valueStr.startsWith('"') && !valueStr.endsWith('"') && valueStr.length > 1)) {
+                inMultiLine = true;
+                multiLineKey = key;
+                multiLineValue = valueStr;
+                continue;
+            }
+            const value = parseGodotValue(valueStr);
+            if (currentSection === 'node' && currentNode) {
+                currentNode.properties[key] = value;
+            }
+            else if (currentSection === 'sub_resource' && currentSubResource) {
+                currentSubResource.properties[key] = value;
+            }
+        }
+    }
+    return scene;
+}
+function parseGodotSceneHeader(params) {
+    const header = { loadSteps: 0, format: 3 };
+    const loadStepsMatch = params.match(/load_steps=(\d+)/);
+    if (loadStepsMatch) {
+        header.loadSteps = parseInt(loadStepsMatch[1], 10);
+    }
+    const formatMatch = params.match(/format=(\d+)/);
+    if (formatMatch) {
+        header.format = parseInt(formatMatch[1], 10);
+    }
+    const uidMatch = params.match(/uid="([^"]+)"/);
+    if (uidMatch) {
+        header.uid = uidMatch[1];
+    }
+    const typeMatch = params.match(/type="([^"]+)"/);
+    if (typeMatch) {
+        header.type = typeMatch[1];
+    }
+    return header;
+}
+function parseExtResource(params) {
+    const resource = { id: '', type: '', path: '' };
+    const typeMatch = params.match(/type="([^"]+)"/);
+    if (typeMatch) {
+        resource.type = typeMatch[1];
+    }
+    const pathMatch = params.match(/path="([^"]+)"/);
+    if (pathMatch) {
+        resource.path = pathMatch[1];
+    }
+    const idMatch = params.match(/id="?([^"\s]+)"?/);
+    if (idMatch) {
+        resource.id = idMatch[1];
+    }
+    const uidMatch = params.match(/uid="([^"]+)"/);
+    if (uidMatch) {
+        resource.uid = uidMatch[1];
+    }
+    return resource;
+}
+function parseSubResourceHeader(params) {
+    const resource = { id: '', type: '', properties: {} };
+    const typeMatch = params.match(/type="([^"]+)"/);
+    if (typeMatch) {
+        resource.type = typeMatch[1];
+    }
+    const idMatch = params.match(/id="?([^"\s]+)"?/);
+    if (idMatch) {
+        resource.id = idMatch[1];
+    }
+    return resource;
+}
+function parseNodeHeader(params) {
+    const node = {
+        name: '',
+        type: 'Node',
+        properties: {},
+        children: [],
+    };
+    const nameMatch = params.match(/name="([^"]+)"/);
+    if (nameMatch) {
+        node.name = nameMatch[1];
+    }
+    const typeMatch = params.match(/type="([^"]+)"/);
+    if (typeMatch) {
+        node.type = typeMatch[1];
+    }
+    const parentMatch = params.match(/parent="([^"]+)"/);
+    if (parentMatch) {
+        node.parent = parentMatch[1];
+    }
+    const instanceMatch = params.match(/instance=ExtResource\(\s*"?([^")]+)"?\s*\)/);
+    if (instanceMatch) {
+        node.instance = instanceMatch[1];
+    }
+    const groupsMatch = params.match(/groups=\[([^\]]+)\]/);
+    if (groupsMatch) {
+        node.groups = groupsMatch[1].split(',').map((g) => g.trim().replace(/"/g, ''));
+    }
+    const indexMatch = params.match(/index="?(\d+)"?/);
+    if (indexMatch) {
+        node.index = parseInt(indexMatch[1], 10);
+    }
+    return node;
+}
+function parseConnectionHeader(params) {
+    const connection = {
+        signal: '',
+        from: '',
+        to: '',
+        method: '',
+    };
+    const signalMatch = params.match(/signal="([^"]+)"/);
+    if (signalMatch) {
+        connection.signal = signalMatch[1];
+    }
+    const fromMatch = params.match(/from="([^"]+)"/);
+    if (fromMatch) {
+        connection.from = fromMatch[1];
+    }
+    const toMatch = params.match(/to="([^"]+)"/);
+    if (toMatch) {
+        connection.to = toMatch[1];
+    }
+    const methodMatch = params.match(/method="([^"]+)"/);
+    if (methodMatch) {
+        connection.method = methodMatch[1];
+    }
+    const flagsMatch = params.match(/flags=(\d+)/);
+    if (flagsMatch) {
+        connection.flags = parseInt(flagsMatch[1], 10);
+    }
+    return connection;
+}
+function parseGodotValue(valueStr) {
+    valueStr = valueStr.trim();
+    // null
+    if (valueStr === 'null') {
+        return null;
+    }
+    // Boolean
+    if (valueStr === 'true') {
+        return true;
+    }
+    if (valueStr === 'false') {
+        return false;
+    }
+    // Integer
+    if (/^-?\d+$/.test(valueStr)) {
+        return parseInt(valueStr, 10);
+    }
+    // Float
+    if (/^-?\d+\.\d+$/.test(valueStr)) {
+        return parseFloat(valueStr);
+    }
+    // String
+    if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
+        return valueStr.slice(1, -1);
+    }
+    // Vector2
+    const vec2Match = valueStr.match(/^Vector2\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)$/);
+    if (vec2Match) {
+        return { x: parseFloat(vec2Match[1]), y: parseFloat(vec2Match[2]) };
+    }
+    // Vector2i
+    const vec2iMatch = valueStr.match(/^Vector2i\(\s*(-?\d+)\s*,\s*(-?\d+)\s*\)$/);
+    if (vec2iMatch) {
+        return { x: parseInt(vec2iMatch[1], 10), y: parseInt(vec2iMatch[2], 10) };
+    }
+    // Vector3
+    const vec3Match = valueStr.match(/^Vector3\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)$/);
+    if (vec3Match) {
+        return {
+            x: parseFloat(vec3Match[1]),
+            y: parseFloat(vec3Match[2]),
+            z: parseFloat(vec3Match[3]),
+        };
+    }
+    // Vector3i
+    const vec3iMatch = valueStr.match(/^Vector3i\(\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*(-?\d+)\s*\)$/);
+    if (vec3iMatch) {
+        return {
+            x: parseInt(vec3iMatch[1], 10),
+            y: parseInt(vec3iMatch[2], 10),
+            z: parseInt(vec3iMatch[3], 10),
+        };
+    }
+    // Color
+    const colorMatch = valueStr.match(/^Color\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/);
+    if (colorMatch) {
+        return {
+            r: parseFloat(colorMatch[1]),
+            g: parseFloat(colorMatch[2]),
+            b: parseFloat(colorMatch[3]),
+            a: colorMatch[4] ? parseFloat(colorMatch[4]) : 1,
+        };
+    }
+    // Rect2
+    const rect2Match = valueStr.match(/^Rect2\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)$/);
+    if (rect2Match) {
+        return {
+            x: parseFloat(rect2Match[1]),
+            y: parseFloat(rect2Match[2]),
+            width: parseFloat(rect2Match[3]),
+            height: parseFloat(rect2Match[4]),
+        };
+    }
+    // Transform2D
+    const transform2dMatch = valueStr.match(/^Transform2D\(\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*\)$/);
+    if (transform2dMatch) {
+        return {
+            type: 'Transform2D',
+            x: { x: parseFloat(transform2dMatch[1]), y: parseFloat(transform2dMatch[2]) },
+            y: { x: parseFloat(transform2dMatch[3]), y: parseFloat(transform2dMatch[4]) },
+            origin: { x: parseFloat(transform2dMatch[5]), y: parseFloat(transform2dMatch[6]) },
+        };
+    }
+    // Transform3D
+    const transform3dMatch = valueStr.match(/^Transform3D\(([^)]+)\)$/);
+    if (transform3dMatch) {
+        const values = transform3dMatch[1].split(',').map((v) => parseFloat(v.trim()));
+        if (values.length === 12) {
+            return {
+                type: 'Transform3D',
+                basis: {
+                    x: { x: values[0], y: values[1], z: values[2] },
+                    y: { x: values[3], y: values[4], z: values[5] },
+                    z: { x: values[6], y: values[7], z: values[8] },
+                },
+                origin: { x: values[9], y: values[10], z: values[11] },
+            };
+        }
+    }
+    // NodePath
+    const nodePathMatch = valueStr.match(/^NodePath\("([^"]*)"\)$/);
+    if (nodePathMatch) {
+        return { type: 'NodePath', path: nodePathMatch[1] };
+    }
+    // ExtResource reference
+    const extResMatch = valueStr.match(/^ExtResource\(\s*"?([^")]+)"?\s*\)$/);
+    if (extResMatch) {
+        return { type: 'ExtResource', id: extResMatch[1] };
+    }
+    // SubResource reference
+    const subResMatch = valueStr.match(/^SubResource\(\s*"?([^")]+)"?\s*\)$/);
+    if (subResMatch) {
+        return { type: 'SubResource', id: subResMatch[1] };
+    }
+    // Array
+    if (valueStr.startsWith('[') && valueStr.endsWith(']')) {
+        const inner = valueStr.slice(1, -1).trim();
+        if (!inner) {
+            return [];
+        }
+        // Simple split for basic arrays (doesn't handle nested structures well)
+        return inner.split(/,(?![^(]*\))/).map((v) => parseGodotValue(v.trim()));
+    }
+    // Dictionary
+    if (valueStr.startsWith('{') && valueStr.endsWith('}')) {
+        // Simple dict parsing
+        const inner = valueStr.slice(1, -1).trim();
+        if (!inner) {
+            return {};
+        }
+        const dict = {};
+        // Match key: value pairs
+        const pairRegex = /"([^"]+)":\s*([^,}]+)/g;
+        let match;
+        while ((match = pairRegex.exec(inner)) !== null) {
+            dict[match[1]] = parseGodotValue(match[2].trim());
+        }
+        return dict;
+    }
+    // PackedStringArray
+    const packedStrMatch = valueStr.match(/^PackedStringArray\(\s*([^)]*)\s*\)$/);
+    if (packedStrMatch) {
+        const inner = packedStrMatch[1].trim();
+        if (!inner) {
+            return [];
+        }
+        return inner.split(',').map((s) => s.trim().replace(/^"|"$/g, ''));
+    }
+    // PackedVector2Array
+    const packedVec2Match = valueStr.match(/^PackedVector2Array\(\s*([^)]*)\s*\)$/);
+    if (packedVec2Match) {
+        const inner = packedVec2Match[1].trim();
+        if (!inner) {
+            return [];
+        }
+        const nums = inner.split(',').map((n) => parseFloat(n.trim()));
+        const vectors = [];
+        for (let i = 0; i < nums.length; i += 2) {
+            vectors.push({ x: nums[i], y: nums[i + 1] });
+        }
+        return vectors;
+    }
+    // Return as-is for unknown types
+    return valueStr;
+}
+// ============================================================
+// TRES Resource Parser
+// ============================================================
+/**
+ * Parses Godot's text resource format (.tres)
+ */
+function parseGodotResource(content) {
+    const lines = content.split('\n');
+    const resource = {
+        header: { type: '', format: 3 },
+        extResources: [],
+        subResources: [],
+        resource: { type: '', properties: {} },
+    };
+    let currentSection = 'header';
+    let currentSubResource = null;
+    for (let line of lines) {
+        line = line.trim();
+        if (!line || line.startsWith(';')) {
+            continue;
+        }
+        // Section headers
+        if (line.startsWith('[')) {
+            const sectionMatch = line.match(/^\[(\w+)(?:\s+(.+))?\]$/);
+            if (sectionMatch) {
+                const sectionType = sectionMatch[1];
+                const sectionParams = sectionMatch[2] || '';
+                switch (sectionType) {
+                    case 'gd_resource':
+                        currentSection = 'header';
+                        resource.header = parseResourceHeader(sectionParams);
+                        break;
+                    case 'ext_resource':
+                        currentSection = 'ext_resource';
+                        resource.extResources.push(parseExtResource(sectionParams));
+                        break;
+                    case 'sub_resource':
+                        currentSection = 'sub_resource';
+                        currentSubResource = parseSubResourceHeader(sectionParams);
+                        resource.subResources.push(currentSubResource);
+                        break;
+                    case 'resource':
+                        currentSection = 'resource';
+                        break;
+                }
+                continue;
+            }
+        }
+        // Property assignment
+        if (line.includes('=')) {
+            const eqIndex = line.indexOf('=');
+            const key = line.substring(0, eqIndex).trim();
+            const valueStr = line.substring(eqIndex + 1).trim();
+            const value = parseGodotValue(valueStr);
+            if (currentSection === 'resource') {
+                resource.resource.properties[key] = value;
+            }
+            else if (currentSection === 'sub_resource' && currentSubResource) {
+                currentSubResource.properties[key] = value;
+            }
+        }
+    }
+    resource.resource.type = resource.header.type;
+    return resource;
+}
+function parseResourceHeader(params) {
+    const header = { type: '', format: 3 };
+    const typeMatch = params.match(/type="([^"]+)"/);
+    if (typeMatch) {
+        header.type = typeMatch[1];
+    }
+    const loadStepsMatch = params.match(/load_steps=(\d+)/);
+    if (loadStepsMatch) {
+        header.loadSteps = parseInt(loadStepsMatch[1], 10);
+    }
+    const formatMatch = params.match(/format=(\d+)/);
+    if (formatMatch) {
+        header.format = parseInt(formatMatch[1], 10);
+    }
+    const uidMatch = params.match(/uid="([^"]+)"/);
+    if (uidMatch) {
+        header.uid = uidMatch[1];
+    }
+    return header;
+}
+// ============================================================
+// GDScript Parser
+// ============================================================
+/**
+ * Parses GDScript files and extracts structure
+ */
+function parseGDScript(content, filePath = '') {
+    const script = {
+        path: filePath,
+        extends: 'Node',
+        isToolScript: false,
+        signals: [],
+        enums: [],
+        constants: [],
+        exportVars: [],
+        onreadyVars: [],
+        variables: [],
+        functions: [],
+        innerClasses: [],
+        staticFunctions: [],
+        annotations: [],
+    };
+    const lines = content.split('\n');
+    let currentFunction = null;
+    let functionIndent = 0;
+    let currentEnum = null;
+    let enumIndent = 0;
+    let pendingDocComment;
+    let pendingAnnotations = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        const indent = line.length - line.trimStart().length;
+        // Skip empty lines and comments (but capture doc comments)
+        if (!trimmed) {
+            continue;
+        }
+        if (trimmed.startsWith('##')) {
+            pendingDocComment = (pendingDocComment || '') + trimmed.substring(2).trim() + '\n';
+            continue;
+        }
+        if (trimmed.startsWith('#')) {
+            continue;
+        }
+        // Handle being inside function body
+        if (currentFunction && indent > functionIndent) {
+            currentFunction.body += line + '\n';
+            continue;
+        }
+        else if (currentFunction && indent <= functionIndent) {
+            currentFunction = null;
+        }
+        // Handle being inside enum
+        if (currentEnum && indent > enumIndent) {
+            // Parse enum value
+            const enumValMatch = trimmed.match(/^(\w+)(?:\s*=\s*(-?\d+))?,?$/);
+            if (enumValMatch) {
+                const name = enumValMatch[1];
+                const value = enumValMatch[2]
+                    ? parseInt(enumValMatch[2], 10)
+                    : Object.keys(currentEnum.values).length;
+                currentEnum.values[name] = value;
+            }
+            continue;
+        }
+        else if (currentEnum && indent <= enumIndent) {
+            currentEnum = null;
+        }
+        // @tool annotation
+        if (trimmed === '@tool') {
+            script.isToolScript = true;
+            continue;
+        }
+        // Annotations
+        if (trimmed.startsWith('@')) {
+            const annotationMatch = trimmed.match(/^@(\w+)(?:\(([^)]*)\))?/);
+            if (annotationMatch) {
+                const annotation = { name: annotationMatch[1] };
+                if (annotationMatch[2]) {
+                    annotation.arguments = annotationMatch[2].split(',').map((a) => a.trim());
+                }
+                pendingAnnotations.push(annotation);
+                // Handle @icon specifically
+                if (annotation.name === 'icon' && annotation.arguments?.[0]) {
+                    script.iconPath = annotation.arguments[0].replace(/"/g, '');
+                }
+            }
+            continue;
+        }
+        // class_name
+        const classNameMatch = trimmed.match(/^class_name\s+(\w+)/);
+        if (classNameMatch) {
+            script.className = classNameMatch[1];
+            script.classNameToken = classNameMatch[1];
+            continue;
+        }
+        // extends
+        const extendsMatch = trimmed.match(/^extends\s+(.+)$/);
+        if (extendsMatch) {
+            script.extends = extendsMatch[1].trim();
+            continue;
+        }
+        // signal
+        const signalMatch = trimmed.match(/^signal\s+(\w+)(?:\(([^)]*)\))?/);
+        if (signalMatch) {
+            const sig = {
+                name: signalMatch[1],
+                parameters: [],
+                documentation: pendingDocComment?.trim(),
+            };
+            if (signalMatch[2]) {
+                sig.parameters = parseGDScriptParameters(signalMatch[2]);
+            }
+            script.signals.push(sig);
+            pendingDocComment = undefined;
+            continue;
+        }
+        // enum
+        const enumMatch = trimmed.match(/^enum\s+(\w+)\s*{?/);
+        if (enumMatch) {
+            currentEnum = {
+                name: enumMatch[1],
+                values: {},
+                documentation: pendingDocComment?.trim(),
+            };
+            enumIndent = indent;
+            // Check for single-line enum
+            const inlineMatch = trimmed.match(/^enum\s+\w+\s*{([^}]+)}/);
+            if (inlineMatch) {
+                const entries = inlineMatch[1].split(',');
+                let nextVal = 0;
+                for (const entry of entries) {
+                    const valMatch = entry.trim().match(/^(\w+)(?:\s*=\s*(-?\d+))?$/);
+                    if (valMatch) {
+                        const val = valMatch[2] ? parseInt(valMatch[2], 10) : nextVal;
+                        currentEnum.values[valMatch[1]] = val;
+                        nextVal = val + 1;
+                    }
+                }
+                script.enums.push(currentEnum);
+                currentEnum = null;
+            }
+            else {
+                script.enums.push(currentEnum);
+            }
+            pendingDocComment = undefined;
+            continue;
+        }
+        // const
+        const constMatch = trimmed.match(/^const\s+(\w+)(?:\s*:\s*(\w+))?\s*=\s*(.+)$/);
+        if (constMatch) {
+            script.constants.push({
+                name: constMatch[1],
+                type: constMatch[2],
+                value: constMatch[3],
+                documentation: pendingDocComment?.trim(),
+            });
+            pendingDocComment = undefined;
+            continue;
+        }
+        // @export var
+        if (trimmed.startsWith('@export')) {
+            // This is an export annotation, the var should follow
+            const exportAnnotations = [trimmed];
+            // Look for subsequent export annotations or the var line
+            let j = i + 1;
+            while (j < lines.length && lines[j].trim().startsWith('@export')) {
+                exportAnnotations.push(lines[j].trim());
+                j++;
+            }
+            if (j < lines.length) {
+                const varLine = lines[j].trim();
+                const varMatch = varLine.match(/^var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
+                if (varMatch) {
+                    script.exportVars.push({
+                        name: varMatch[1],
+                        type: varMatch[2],
+                        default: varMatch[3],
+                        exportAnnotations: exportAnnotations,
+                        documentation: pendingDocComment?.trim(),
+                    });
+                    i = j; // Skip to after the var line
+                    pendingDocComment = undefined;
+                    pendingAnnotations = [];
+                }
+            }
+            continue;
+        }
+        // @onready var
+        const onreadyMatch = trimmed.match(/^@onready\s+var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
+        if (onreadyMatch) {
+            script.onreadyVars.push({
+                name: onreadyMatch[1],
+                type: onreadyMatch[2],
+                default: onreadyMatch[3],
+                documentation: pendingDocComment?.trim(),
+            });
+            pendingDocComment = undefined;
+            continue;
+        }
+        // Regular var
+        const varMatch = trimmed.match(/^var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?(?:\s*:\s*(?:get\s*=\s*(\w+))?(?:\s*,?\s*set\s*=\s*(\w+))?)?$/);
+        if (varMatch) {
+            const variable = {
+                name: varMatch[1],
+                type: varMatch[2],
+                default: varMatch[3],
+                documentation: pendingDocComment?.trim(),
+            };
+            if (varMatch[4] || varMatch[5]) {
+                variable.setget = {
+                    getter: varMatch[4],
+                    setter: varMatch[5],
+                };
+            }
+            script.variables.push(variable);
+            pendingDocComment = undefined;
+            continue;
+        }
+        // Function
+        const funcMatch = trimmed.match(/^(?:(static)\s+)?func\s+(\w+)\(([^)]*)\)(?:\s*->\s*(\w+))?(?:\s*:\s*)?$/);
+        if (funcMatch) {
+            currentFunction = {
+                name: funcMatch[2],
+                parameters: parseGDScriptParameters(funcMatch[3]),
+                returnType: funcMatch[4],
+                isVirtual: funcMatch[2].startsWith('_'),
+                isStatic: !!funcMatch[1],
+                isCoroutine: false,
+                body: '',
+                documentation: pendingDocComment?.trim(),
+            };
+            functionIndent = indent;
+            if (currentFunction.isStatic) {
+                script.staticFunctions.push(currentFunction);
+            }
+            else {
+                script.functions.push(currentFunction);
+            }
+            pendingDocComment = undefined;
+            continue;
+        }
+        // Inner class
+        const classMatch = trimmed.match(/^class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s*:\s*)?$/);
+        if (classMatch) {
+            script.innerClasses.push({
+                name: classMatch[1],
+                extends: classMatch[2],
+                signals: [],
+                variables: [],
+                functions: [],
+            });
+            pendingDocComment = undefined;
+            continue;
+        }
+        pendingDocComment = undefined;
+        pendingAnnotations = [];
+    }
+    return script;
+}
+function parseGDScriptParameters(paramString) {
+    if (!paramString.trim()) {
+        return [];
+    }
+    const params = [];
+    const parts = paramString.split(',');
+    for (const part of parts) {
+        const trimmed = part.trim();
+        const paramMatch = trimmed.match(/^(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
+        if (paramMatch) {
+            params.push({
+                name: paramMatch[1],
+                type: paramMatch[2],
+                default: paramMatch[3],
+            });
+        }
+    }
+    return params;
+}
+class GodotProjectImporter {
+    constructor(callbacks) {
+        this.projectPath = '';
+        this.config = null;
+        this.scenes = new Map();
+        this.resources = new Map();
+        this.scripts = new Map();
+        this.callbacks = {};
+        if (callbacks) {
+            this.callbacks = callbacks;
+        }
+    }
+    /**
+     * Parses project.godot configuration file
+     */
+    parseProjectConfig(content) {
+        const config = {
+            configVersion: 5,
+            name: 'Untitled',
+            features: [],
+            autoloads: {},
+            inputMap: {},
+            layers: { layer2d: {}, layer3d: {} },
+        };
+        let currentSection = '';
+        const lines = content.split('\n');
+        for (let line of lines) {
+            line = line.trim();
+            if (!line || line.startsWith(';')) {
+                continue;
+            }
+            // Section header
+            if (line.startsWith('[')) {
+                const match = line.match(/^\[(.+)\]$/);
+                if (match) {
+                    currentSection = match[1];
+                }
+                continue;
+            }
+            // Key-value pair
+            if (line.includes('=')) {
+                const eqIndex = line.indexOf('=');
+                const key = line.substring(0, eqIndex).trim();
+                const valueStr = line.substring(eqIndex + 1).trim();
+                const value = parseGodotValue(valueStr);
+                switch (currentSection) {
+                    case '':
+                        if (key === 'config_version') {
+                            config.configVersion = value;
+                        }
+                        break;
+                    case 'application':
+                        if (key === 'config/name') {
+                            config.name = value;
+                        }
+                        if (key === 'config/features') {
+                            config.features = value;
+                        }
+                        if (key === 'config/icon') {
+                            config.icon = value;
+                        }
+                        if (key === 'run/main_scene') {
+                            config.mainScene = value;
+                        }
+                        break;
+                    case 'autoload':
+                        const autoloadMatch = key.match(/^(.+)$/);
+                        if (autoloadMatch) {
+                            const autoloadPath = value.replace(/^\*/, '');
+                            config.autoloads[autoloadMatch[1]] = autoloadPath;
+                        }
+                        break;
+                    case 'input':
+                        const inputMatch = key.match(/^(.+)$/);
+                        if (inputMatch) {
+                            const inputValue = value;
+                            config.inputMap[inputMatch[1]] = {
+                                deadzone: inputValue.deadzone ?? 0.5,
+                                events: inputValue.events ?? [],
+                            };
+                        }
+                        break;
+                    case 'layer_names':
+                        if (key.startsWith('2d_physics/layer_')) {
+                            const layerNum = parseInt(key.split('_').pop(), 10);
+                            config.layers.layer2d[value] = layerNum;
+                        }
+                        if (key.startsWith('3d_physics/layer_')) {
+                            const layerNum = parseInt(key.split('_').pop(), 10);
+                            config.layers.layer3d[value] = layerNum;
+                        }
+                        break;
+                }
+            }
+        }
+        this.config = config;
+        return config;
+    }
+    /**
+     * Imports a scene file and all its dependencies
+     */
+    async importScene(content, filePath) {
+        const scene = parseGodotScene(content);
+        this.scenes.set(filePath, scene);
+        this.callbacks.onSceneParsed?.(scene);
+        return this.convertSceneToImported(scene, filePath);
+    }
+    /**
+     * Imports a resource file
+     */
+    async importResource(content, filePath) {
+        const resource = parseGodotResource(content);
+        this.resources.set(filePath, resource);
+        this.callbacks.onResourceParsed?.(resource);
+        return resource;
+    }
+    /**
+     * Imports a GDScript file
+     */
+    async importScript(content, filePath) {
+        const script = parseGDScript(content, filePath);
+        this.scripts.set(filePath, script);
+        this.callbacks.onScriptParsed?.(script);
+        return script;
+    }
+    convertSceneToImported(scene, filePath) {
+        const imported = {
+            name: filePath.split('/').pop()?.replace('.tscn', '') ?? 'Scene',
+            path: filePath,
+            nodes: [],
+            rootNode: null,
+            connections: scene.connections,
+            resources: new Map(),
+        };
+        // Build resource map
+        for (const extRes of scene.extResources) {
+            imported.resources.set(String(extRes.id), extRes);
+        }
+        // Convert nodes
+        if (scene.rootNode) {
+            imported.rootNode = this.convertNode(scene.rootNode, imported.resources);
+            imported.nodes = this.flattenNodes(imported.rootNode);
+        }
+        return imported;
+    }
+    convertNode(node, resources, parentId) {
+        const id = parentId ? `${parentId}/${node.name}` : node.name;
+        const imported = {
+            id,
+            name: node.name,
+            type: node.type,
+            parentId,
+            properties: { ...node.properties },
+            children: [],
+            groups: node.groups ?? [],
+        };
+        // Extract position/rotation/scale from properties
+        if (node.properties.position) {
+            imported.position = node.properties.position;
+        }
+        if (node.properties.global_position) {
+            imported.position = node.properties.global_position;
+        }
+        if (node.properties.rotation) {
+            imported.rotation = node.properties.rotation;
+        }
+        if (node.properties.scale) {
+            imported.scale = node.properties.scale;
+        }
+        // 3D transforms
+        if (node.properties.transform) {
+            const t = node.properties.transform;
+            imported.position = t.origin;
+        }
+        // Resolve script reference
+        if (node.script) {
+            const scriptRes = resources.get(String(node.script));
+            if (scriptRes) {
+                const cachedScript = this.scripts.get(scriptRes.path);
+                if (cachedScript) {
+                    imported.script = cachedScript;
+                }
+            }
+        }
+        // Convert children
+        for (const child of node.children) {
+            imported.children.push(this.convertNode(child, resources, id));
+        }
+        return imported;
+    }
+    flattenNodes(node) {
+        const nodes = [node];
+        for (const child of node.children) {
+            nodes.push(...this.flattenNodes(child));
+        }
+        return nodes;
+    }
+    /**
+     * Gets all imported data
+     */
+    getImportedData() {
+        return {
+            config: this.config,
+            scenes: this.scenes,
+            resources: this.resources,
+            scripts: this.scripts,
+        };
+    }
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+// ============================================================
+// Node Type Mapping
+// ============================================================
+const GODOT_NODE_MAPPING = {
+    // 2D Nodes
+    Node2D: 'Entity2D',
+    Sprite2D: 'Sprite',
+    AnimatedSprite2D: 'AnimatedSprite',
+    Camera2D: 'Camera2D',
+    CharacterBody2D: 'KinematicBody2D',
+    RigidBody2D: 'RigidBody2D',
+    StaticBody2D: 'StaticBody2D',
+    Area2D: 'Area2D',
+    CollisionShape2D: 'CollisionShape2D',
+    TileMap: 'TileMap',
+    TileMapLayer: 'TileMapLayer',
+    GPUParticles2D: 'ParticleEmitter2D',
+    CPUParticles2D: 'ParticleEmitter2D',
+    NavigationAgent2D: 'NavigationAgent2D',
+    AudioStreamPlayer2D: 'AudioSource2D',
+    // 3D Nodes
+    Node3D: 'Entity3D',
+    MeshInstance3D: 'MeshRenderer',
+    Camera3D: 'Camera3D',
+    CharacterBody3D: 'KinematicBody3D',
+    RigidBody3D: 'RigidBody3D',
+    StaticBody3D: 'StaticBody3D',
+    Area3D: 'Area3D',
+    CollisionShape3D: 'CollisionShape3D',
+    DirectionalLight3D: 'DirectionalLight',
+    OmniLight3D: 'PointLight',
+    SpotLight3D: 'SpotLight',
+    GPUParticles3D: 'ParticleEmitter3D',
+    CPUParticles3D: 'ParticleEmitter3D',
+    NavigationAgent3D: 'NavigationAgent3D',
+    AudioStreamPlayer3D: 'AudioSource3D',
+    WorldEnvironment: 'Environment',
+    // Audio
+    AudioStreamPlayer: 'AudioSource',
+    // Animation
+    AnimationPlayer: 'AnimationPlayer',
+    AnimationTree: 'AnimationTree',
+    // UI
+    Control: 'UIElement',
+    Button: 'UIButton',
+    Label: 'UILabel',
+    TextureRect: 'UIImage',
+    Panel: 'UIPanel',
+    VBoxContainer: 'UIVBox',
+    HBoxContainer: 'UIHBox',
+    GridContainer: 'UIGrid',
+    LineEdit: 'UIInput',
+    TextEdit: 'UITextArea',
+    ProgressBar: 'UIProgressBar',
+    Slider: 'UISlider',
+    TabContainer: 'UITabs',
+    CanvasLayer: 'UILayer',
+    // Other
+    Timer: 'Timer',
+    Node: 'Entity',
+};
+// ============================================================
+// Factory Functions
+// ============================================================
+function createGodotProjectImporter(callbacks) {
+    return new GodotProjectImporter(callbacks);
+}
+
+exports.GODOT_NODE_MAPPING = GODOT_NODE_MAPPING;
+exports.GodotProjectImporter = GodotProjectImporter;
+exports.createGodotProjectImporter = createGodotProjectImporter;
+exports.parseGDScript = parseGDScript;
+exports.parseGodotResource = parseGodotResource;
+exports.parseGodotScene = parseGodotScene;
+//# sourceMappingURL=GodotImport.js.map