@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/cjs/export/CocosExporter.js

@@ -0,0 +1,706 @@
+'use strict';
+
+var PlatformExporter = require('./PlatformExporter.js');
+
+/* ────────────────────────────────────────────────────────────────
+   Cocos Creator Exporter — Cocos Creator 3.x Project Export
+   
+   Exports Nice2Dev projects to Cocos Creator 3.x format including:
+   - TypeScript components and scripts
+   - Scene files (.scene)
+   - Prefab files (.prefab)
+   - Animation clips (.anim)
+   - Asset meta files
+──────────────────────────────────────────────────────────────── */
+function generateShortUUID() {
+    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}
+const COCOS_COMPONENT_MAP = {
+    sprite: {
+        type: 'cc.Sprite',
+        properties: new Map([
+            ['texture', 'spriteFrame'],
+            ['color', 'color'],
+        ]),
+        additionalSetup: () => ({
+            _type: 1, // SpriteType.SIMPLE
+            _sizeMode: 1, // SizeMode.TRIMMED
+        }),
+    },
+    transform: {
+        type: 'cc.UITransform', // For 2D
+        properties: new Map([
+            ['width', 'contentSize.width'],
+            ['height', 'contentSize.height'],
+        ]),
+    },
+    rigidbody: {
+        type: 'cc.RigidBody2D',
+        properties: new Map([
+            ['type', 'type'],
+            ['linearDamping', 'linearDamping'],
+            ['angularDamping', 'angularDamping'],
+            ['gravityScale', 'gravityScale'],
+        ]),
+    },
+    boxCollider: {
+        type: 'cc.BoxCollider2D',
+        properties: new Map([
+            ['size', 'size'],
+            ['offset', 'offset'],
+            ['isTrigger', 'sensor'],
+        ]),
+    },
+    circleCollider: {
+        type: 'cc.CircleCollider2D',
+        properties: new Map([
+            ['radius', 'radius'],
+            ['offset', 'offset'],
+            ['isTrigger', 'sensor'],
+        ]),
+    },
+    audioSource: {
+        type: 'cc.AudioSource',
+        properties: new Map([
+            ['clip', 'clip'],
+            ['volume', 'volume'],
+            ['loop', 'loop'],
+            ['playOnAwake', 'playOnAwake'],
+        ]),
+    },
+    animation: {
+        type: 'cc.Animation',
+        properties: new Map([
+            ['clips', 'clips'],
+            ['defaultClip', 'defaultClip'],
+            ['playOnLoad', 'playOnLoad'],
+        ]),
+    },
+    camera: {
+        type: 'cc.Camera',
+        properties: new Map([
+            ['priority', 'priority'],
+            ['clearFlags', 'clearFlags'],
+            ['clearColor', 'clearColor'],
+        ]),
+    },
+    label: {
+        type: 'cc.Label',
+        properties: new Map([
+            ['string', 'string'],
+            ['fontSize', 'fontSize'],
+            ['lineHeight', 'lineHeight'],
+            ['color', 'color'],
+        ]),
+    },
+    button: {
+        type: 'cc.Button',
+        properties: new Map([
+            ['interactable', 'interactable'],
+            ['transition', 'transition'],
+        ]),
+    },
+    particleSystem: {
+        type: 'cc.ParticleSystem2D',
+        properties: new Map([
+            ['file', 'file'],
+            ['playOnLoad', 'playOnLoad'],
+            ['autoRemoveOnFinish', 'autoRemoveOnFinish'],
+        ]),
+    },
+    tiledMap: {
+        type: 'cc.TiledMap',
+        properties: new Map([['tmxAsset', 'tmxAsset']]),
+    },
+};
+/* ── Cocos Color Utilities ────────────────────────────────────── */
+function colorToCocosJson(color) {
+    if (typeof color === 'string') {
+        const hex = color.replace('#', '');
+        const r = parseInt(hex.substr(0, 2), 16);
+        const g = parseInt(hex.substr(2, 2), 16);
+        const b = parseInt(hex.substr(4, 2), 16);
+        const a = hex.length === 8 ? parseInt(hex.substr(6, 2), 16) : 255;
+        return { __type__: 'cc.Color', r, g, b, a };
+    }
+    return {
+        __type__: 'cc.Color',
+        r: Math.round(color.r * 255),
+        g: Math.round(color.g * 255),
+        b: Math.round(color.b * 255),
+        a: Math.round((color.a ?? 1) * 255),
+    };
+}
+function vec2ToCocosJson(v) {
+    return { __type__: 'cc.Vec2', x: v.x, y: v.y };
+}
+function vec3ToCocosJson(v) {
+    return { __type__: 'cc.Vec3', x: v.x, y: v.y, z: v.z ?? 0 };
+}
+function sizeToCocosJson(w, h) {
+    return { __type__: 'cc.Size', width: w, height: h };
+}
+/* ── Cocos Creator Exporter Implementation ────────────────────── */
+class CocosExporter extends PlatformExporter.PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'cocos';
+        this.platformInfo = {
+            id: 'cocos',
+            name: 'Cocos Creator',
+            description: 'Cocos Creator 3.x game engine with TypeScript support',
+            website: 'https://www.cocos.com/en/creator',
+            features: [
+                '2d-rendering',
+                '3d-rendering',
+                'physics-2d',
+                'physics-3d',
+                'audio',
+                'networking',
+                'ui-system',
+                'tilemaps',
+                'particles',
+                'animation',
+            ],
+            supportedAssets: [
+                'sprite',
+                'tileset',
+                'audio',
+                'font',
+                'script',
+                'scene',
+                'prefab',
+                'animation',
+                'particleSystem',
+                'texture',
+                'data',
+            ],
+            exportFormats: ['.scene', '.prefab', '.ts', '.meta', '.anim'],
+        };
+        this.uuidMap = new Map();
+        this.engineVersion = '3.8.0';
+        this.useTypeScript = true;
+        this.is2D = true;
+    }
+    async doExport(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        this.engineVersion = platformOpts.engineVersion ?? '3.8.0';
+        this.useTypeScript = platformOpts.useTypeScript !== false;
+        this.is2D = platformOpts.mode !== '3d';
+        this.uuidMap.clear();
+        // Generate project configuration
+        await this.generateProjectConfig(project, options);
+        // Generate TypeScript/JavaScript components
+        await this.generateScripts(project, options);
+        // Export scenes
+        for (const scene of project.scenes) {
+            await this.exportScene(scene, project, options);
+        }
+        // Export prefabs
+        for (const prefab of project.prefabs) {
+            await this.exportPrefab(prefab, options);
+        }
+        // Export assets with meta files
+        for (const asset of project.assets) {
+            await this.exportAsset(asset, options);
+        }
+    }
+    /* ── Project Configuration ──────────────────────────────────── */
+    async generateProjectConfig(project, options) {
+        const projectName = options.projectName ?? project.name;
+        const platformOpts = options.platformOptions ?? {};
+        // creator.d.ts settings file (simplified project.json)
+        const projectJson = {
+            name: projectName,
+            version: project.version,
+            'engine-version': this.engineVersion,
+            description: project.description ?? '',
+            'render-mode': this.is2D ? 1 : 0,
+            'design-width': project.settings.resolution.width,
+            'design-height': project.settings.resolution.height,
+            'fit-width': false,
+            'fit-height': true,
+        };
+        this.addTextFile('settings/project.json', JSON.stringify(projectJson, null, 2));
+        // tsconfig.json for TypeScript projects
+        if (this.useTypeScript) {
+            const tsConfig = {
+                compilerOptions: {
+                    target: 'ES2015',
+                    module: 'ES2015',
+                    lib: ['ES2015', 'DOM'],
+                    strict: true,
+                    esModuleInterop: true,
+                    skipLibCheck: true,
+                    declaration: true,
+                    moduleResolution: 'node',
+                    resolveJsonModule: true,
+                    types: [],
+                },
+                include: ['assets/**/*.ts', 'extensions/**/*.ts'],
+                exclude: ['node_modules'],
+            };
+            this.addTextFile('tsconfig.json', JSON.stringify(tsConfig, null, 2));
+        }
+        // Physics configuration
+        const physicsConfig = {
+            enabled: project.settings.physics.enabled,
+            gravity: vec2ToCocosJson(project.settings.physics.gravity),
+            velocityIterations: project.settings.physics.velocityIterations ?? 10,
+            positionIterations: project.settings.physics.positionIterations ?? 10,
+            physicsEngine: platformOpts.physicsEngine ?? 'box2d',
+        };
+        this.addTextFile('settings/physics.json', JSON.stringify(physicsConfig, null, 2));
+    }
+    /* ── Script Generation ──────────────────────────────────────── */
+    async generateScripts(project, options) {
+        // Generate game manager script
+        this.generateGameManager(project, options);
+        // Generate entity scripts for unique entity types
+        const entityTypes = new Set();
+        for (const scene of project.scenes) {
+            for (const entity of scene.entities) {
+                if (entity.type) {
+                    entityTypes.add(entity.type);
+                }
+            }
+        }
+        for (const entityType of entityTypes) {
+            this.generateEntityScript(entityType, options);
+        }
+    }
+    generateGameManager(project, options) {
+        const ext = this.useTypeScript ? 'ts' : 'js';
+        const res = project.settings.resolution;
+        const script = `import { _decorator, Component, Node, director } from 'cc';
+const { ccclass, property } = _decorator;
+
+/**
+ * Game Manager - Main game controller
+ * Generated from Nice2Dev project: ${project.name}
+ */
+@ccclass('GameManager')
+export class GameManager extends Component {
+    private static _instance: GameManager | null = null;
+    
+    @property
+    gameWidth: number = ${res.width};
+    
+    @property
+    gameHeight: number = ${res.height};
+    
+    @property
+    masterVolume: number = ${project.settings.audio.masterVolume};
+    
+    @property
+    physicsEnabled: boolean = ${project.settings.physics.enabled};
+
+    static get instance(): GameManager | null {
+        return GameManager._instance;
+    }
+
+    onLoad() {
+        if (GameManager._instance === null) {
+            GameManager._instance = this;
+        } else {
+            this.node.destroy();
+            return;
+        }
+
+        // Initialize game systems
+        this.initializeAudio();
+        this.initializePhysics();
+    }
+
+    private initializeAudio() {
+        // Audio initialization
+    }
+
+    private initializePhysics() {
+        // Physics world initialization
+    }
+
+    loadScene(sceneName: string) {
+        director.loadScene(sceneName);
+    }
+
+    pauseGame() {
+        director.pause();
+    }
+
+    resumeGame() {
+        director.resume();
+    }
+}
+`;
+        this.addTextFile(`assets/scripts/GameManager.${ext}`, script);
+        this.generateMetaFile(`assets/scripts/GameManager.${ext}`, 'typescript');
+    }
+    generateEntityScript(entityType, options) {
+        const ext = this.useTypeScript ? 'ts' : 'js';
+        const className = entityType.charAt(0).toUpperCase() + entityType.slice(1);
+        const script = `import { _decorator, Component, Node, Vec2, Vec3 } from 'cc';
+const { ccclass, property, executionOrder } from _decorator;
+
+/**
+ * ${className} - Entity script
+ * Generated from Nice2Dev entity type: ${entityType}
+ */
+@ccclass('${className}')
+@executionOrder(0)
+export class ${className} extends Component {
+    @property
+    entityId: string = '';
+
+    @property([String])
+    tags: string[] = [];
+
+    @property
+    speed: number = 100;
+
+    private _velocity: Vec2 = new Vec2();
+
+    onLoad() {
+        // Initialize entity
+        this.onNiceStart();
+    }
+
+    start() {
+        // Called after all onLoad
+    }
+
+    update(deltaTime: number) {
+        this.onNiceUpdate(deltaTime);
+    }
+
+    /** Override for custom start logic */
+    protected onNiceStart() {
+        // Initialization logic
+    }
+
+    /** Override for custom update logic */
+    protected onNiceUpdate(deltaTime: number) {
+        // Update logic
+    }
+
+    /** Move entity towards a target position */
+    moveTowards(target: Vec3, speed: number, deltaTime: number) {
+        const currentPos = this.node.position;
+        const direction = new Vec3();
+        Vec3.subtract(direction, target, currentPos);
+        direction.normalize();
+        
+        const movement = new Vec3();
+        Vec3.multiplyScalar(movement, direction, speed * deltaTime);
+        
+        const newPos = new Vec3();
+        Vec3.add(newPos, currentPos, movement);
+        this.node.setPosition(newPos);
+    }
+
+    /** Set velocity for physics-based movement */
+    setVelocity(x: number, y: number) {
+        this._velocity.set(x, y);
+    }
+
+    /** Check if entity has a specific tag */
+    hasTag(tag: string): boolean {
+        return this.tags.includes(tag);
+    }
+}
+`;
+        this.addTextFile(`assets/scripts/entities/${className}.${ext}`, script);
+        this.generateMetaFile(`assets/scripts/entities/${className}.${ext}`, 'typescript');
+    }
+    /* ── Scene Export ───────────────────────────────────────────── */
+    async exportScene(scene, project, options) {
+        const sceneData = this.buildSceneData(scene, project);
+        const scenePath = `assets/scenes/${scene.name}.scene`;
+        this.addTextFile(scenePath, JSON.stringify(sceneData, null, 2));
+        this.generateMetaFile(scenePath, 'scene');
+    }
+    buildSceneData(scene, project) {
+        const sceneData = [];
+        this.getOrCreateUUID(scene.id);
+        // Scene asset header
+        sceneData.push({
+            __type__: 'cc.SceneAsset',
+            _name: scene.name,
+            scene: { __id__: 1 },
+        });
+        // Scene node
+        sceneData.push({
+            __type__: 'cc.Scene',
+            _name: scene.name,
+            _active: true,
+            _children: scene.entities.map((_, idx) => ({ __id__: 2 + idx })),
+            _globals: { __id__: sceneData.length + scene.entities.length + 1 },
+            autoReleaseAssets: false,
+        });
+        // Entity nodes
+        for (const entity of scene.entities) {
+            const nodeData = this.buildNodeData(entity, sceneData.length);
+            sceneData.push(...nodeData);
+        }
+        // Scene globals
+        sceneData.push({
+            __type__: 'cc.SceneGlobals',
+            ambient: {
+                _skyColor: colorToCocosJson(project.settings.backgroundColor),
+                _skyIllum: 20000,
+                _groundAlbedo: colorToCocosJson('#333333'),
+            },
+            shadows: { enabled: false },
+            fog: { enabled: false },
+        });
+        return sceneData;
+    }
+    buildNodeData(entity, startIndex) {
+        const nodeData = [];
+        const nodeUuid = this.getOrCreateUUID(entity.id);
+        const pos = entity.position ?? { x: 0, y: 0 };
+        const rot = entity.rotation ?? 0;
+        const scale = entity.scale ?? { x: 1, y: 1 };
+        // Main node
+        const componentIds = [];
+        let currentIdx = startIndex + 1;
+        // Calculate component IDs
+        for (const comp of entity.components) {
+            if (COCOS_COMPONENT_MAP[comp.type]) {
+                componentIds.push({ __id__: currentIdx++ });
+            }
+        }
+        // Add UITransform for 2D nodes
+        if (this.is2D) {
+            componentIds.unshift({ __id__: currentIdx++ });
+        }
+        // Build child references
+        const childIds = (entity.children ?? []).map((_, idx) => ({ __id__: currentIdx + idx }));
+        nodeData.push({
+            __type__: 'cc.Node',
+            _name: entity.name ?? entity.id,
+            _active: entity.active !== false,
+            _components: componentIds,
+            _children: childIds,
+            _lpos: vec3ToCocosJson({ x: pos.x, y: pos.y, z: 0 }),
+            _lrot: {
+                __type__: 'cc.Quat',
+                x: 0,
+                y: 0,
+                z: Math.sin((rot * Math.PI) / 360),
+                w: Math.cos((rot * Math.PI) / 360),
+            },
+            _lscale: vec3ToCocosJson({ x: scale.x, y: scale.y, z: 1 }),
+            _layer: 1 << 25, // UI_2D layer
+            _euler: vec3ToCocosJson({ x: 0, y: 0, z: rot }),
+            _id: nodeUuid,
+        });
+        // UITransform for 2D
+        if (this.is2D) {
+            nodeData.push({
+                __type__: 'cc.UITransform',
+                _name: '',
+                _enabled: true,
+                node: { __id__: startIndex },
+                _contentSize: sizeToCocosJson(100, 100),
+                _anchorPoint: vec2ToCocosJson({ x: 0.5, y: 0.5 }),
+            });
+        }
+        // Entity components
+        for (const comp of entity.components) {
+            const mapping = COCOS_COMPONENT_MAP[comp.type];
+            if (mapping) {
+                const compData = {
+                    __type__: mapping.type,
+                    _name: '',
+                    _enabled: true,
+                    node: { __id__: startIndex },
+                };
+                // Map properties
+                if (comp.properties) {
+                    for (const [key, value] of Object.entries(comp.properties)) {
+                        const cocosKey = mapping.properties.get(key);
+                        if (cocosKey) {
+                            compData[cocosKey] = this.convertPropertyValue(key, value);
+                        }
+                    }
+                }
+                // Additional setup
+                if (mapping.additionalSetup) {
+                    Object.assign(compData, mapping.additionalSetup(comp));
+                }
+                nodeData.push(compData);
+            }
+        }
+        // Process children
+        for (const child of entity.children ?? []) {
+            const childData = this.buildNodeData(child, startIndex + nodeData.length);
+            nodeData.push(...childData);
+        }
+        return nodeData;
+    }
+    convertPropertyValue(key, value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value === 'object') {
+            if ('x' in value && 'y' in value) {
+                const v = value;
+                return 'z' in v ? vec3ToCocosJson(v) : vec2ToCocosJson(v);
+            }
+            if ('r' in value && 'g' in value && 'b' in value) {
+                return colorToCocosJson(value);
+            }
+            if ('width' in value && 'height' in value) {
+                const s = value;
+                return sizeToCocosJson(s.width, s.height);
+            }
+        }
+        if (typeof value === 'string' && value.startsWith('#')) {
+            return colorToCocosJson(value);
+        }
+        return value;
+    }
+    /* ── Prefab Export ──────────────────────────────────────────── */
+    async exportPrefab(prefab, options) {
+        const prefabData = this.buildPrefabData(prefab);
+        const prefabPath = `assets/prefabs/${prefab.name}.prefab`;
+        this.addTextFile(prefabPath, JSON.stringify(prefabData, null, 2));
+        this.generateMetaFile(prefabPath, 'prefab');
+    }
+    buildPrefabData(prefab) {
+        const data = [];
+        // Prefab header
+        data.push({
+            __type__: 'cc.Prefab',
+            _name: prefab.name,
+            data: { __id__: 1 },
+        });
+        // Build entity node data
+        const nodeData = this.buildNodeData(prefab.entity, 1);
+        data.push(...nodeData);
+        return data;
+    }
+    /* ── Asset Export ───────────────────────────────────────────── */
+    async exportAsset(asset, options) {
+        const assetPath = `assets/resources/${asset.type}/${asset.name}`;
+        switch (asset.type) {
+            case 'sprite':
+            case 'texture':
+                // Generate meta file for texture
+                this.addWarning('ASSET_MANUAL', `Texture "${asset.name}" requires manual import`, 'Copy texture file to assets folder and let Cocos Creator import it');
+                this.generateMetaFile(`${assetPath}.png`, 'texture');
+                break;
+            case 'audio':
+                this.addWarning('ASSET_MANUAL', `Audio "${asset.name}" requires manual import`, 'Copy audio file to assets folder');
+                this.generateMetaFile(`${assetPath}.mp3`, 'audio');
+                break;
+            case 'data':
+                // Export as JSON
+                const jsonContent = JSON.stringify(asset.data ?? {}, null, 2);
+                this.addTextFile(`${assetPath}.json`, jsonContent);
+                this.generateMetaFile(`${assetPath}.json`, 'json');
+                break;
+            case 'animation':
+                this.exportAnimationClip(asset);
+                break;
+        }
+    }
+    exportAnimationClip(asset) {
+        const animData = {
+            __type__: 'cc.AnimationClip',
+            _name: asset.name,
+            _duration: asset.data?.duration ?? 1,
+            sample: 60,
+            speed: 1,
+            wrapMode: 2, // Loop
+            curveData: {},
+        };
+        const animPath = `assets/animations/${asset.name}.anim`;
+        this.addTextFile(animPath, JSON.stringify(animData, null, 2));
+        this.generateMetaFile(animPath, 'animation');
+    }
+    /* ── Meta File Generation ───────────────────────────────────── */
+    generateMetaFile(assetPath, assetType) {
+        const uuid = this.getOrCreateUUID(assetPath);
+        const meta = {
+            ver: '2.0.0',
+            importer: this.getImporterType(assetType),
+            uuid,
+            files: ['.json'],
+            subMetas: {},
+        };
+        // Type-specific meta options
+        switch (assetType) {
+            case 'texture':
+                meta.importer = 'image';
+                meta.type = 'sprite-frame';
+                meta.wrapMode = 'clamp';
+                meta.filterMode = 'point';
+                meta.premultipliedAlpha = false;
+                meta.userData = {
+                    hasAlpha: true,
+                    packable: true,
+                    pixelsToUnit: 100,
+                };
+                break;
+            case 'audio':
+                meta.importer = 'audio';
+                meta.userData = {
+                    loadMode: 0, // WEB_AUDIO
+                };
+                break;
+            case 'typescript':
+            case 'javascript':
+                meta.importer = 'typescript';
+                meta.isPlugin = false;
+                meta.loadPluginInWeb = true;
+                meta.loadPluginInNative = true;
+                meta.loadPluginInEditor = false;
+                break;
+            case 'scene':
+                meta.importer = 'scene';
+                break;
+            case 'prefab':
+                meta.importer = 'prefab';
+                break;
+            case 'animation':
+                meta.importer = 'animation-clip';
+                break;
+            case 'json':
+                meta.importer = 'json';
+                break;
+        }
+        this.addTextFile(`${assetPath}.meta`, JSON.stringify(meta, null, 2));
+    }
+    getImporterType(assetType) {
+        const importerMap = {
+            texture: 'image',
+            sprite: 'image',
+            audio: 'audio',
+            font: 'font',
+            typescript: 'typescript',
+            javascript: 'javascript',
+            scene: 'scene',
+            prefab: 'prefab',
+            animation: 'animation-clip',
+            json: 'json',
+        };
+        return importerMap[assetType] ?? 'raw';
+    }
+    /* ── UUID Management ────────────────────────────────────────── */
+    getOrCreateUUID(id) {
+        if (!this.uuidMap.has(id)) {
+            this.uuidMap.set(id, generateShortUUID());
+        }
+        return this.uuidMap.get(id);
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createCocosExporter() {
+    return new CocosExporter();
+}
+
+exports.CocosExporter = CocosExporter;
+exports.createCocosExporter = createCocosExporter;
+//# sourceMappingURL=CocosExporter.js.map