@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/cjs/export/GDevelopExporter.js

@@ -0,0 +1,748 @@
+'use strict';
+
+var PlatformExporter = require('./PlatformExporter.js');
+
+/* ────────────────────────────────────────────────────────────────
+   GDevelop Exporter — GDevelop 5 Project Export
+   
+   Exports Nice2Dev projects to GDevelop 5 format:
+   - Project file (JSON)
+   - Scene layouts
+   - Event sheets
+   - Object definitions
+   - Extension behaviors
+──────────────────────────────────────────────────────────────── */
+/* ── UUID Generator ───────────────────────────────────────────── */
+function generateGDevelopUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/* ── GDevelop Behavior Mappings ───────────────────────────────── */
+const GDEVELOP_BEHAVIOR_MAP = {
+    rigidbody: {
+        type: 'PhysicsBehavior::PhysicsBehavior',
+        content: {
+            dynamic: true,
+            fixedRotation: false,
+            isBullet: false,
+            massDensity: 1,
+            averageFriction: 0.8,
+            averageRestitution: 0,
+            linearDamping: 0.1,
+            angularDamping: 0.1,
+            gravityScale: 1,
+            shapeType: 'Box',
+            layers: 1,
+            masks: 1,
+        },
+    },
+    movement: {
+        type: 'TopDownMovementBehavior::TopDownMovementBehavior',
+        content: {
+            allowDiagonals: true,
+            acceleration: 400,
+            deceleration: 800,
+            maxSpeed: 200,
+            angularMaxSpeed: 180,
+            rotateObject: false,
+            angleOffset: 0,
+            ignoreDefaultControls: false,
+            movementAngleOffset: 0,
+        },
+    },
+    platformer: {
+        type: 'PlatformBehavior::PlatformerObjectBehavior',
+        content: {
+            acceleration: 1500,
+            deceleration: 1500,
+            maxSpeed: 250,
+            gravity: 1000,
+            maxFallingSpeed: 700,
+            jumpSpeed: 600,
+            canGrabPlatforms: false,
+            ignoreDefaultControls: false,
+            slopeMaxAngle: 60,
+            useLegacyTrajectory: false,
+        },
+    },
+    solid: {
+        type: 'PlatformBehavior::PlatformBehavior',
+        content: {
+            canBeGrabbed: true,
+            platformType: 'Platform',
+        },
+    },
+    draggable: {
+        type: 'DraggableBehavior::Draggable',
+        content: {},
+    },
+    bounce: {
+        type: 'BounceBehavior::BounceBehavior',
+        content: {},
+    },
+    tween: {
+        type: 'Tween::TweenBehavior',
+        content: {},
+    },
+    pathfinding: {
+        type: 'PathfindingBehavior::PathfindingBehavior',
+        content: {
+            allowDiagonals: true,
+            acceleration: 400,
+            maxSpeed: 200,
+            angularMaxSpeed: 180,
+            rotateObject: true,
+            angleOffset: 0,
+            extraBorder: 0,
+            cellWidth: 20,
+            cellHeight: 20,
+        },
+    },
+    anchor: {
+        type: 'AnchorBehavior::AnchorBehavior',
+        content: {},
+    },
+};
+/* ── Exporter Implementation ──────────────────────────────────── */
+class GDevelopExporter extends PlatformExporter.PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'gdevelop';
+        this.platformInfo = {
+            id: 'gdevelop',
+            name: 'GDevelop 5',
+            description: 'GDevelop - Open-source, cross-platform 2D game engine',
+            website: 'https://gdevelop.io/',
+            features: [
+                '2d-rendering',
+                'physics-2d',
+                'audio',
+                'particles',
+                'ui-system',
+                'tilemaps',
+                'animation',
+            ],
+            supportedAssets: ['texture', 'audio', 'tilemap', 'animation', 'prefab', 'scene', 'data'],
+            exportFormats: ['.json'],
+        };
+        this.projectUUID = '';
+        this.zOrderCounter = 0;
+    }
+    async doExport(project, options) {
+        this.projectUUID = generateGDevelopUUID();
+        this.zOrderCounter = 0;
+        const platformOpts = options.platformOptions ?? {};
+        // Generate single project JSON file
+        const gdProject = await this.generateProject(project, options);
+        this.addTextFile('game.json', JSON.stringify(gdProject, null, 2));
+        // Generate extension if requested
+        if (platformOpts.generateExtensions !== false) {
+            await this.generateNice2DevExtension(project, options);
+        }
+        // Generate README
+        await this.generateReadme(project, options);
+    }
+    /* ── Project Generation ─────────────────────────────────────── */
+    async generateProject(project, options) {
+        const safeName = (options.projectName ?? project.name).replace(/[^a-zA-Z0-9]/g, '');
+        // Collect all unique objects
+        const globalObjects = this.collectGlobalObjects(project);
+        // Generate layouts from scenes
+        const layouts = [];
+        for (const scene of project.scenes) {
+            layouts.push(this.generateLayout(scene, project, options));
+        }
+        // Generate extension
+        const extensions = [];
+        const platformOpts = options.platformOptions ?? {};
+        if (platformOpts.generateExtensions !== false) {
+            extensions.push(this.createNice2DevExtension(project));
+        }
+        // Generate resources from assets
+        const resources = this.collectResources(project);
+        const gdProject = {
+            firstLayout: layouts[0]?.name ?? 'Scene1',
+            gdVersion: { build: 203, major: 5, minor: 3, revision: 0 },
+            properties: {
+                adaptGameResolutionAtRuntime: true,
+                antialiasingMode: 'MSAA',
+                author: 'Nice2Dev',
+                authorIds: [],
+                categories: [],
+                description: `Generated from Nice2Dev project: ${project.name}`,
+                folderProject: false,
+                gameResolutionResizingMode: 'adaptWidth',
+                latestCompilationDirectory: '',
+                maxFPS: 60,
+                minFPS: 20,
+                name: safeName,
+                orientation: 'landscape',
+                packageName: `com.nice2dev.${safeName.toLowerCase()}`,
+                pixelsRounding: false,
+                platformSpecificAssets: {},
+                playableDevicesTouchControls: true,
+                projectUuid: this.projectUUID,
+                scaleMode: 'linear',
+                sizeOnStartupMode: '',
+                useDeprecatedZeroAsDefaultZOrder: false,
+                useExternalSourceFiles: false,
+                version: project.version,
+                windowWidth: project.settings.resolution.width,
+                windowHeight: project.settings.resolution.height,
+            },
+            resources: { resources, resourceFolders: [] },
+            objects: globalObjects,
+            objectsFolderStructure: { folderName: '__ROOT', children: [] },
+            objectsGroups: [],
+            variables: this.generateGlobalVariables(project),
+            layouts,
+            externalEvents: [],
+            eventsFunctionsExtensions: extensions,
+            externalLayouts: [],
+            externalSourceFiles: [],
+        };
+        return gdProject;
+    }
+    collectGlobalObjects(project) {
+        const objectsMap = new Map();
+        // Collect unique entities
+        for (const scene of project.scenes) {
+            for (const entity of scene.entities) {
+                const name = (entity.name ?? entity.id).replace(/[^a-zA-Z0-9_]/g, '_');
+                if (!objectsMap.has(name)) {
+                    objectsMap.set(name, entity);
+                }
+            }
+        }
+        // Collect prefabs
+        for (const prefab of project.prefabs) {
+            const name = prefab.name.replace(/[^a-zA-Z0-9_]/g, '_');
+            if (!objectsMap.has(name)) {
+                objectsMap.set(name, prefab.entity);
+            }
+        }
+        return Array.from(objectsMap.entries()).map(([name, entity]) => this.entityToGDObject(name, entity));
+    }
+    entityToGDObject(name, entity) {
+        const behaviors = [];
+        const variables = [];
+        // Map components to behaviors
+        for (const comp of entity.components) {
+            const mapping = GDEVELOP_BEHAVIOR_MAP[comp.type];
+            if (mapping) {
+                const content = { ...mapping.content };
+                // Apply component properties
+                if (comp.properties) {
+                    for (const [key, value] of Object.entries(comp.properties)) {
+                        if (key in content) {
+                            content[key] = value;
+                        }
+                    }
+                }
+                behaviors.push({
+                    name: comp.type,
+                    type: mapping.type,
+                    content,
+                });
+            }
+        }
+        // Add tags as variables
+        for (const tag of entity.tags ?? []) {
+            variables.push({
+                name: `tag_${tag}`,
+                type: 'boolean',
+                value: true,
+            });
+        }
+        // Determine if sprite or other object type
+        entity.components.some((c) => c.type === 'sprite');
+        const object = {
+            name,
+            type: 'Sprite',
+            updateIfNotVisible: false,
+            variables,
+            behaviors,
+            effects: [],
+            animations: [
+                {
+                    name: 'Default',
+                    useMultipleDirections: false,
+                    directions: [
+                        {
+                            looping: true,
+                            timeBetweenFrames: 0.1,
+                            sprites: [
+                                {
+                                    hasCustomCollisionMask: false,
+                                    image: `${name}_default`,
+                                    originPoint: { name: 'origine', x: 0, y: 0 },
+                                    centerPoint: { automatic: true, name: 'centre', x: 0, y: 0 },
+                                    points: [],
+                                    customCollisionMask: [],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        };
+        return object;
+    }
+    /* ── Layout Generation ──────────────────────────────────────── */
+    generateLayout(scene, project, options) {
+        const layoutName = scene.name.replace(/[^a-zA-Z0-9_]/g, '_');
+        this.zOrderCounter = 0;
+        // Generate instances from entities
+        const instances = scene.entities.map((entity) => this.entityToGDInstance(entity));
+        // Generate events for this scene
+        const events = this.generateSceneEvents(scene, project, options);
+        return {
+            b: 0,
+            disableInputWhenNotFocused: true,
+            mangledName: layoutName,
+            name: layoutName,
+            r: 0,
+            g: 0,
+            stopSoundsOnStartup: true,
+            title: scene.name,
+            v: 0,
+            uiSettings: {},
+            objectsGroups: [],
+            variables: [],
+            instances,
+            objects: [], // Object definitions are at project level
+            events,
+            layers: [
+                {
+                    ambientLightColorB: 128,
+                    ambientLightColorG: 128,
+                    ambientLightColorR: 128,
+                    camera3DFarPlaneDistance: 10000,
+                    camera3DFieldOfView: 45,
+                    camera3DNearPlaneDistance: 3,
+                    followBaseLayerCamera: false,
+                    isLightingLayer: false,
+                    isLocked: false,
+                    name: '',
+                    renderingType: '',
+                    visibility: true,
+                    cameras: [],
+                    effects: [],
+                },
+            ],
+            behaviorsSharedData: [],
+        };
+    }
+    entityToGDInstance(entity) {
+        const name = (entity.name ?? entity.id).replace(/[^a-zA-Z0-9_]/g, '_');
+        const pos = entity.position ?? { x: 0, y: 0 };
+        const scale = entity.scale ?? { x: 1, y: 1 };
+        return {
+            angle: entity.rotation ?? 0,
+            customSize: scale.x !== 1 || scale.y !== 1,
+            height: 64 * scale.y,
+            layer: '',
+            locked: false,
+            name,
+            width: 64 * scale.x,
+            x: pos.x,
+            y: pos.y,
+            zOrder: this.zOrderCounter++,
+            numberProperties: [],
+            stringProperties: [],
+            initialVariables: [],
+        };
+    }
+    /* ── Event Generation ───────────────────────────────────────── */
+    generateSceneEvents(scene, project, options) {
+        const events = [];
+        // Header comment
+        events.push({
+            type: 'BuiltinCommonInstructions::Comment',
+            color: { b: 109, g: 230, r: 255, textB: 0, textG: 0, textR: 0 },
+            comment: `Scene: ${scene.name}\nGenerated from Nice2Dev`,
+        });
+        // Scene start event
+        events.push({
+            type: 'BuiltinCommonInstructions::Standard',
+            conditions: [
+                {
+                    type: { inverted: false, value: 'DepartScene' },
+                    parameters: [],
+                },
+            ],
+            actions: [
+                {
+                    type: { inverted: false, value: 'ModVarScene' },
+                    parameters: ['__N2D_SceneStarted', '=', '1'],
+                },
+            ],
+            events: [
+                {
+                    type: 'BuiltinCommonInstructions::Comment',
+                    comment: 'Scene initialization',
+                },
+            ],
+        });
+        // Main game loop
+        events.push({
+            type: 'BuiltinCommonInstructions::Comment',
+            comment: 'Main game loop',
+        });
+        // Entity-specific events
+        for (const entity of scene.entities) {
+            const entityEvents = this.generateEntityEvents(entity);
+            if (entityEvents.length > 0) {
+                events.push({
+                    type: 'BuiltinCommonInstructions::Group',
+                    parameters: [entity.name ?? entity.id],
+                    events: entityEvents,
+                });
+            }
+        }
+        return events;
+    }
+    generateEntityEvents(entity) {
+        const events = [];
+        const name = (entity.name ?? entity.id).replace(/[^a-zA-Z0-9_]/g, '_');
+        // Generate events based on components
+        for (const comp of entity.components) {
+            switch (comp.type) {
+                case 'health':
+                    events.push({
+                        type: 'BuiltinCommonInstructions::Standard',
+                        conditions: [
+                            {
+                                type: { inverted: false, value: `${name}.Variable` },
+                                parameters: [name, 'health', '<=', '0'],
+                            },
+                        ],
+                        actions: [
+                            {
+                                type: { inverted: false, value: 'Delete' },
+                                parameters: [name, ''],
+                            },
+                        ],
+                    });
+                    break;
+                case 'autoDestroy':
+                    const lifetime = comp.properties?.['lifetime'] ?? 5;
+                    events.push({
+                        type: 'BuiltinCommonInstructions::Standard',
+                        conditions: [
+                            {
+                                type: { inverted: false, value: 'Timer' },
+                                parameters: [`"${name}_lifetime"`, String(lifetime)],
+                            },
+                        ],
+                        actions: [
+                            {
+                                type: { inverted: false, value: 'Delete' },
+                                parameters: [name, ''],
+                            },
+                        ],
+                    });
+                    break;
+            }
+        }
+        return events;
+    }
+    /* ── Global Variables ───────────────────────────────────────── */
+    generateGlobalVariables(project) {
+        return [
+            { name: '__N2D_Version', type: 'string', value: project.version },
+            { name: '__N2D_ProjectName', type: 'string', value: project.name },
+            { name: 'GameWidth', type: 'number', value: project.settings.resolution.width },
+            { name: 'GameHeight', type: 'number', value: project.settings.resolution.height },
+            { name: 'MasterVolume', type: 'number', value: project.settings.audio.masterVolume },
+            { name: 'IsPaused', type: 'boolean', value: false },
+            { name: 'Score', type: 'number', value: 0 },
+        ];
+    }
+    /* ── Resources ──────────────────────────────────────────────── */
+    collectResources(project) {
+        const resources = [];
+        // Placeholder resources for each object
+        const processedNames = new Set();
+        for (const scene of project.scenes) {
+            for (const entity of scene.entities) {
+                const name = (entity.name ?? entity.id).replace(/[^a-zA-Z0-9_]/g, '_');
+                if (!processedNames.has(name)) {
+                    processedNames.add(name);
+                    resources.push({
+                        alwaysLoaded: false,
+                        file: `assets/${name}.png`,
+                        kind: 'image',
+                        metadata: '',
+                        name: `${name}_default`,
+                        smoothed: true,
+                        userAdded: true,
+                    });
+                }
+            }
+        }
+        for (const prefab of project.prefabs) {
+            const name = prefab.name.replace(/[^a-zA-Z0-9_]/g, '_');
+            if (!processedNames.has(name)) {
+                processedNames.add(name);
+                resources.push({
+                    alwaysLoaded: false,
+                    file: `assets/${name}.png`,
+                    kind: 'image',
+                    metadata: '',
+                    name: `${name}_default`,
+                    smoothed: true,
+                    userAdded: true,
+                });
+            }
+        }
+        return resources;
+    }
+    /* ── Nice2Dev Extension ─────────────────────────────────────── */
+    createNice2DevExtension(project) {
+        return {
+            authorIds: [],
+            author: 'Nice2Dev',
+            category: 'General',
+            description: 'Nice2Dev game utilities and functions',
+            extensionNamespace: 'Nice2Dev',
+            fullName: 'Nice2Dev Utilities',
+            helpPath: '',
+            iconUrl: '',
+            name: 'Nice2Dev',
+            previewIconUrl: '',
+            shortDescription: 'Utilities for Nice2Dev exported games',
+            version: project.version,
+            origin: { identifier: 'Nice2Dev', name: 'Nice2Dev' },
+            tags: ['nice2dev', 'game', 'utilities'],
+            eventsBasedBehaviors: [
+                {
+                    description: 'Nice2Dev entity behavior with common game functionality',
+                    fullName: 'Nice2Dev Entity',
+                    name: 'N2DEntity',
+                    objectType: 'Sprite',
+                    eventsFunctions: [
+                        {
+                            description: 'Initialize the Nice2Dev entity',
+                            fullName: 'Initialize entity',
+                            functionType: 'Action',
+                            name: 'Initialize',
+                            sentence: 'Initialize _PARAM0_ as Nice2Dev entity',
+                            events: [],
+                            parameters: [
+                                {
+                                    description: 'Object',
+                                    longDescription: '',
+                                    name: 'Object',
+                                    supplementaryInformation: 'Sprite',
+                                    type: 'object',
+                                },
+                            ],
+                            objectGroups: [],
+                        },
+                        {
+                            description: 'Apply damage to entity',
+                            fullName: 'Apply damage',
+                            functionType: 'Action',
+                            name: 'TakeDamage',
+                            sentence: 'Apply _PARAM1_ damage to _PARAM0_',
+                            events: [
+                                {
+                                    type: 'BuiltinCommonInstructions::Standard',
+                                    conditions: [],
+                                    actions: [
+                                        {
+                                            type: { inverted: false, value: 'ModVarObjet' },
+                                            parameters: ['Object', 'health', '-', 'GetArgumentAsNumber("Amount")'],
+                                        },
+                                    ],
+                                },
+                            ],
+                            parameters: [
+                                {
+                                    description: 'Object',
+                                    longDescription: '',
+                                    name: 'Object',
+                                    supplementaryInformation: 'Sprite',
+                                    type: 'object',
+                                },
+                                {
+                                    description: 'Damage amount',
+                                    longDescription: '',
+                                    name: 'Amount',
+                                    supplementaryInformation: '',
+                                    type: 'expression',
+                                },
+                            ],
+                            objectGroups: [],
+                        },
+                    ],
+                    propertyDescriptors: [
+                        {
+                            value: '100',
+                            type: 'Number',
+                            label: 'Max Health',
+                            description: 'Maximum health for this entity',
+                            group: 'Health',
+                            extraInformation: [],
+                            hidden: false,
+                            name: 'MaxHealth',
+                        },
+                        {
+                            value: '100',
+                            type: 'Number',
+                            label: 'Current Health',
+                            description: 'Current health for this entity',
+                            group: 'Health',
+                            extraInformation: [],
+                            hidden: false,
+                            name: 'Health',
+                        },
+                    ],
+                    sharedPropertyDescriptors: [],
+                },
+            ],
+            eventsBasedObjects: [],
+            eventsFunctions: [
+                {
+                    description: 'Get the Nice2Dev version',
+                    fullName: 'Get Nice2Dev version',
+                    functionType: 'StringExpression',
+                    name: 'Version',
+                    sentence: '',
+                    events: [
+                        {
+                            type: 'BuiltinCommonInstructions::Standard',
+                            conditions: [],
+                            actions: [
+                                {
+                                    type: { inverted: false, value: 'SetReturnString' },
+                                    parameters: [`"${project.version}"`],
+                                },
+                            ],
+                        },
+                    ],
+                    expressionType: { type: 'string' },
+                    parameters: [],
+                    objectGroups: [],
+                },
+                {
+                    description: 'Pause the game',
+                    fullName: 'Pause game',
+                    functionType: 'Action',
+                    name: 'Pause',
+                    sentence: 'Pause the game',
+                    events: [
+                        {
+                            type: 'BuiltinCommonInstructions::Standard',
+                            conditions: [],
+                            actions: [
+                                {
+                                    type: { inverted: false, value: 'SetGlobalVariableAsBoolean' },
+                                    parameters: ['IsPaused', 'True'],
+                                },
+                            ],
+                        },
+                    ],
+                    parameters: [],
+                    objectGroups: [],
+                },
+                {
+                    description: 'Resume the game',
+                    fullName: 'Resume game',
+                    functionType: 'Action',
+                    name: 'Resume',
+                    sentence: 'Resume the game',
+                    events: [
+                        {
+                            type: 'BuiltinCommonInstructions::Standard',
+                            conditions: [],
+                            actions: [
+                                {
+                                    type: { inverted: false, value: 'SetGlobalVariableAsBoolean' },
+                                    parameters: ['IsPaused', 'False'],
+                                },
+                            ],
+                        },
+                    ],
+                    parameters: [],
+                    objectGroups: [],
+                },
+            ],
+            globalVariables: [],
+            sceneVariables: [],
+        };
+    }
+    async generateNice2DevExtension(project, options) {
+        // Extension is already embedded in the project, this generates a standalone version
+        const extension = this.createNice2DevExtension(project);
+        this.addTextFile('extensions/Nice2Dev.json', JSON.stringify(extension, null, 2));
+    }
+    /* ── README ─────────────────────────────────────────────────── */
+    async generateReadme(project, options) {
+        const readme = `# ${project.name} - GDevelop 5 Export
+
+Generated from Nice2Dev project v${project.version}
+
+## Installation
+
+1. Open GDevelop 5
+2. Create new project or open existing
+3. Import \`game.json\` (File > Open > select game.json)
+4. Import assets to the \`assets/\` folder
+
+## Project Structure
+
+- \`game.json\` - Main GDevelop project file
+- \`extensions/Nice2Dev.json\` - Nice2Dev utilities extension (optional standalone)
+- \`assets/\` - Place your image and audio assets here
+
+## Scenes
+
+${project.scenes.map((s) => `- ${s.name} (${s.entities.length} objects)`).join('\n')}
+
+## Nice2Dev Extension Features
+
+### Custom Behavior: N2DEntity
+- Health system with MaxHealth and Health properties
+- TakeDamage action
+
+### Functions
+- \`Nice2Dev::Version()\` - Returns Nice2Dev version string
+- \`Nice2Dev::Pause()\` - Pause the game
+- \`Nice2Dev::Resume()\` - Resume the game
+
+## Global Variables
+
+- \`GameWidth\` - Game resolution width (${project.settings.resolution.width})
+- \`GameHeight\` - Game resolution height (${project.settings.resolution.height})
+- \`MasterVolume\` - Master audio volume (${project.settings.audio.masterVolume})
+- \`IsPaused\` - Game pause state
+- \`Score\` - Player score
+
+## Notes
+
+- Replace placeholder images in \`assets/\` folder with actual game assets
+- Adjust physics and movement values as needed
+- Audio files should be imported separately
+
+## Settings
+
+- Resolution: ${project.settings.resolution.width}x${project.settings.resolution.height}
+- Physics: ${project.settings.physics.enabled ? 'Enabled' : 'Disabled'}
+- Gravity: (${project.settings.physics.gravity.x}, ${project.settings.physics.gravity.y})
+`;
+        this.addTextFile('README.md', readme);
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createGDevelopExporter() {
+    return new GDevelopExporter();
+}
+
+exports.GDevelopExporter = GDevelopExporter;
+exports.createGDevelopExporter = createGDevelopExporter;
+//# sourceMappingURL=GDevelopExporter.js.map