@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/export/MinecraftBedrockExporter.d.ts

@@ -0,0 +1,34 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface MinecraftBedrockExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Minimum Minecraft engine version */
+        minEngineVersion?: [number, number, number];
+        /** Pack version */
+        packVersion?: [number, number, number];
+        /** Enable experimental features */
+        experimentalGameplay?: boolean;
+        /** Generate scripting API files */
+        generateScripts?: boolean;
+        /** Script API version */
+        scriptApiVersion?: '@minecraft/server' | '@minecraft/server-gametest';
+        /** World template format */
+        worldTemplate?: boolean;
+        /** Include texture assets */
+        includeTextures?: boolean;
+    };
+}
+export declare class MinecraftBedrockExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectName;
+    private namespace;
+    private resourcePackUUID;
+    private behaviorPackUUID;
+    protected doExport(project: NiceProject, options: MinecraftBedrockExportOptions): Promise<void>;
+    private generateResourcePack;
+    private generateBehaviorPack;
+    private generateScripts;
+    private exportPrefab;
+    private exportScene;
+}
+export declare function createMinecraftBedrockExporter(): MinecraftBedrockExporter;

package/dist/types/export/MonoGameExporter.d.ts

@@ -0,0 +1,71 @@
+import type { ExportConfig, GameProject } from './PlatformExporter';
+export interface MonoGameExportConfig extends ExportConfig {
+    /** Target framework */
+    framework: 'monogame' | 'fna';
+    /** MonoGame version */
+    monogameVersion: '3.8.1' | '3.8.2';
+    /** Target platform template */
+    targetPlatform: 'DesktopGL' | 'WindowsDX' | 'UWP' | 'Android' | 'iOS';
+    /** Use extended content pipeline */
+    extendedPipeline: boolean;
+    /** Generate design-time content */
+    designTimeContent: boolean;
+    /** Use entity component system (MonoGame.Extended) */
+    useECS: boolean;
+    /** Use Nez framework */
+    useNez: boolean;
+    /** Use tilemaps */
+    useTilemaps: boolean;
+    /** Namespace for generated code */
+    namespace: string;
+    /** Solution name */
+    solutionName: string;
+}
+export declare const DEFAULT_MONOGAME_CONFIG: MonoGameExportConfig;
+export declare class MonoGameExporter {
+    private config;
+    private csharpFiles;
+    private contentFiles;
+    private assets;
+    constructor(config?: Partial<MonoGameExportConfig>);
+    /** Export game project to MonoGame */
+    export(project: GameProject): Promise<{
+        success: boolean;
+        outputPath: string | undefined;
+        files: {
+            path: string;
+            content: string;
+            type: "source";
+        }[];
+        assets: {
+            path: string;
+            type: "asset";
+            originalPath: string;
+        }[];
+        stats: {
+            duration: number;
+            fileCount: number;
+            assetCount: number;
+        };
+        errors?: undefined;
+    } | {
+        success: boolean;
+        errors: string[];
+        outputPath?: undefined;
+        files?: undefined;
+        assets?: undefined;
+        stats?: undefined;
+    }>;
+    private generateSolution;
+    private generateCsproj;
+    private generateGame1;
+    private generateECSInitialization;
+    private generateComponents;
+    private generateEntities;
+    private generateSystems;
+    private generateScreens;
+    private generateContentMgcb;
+    private collectAssets;
+    private generateGuid;
+    private toPascalCase;
+}

package/dist/types/export/Pico8Exporter.d.ts

@@ -0,0 +1,40 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface Pico8ExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Optimize for token count */
+        optimizeTokens?: boolean;
+        /** Include debug tools */
+        includeDebug?: boolean;
+        /** Generate sprite sheet placeholder */
+        spriteSheet?: boolean;
+        /** Generate sfx placeholder */
+        sfxPlaceholders?: boolean;
+        /** Include music patterns */
+        musicPatterns?: boolean;
+    };
+}
+export declare class Pico8Exporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    protected doExport(project: NiceProject, options: Pico8ExportOptions): Promise<void>;
+    private generateCartridge;
+    private generateCode;
+    private generateCoreFunctions;
+    private generateEntitySystem;
+    private generateEntityDefinitions;
+    private entityTypeToLua;
+    private getEntitySpriteIndex;
+    private getComponentProperty;
+    private generateSceneSetup;
+    private generateUtilityFunctions;
+    private generateDebugOverlay;
+    private generateGfxSection;
+    private generateGffSection;
+    private generateMapSection;
+    private generateSfxSection;
+    private generateMusicSection;
+    private generateLuaSource;
+    private getClosestPico8Color;
+    private generateReadme;
+}
+export declare function createPico8Exporter(): Pico8Exporter;

package/dist/types/export/PlatformExporter.d.ts

@@ -1,5 +1,13 @@
 import type { ScriptGraph } from '../scripting/NodeGraph';
-export type PlatformId = 'unity' | 'godot' | 'unreal' | 'pixijs' | 'phaser' | 'threejs' | 'cocos' | 'gamemaker' | 'roblox' | 'minecraft' | 'rpgmaker' | 'construct3' | 'gdevelop' | 'defold' | 'solar2d' | 'pico8' | 'tic80' | 'web-generic';
+/** Generic base config for platform exporters. */
+export interface ExportConfig {
+    outputPath?: string;
+    assetPath?: string;
+    projectName?: string;
+    [key: string]: unknown;
+}
+/** Generic exporter result. */
+export type PlatformId = 'unity' | 'godot' | 'unreal' | 'pixijs' | 'phaser' | 'threejs' | 'cocos' | 'gamemaker' | 'roblox' | 'minecraft' | 'rpgmaker' | 'construct3' | 'gdevelop' | 'defold' | 'solar2d' | 'pico8' | 'tic80' | 'web-generic' | (string & {});
 export interface PlatformInfo {
     id: PlatformId;
     name: string;
@@ -10,8 +18,8 @@ export interface PlatformInfo {
     supportedAssets: AssetType[];
     exportFormats: string[];
 }
-export type PlatformFeature = '2d-rendering' | '3d-rendering' | 'physics-2d' | 'physics-3d' | 'audio' | 'networking' | 'ui-system' | 'visual-scripting' | 'tilemaps' | 'particles' | 'animation' | 'vr-ar';
-export type AssetType = 'sprite' | 'tileset' | 'audio' | 'font' | 'script' | 'scene' | 'prefab' | 'material' | 'shader' | 'animation' | 'tilemap' | 'particleSystem' | 'texture' | 'data';
+export type PlatformFeature = '2d-rendering' | '3d-rendering' | 'physics-2d' | 'physics-3d' | 'audio' | 'networking' | 'ui-system' | 'visual-scripting' | 'tilemaps' | 'particles' | 'animation' | 'vr-ar' | (string & {});
+export type AssetType = 'sprite' | 'tileset' | 'audio' | 'font' | 'script' | 'scene' | 'prefab' | 'material' | 'shader' | 'animation' | 'tilemap' | 'particleSystem' | 'texture' | 'data' | (string & {});
 export interface NiceProject {
     name: string;
     version: string;
@@ -22,6 +30,8 @@ export interface NiceProject {
     assets: NiceAsset[];
     scripts: ScriptGraph[];
     prefabs: NicePrefab[];
+    /** Top-level entity collection alias used by some exporters (flattened from all scenes). */
+    entities?: NiceEntity[];
 }
 export interface ProjectSettings {
     resolution: {
@@ -31,6 +41,7 @@ export interface ProjectSettings {
     width?: number;
     height?: number;
     backgroundColor: string;
+    targetFrameRate?: number;
     physics: {
         gravity: {
             x: number;
@@ -40,6 +51,7 @@ export interface ProjectSettings {
         velocityIterations?: number;
         positionIterations?: number;
         timeStep?: number;
+        scale?: number;
     };
     audio: {
         masterVolume: number;
@@ -64,6 +76,7 @@ export interface NiceScene {
     tilemaps?: NiceTilemap[];
     metadata?: Record<string, unknown>;
     settings?: Record<string, unknown>;
+    background?: string;
 }
 export interface NiceEntity {
     id: string;
@@ -199,3 +212,7 @@ export declare function registerPlatform(info: PlatformInfo): void;
 export declare function getPlatformInfo(id: PlatformId): PlatformInfo | undefined;
 export declare function getAllPlatforms(): PlatformInfo[];
 export default PlatformExporter;
+export type GameProject = NiceProject;
+export type Entity = NiceEntity;
+export type Component = NiceComponent;
+export type Asset = NiceAsset;

package/dist/types/export/RPGMakerExporter.d.ts

@@ -0,0 +1,41 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface RPGMakerExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Target version */
+        version?: 'MV' | 'MZ';
+        /** Plugin name prefix */
+        pluginPrefix?: string;
+        /** Generate common events */
+        generateCommonEvents?: boolean;
+        /** Generate battle system customizations */
+        customBattleSystem?: boolean;
+        /** Tile size */
+        tileSize?: 48 | 32;
+        /** Map width in tiles */
+        defaultMapWidth?: number;
+        /** Map height in tiles */
+        defaultMapHeight?: number;
+    };
+}
+export declare class RPGMakerExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private version;
+    private pluginPrefix;
+    private tileSize;
+    protected doExport(project: NiceProject, options: RPGMakerExportOptions): Promise<void>;
+    private generateMainPlugin;
+    private getMZPluginHeader;
+    private getMVPluginHeader;
+    private getMZPluginCommands;
+    private getMVPluginCommands;
+    private generateUtilityPlugin;
+    private exportScene;
+    private entityToEvent;
+    private generateEventCommands;
+    private exportPrefab;
+    private generateCommonEvents;
+    private generateDataFiles;
+    private hashCode;
+}
+export declare function createRPGMakerExporter(): RPGMakerExporter;

package/dist/types/export/RobloxExporter.d.ts

@@ -0,0 +1,38 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface RobloxExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Generate server scripts */
+        includeServerScripts?: boolean;
+        /** Generate client scripts */
+        includeClientScripts?: boolean;
+        /** Use Roblox's new Luau strict mode */
+        strictMode?: boolean;
+        /** Game genre (affects default services) */
+        genre?: 'adventure' | 'obby' | 'simulator' | 'roleplay' | 'fps' | 'tycoon';
+        /** Enable team create compatibility */
+        teamCreate?: boolean;
+        /** Target experience type */
+        experienceType?: 'game' | 'showcase' | 'social';
+    };
+}
+export declare class RobloxExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectName;
+    private useStrictMode;
+    protected doExport(project: NiceProject, options: RobloxExportOptions): Promise<void>;
+    private generateFolderStructure;
+    private generateCoreScripts;
+    private generateServicesSetup;
+    private generateClientScripts;
+    private generateServerScripts;
+    private exportScene;
+    private generateSceneModel;
+    private generateEntityXml;
+    private generateComponentChildren;
+    private hexToRobloxColor3;
+    private generateSceneScript;
+    private exportPrefab;
+    private luaTableFromObject;
+}
+export declare function createRobloxExporter(): RobloxExporter;

package/dist/types/export/Solar2DExporter.d.ts

@@ -0,0 +1,33 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface Solar2DExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Target platforms */
+        platforms?: ('ios' | 'android' | 'win32' | 'macos' | 'tvos' | 'html5')[];
+        /** Use physics engine (Box2D) */
+        usePhysics?: boolean;
+        /** Use Composer scene manager */
+        useComposer?: boolean;
+        /** Generate plugin stubs */
+        pluginStubs?: boolean;
+        /** Generate push notification config */
+        pushNotifications?: boolean;
+        /** Content scaling mode */
+        scale?: 'letterbox' | 'zoomStretch' | 'zoomEven' | 'none';
+    };
+}
+export declare class Solar2DExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    protected doExport(project: NiceProject, options: Solar2DExportOptions): Promise<void>;
+    private generateConfigLua;
+    private generateBuildSettings;
+    private generateMainLua;
+    private generateUtilityModules;
+    private exportScene;
+    private createEntityLua;
+    private hexToRGB;
+    private exportPrefab;
+    private componentToLua;
+    private generateReadme;
+}
+export declare function createSolar2DExporter(): Solar2DExporter;

package/dist/types/export/Tic80Exporter.d.ts

@@ -0,0 +1,42 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface Tic80ExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Programming language */
+        language?: 'lua' | 'javascript' | 'moonscript' | 'wren';
+        /** Include bank switching code */
+        bankSwitching?: boolean;
+        /** Generate sfx placeholders */
+        sfxPlaceholders?: boolean;
+        /** Generate music patterns */
+        musicPatterns?: boolean;
+        /** Include debug tools */
+        includeDebug?: boolean;
+    };
+}
+export declare class Tic80Exporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    protected doExport(project: NiceProject, options: Tic80ExportOptions): Promise<void>;
+    private generateTicFile;
+    private generateLuaCode;
+    private generateLuaCoreFunctions;
+    private generateLuaEntitySystem;
+    private generateLuaEntityDefinitions;
+    private entityTypeToLuaDef;
+    private getEntitySpriteIndex;
+    private getComponentProperty;
+    private generateLuaSceneManagement;
+    private generateLuaUtilities;
+    private generateJavaScriptCode;
+    private generateMoonscriptCode;
+    private generateWrenCode;
+    private generateSpritesSection;
+    private generateMapSection;
+    private generateWavesSection;
+    private generateSfxSection;
+    private generateMusicSection;
+    private generatePaletteSection;
+    private getClosestTic80Color;
+    private generateReadme;
+}
+export declare function createTic80Exporter(): Tic80Exporter;

package/dist/types/export/UnrealExporter.d.ts

@@ -0,0 +1,46 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface UnrealExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Unreal Engine version (e.g., '5.3', '5.4') */
+        engineVersion?: string;
+        /** Module name for generated C++ classes */
+        moduleName?: string;
+        /** Generate Blueprint-compatible nodes */
+        generateBlueprints?: boolean;
+        /** Generate pure C++ without BP macros */
+        pureCpp?: boolean;
+        /** Use Niagara instead of Cascade for particles */
+        useNiagara?: boolean;
+        /** Default skeletal mesh system */
+        skeletalSystem?: 'control-rig' | 'animation-bp';
+        /** Use Enhanced Input system */
+        useEnhancedInput?: boolean;
+        /** Generate Gameplay Ability System components */
+        useGAS?: boolean;
+        /** Project category */
+        projectCategory?: 'game' | 'plugin' | 'engine';
+    };
+}
+export declare class UnrealExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private moduleName;
+    private engineVersion;
+    private usedHeaders;
+    protected doExport(project: NiceProject, options: UnrealExportOptions): Promise<void>;
+    private generateProjectFiles;
+    private generateBuildFiles;
+    private generateSourceFiles;
+    private generateGameMode;
+    private generateActorClass;
+    private convertPropertyValue;
+    private generateConfigFiles;
+    private exportScene;
+    private generateLevelBlueprint;
+    private generateEntitySpawnCode;
+    private generateSpawnData;
+    private exportAsset;
+    private generateDataAsset;
+    private generateBlueprintLibrary;
+}
+export declare function createUnrealExporter(): UnrealExporter;

package/dist/types/export/index.d.ts

@@ -1,8 +1,22 @@
 export { PlatformExporter, type PlatformId, type PlatformInfo, type PlatformFeature, type AssetType, type NiceProject, type ProjectSettings, type NiceScene, type NiceEntity, type NiceComponent, type NiceAsset, type NicePrefab, type NiceTilemap, type TilemapLayer, type ExportOptions, type ExportResult, type ExportedFile, type ExportError, type ExportWarning, type ExportStats, type DetectionResult, detectBestPlatform, registerPlatform, getPlatformInfo, getAllPlatforms, } from './PlatformExporter';
 export { UnityExporter, type UnityExportOptions } from './UnityExporter';
 export { GodotExporter, type GodotExportOptions } from './GodotExporter';
+export { UnrealExporter, type UnrealExportOptions, createUnrealExporter } from './UnrealExporter';
+export { CocosExporter, type CocosExportOptions, createCocosExporter } from './CocosExporter';
+export { GameMakerExporter, type GameMakerExportOptions, createGameMakerExporter, } from './GameMakerExporter';
+export { RobloxExporter, type RobloxExportOptions, createRobloxExporter } from './RobloxExporter';
+export { MinecraftBedrockExporter, type MinecraftBedrockExportOptions, createMinecraftBedrockExporter, } from './MinecraftBedrockExporter';
+export { RPGMakerExporter, type RPGMakerExportOptions, createRPGMakerExporter, } from './RPGMakerExporter';
+export { Construct3Exporter, type Construct3ExportOptions, createConstruct3Exporter, } from './Construct3Exporter';
+export { GDevelopExporter, type GDevelopExportOptions, createGDevelopExporter, } from './GDevelopExporter';
+export { DefoldExporter, type DefoldExportOptions, createDefoldExporter } from './DefoldExporter';
+export { Solar2DExporter, type Solar2DExportOptions, createSolar2DExporter, } from './Solar2DExporter';
+export { Pico8Exporter, type Pico8ExportOptions, createPico8Exporter } from './Pico8Exporter';
+export { Tic80Exporter, type Tic80ExportOptions, createTic80Exporter } from './Tic80Exporter';
+export { ThreeJSExporter } from './ThreeJSExporter';
+export { BevyExporter, type BevyExportConfig, DEFAULT_BEVY_CONFIG } from './BevyExporter';
+export { MonoGameExporter, type MonoGameExportConfig, DEFAULT_MONOGAME_CONFIG, } from './MonoGameExporter';
 export { PixiJSExporter, PhaserExporter, type WebExportOptions } from './WebExporter';
-export { ThreeJSExporter, type ThreeJSExportOptions } from './ThreeJSExporter';
 import type { PlatformId } from './PlatformExporter';
 import { PlatformExporter } from './PlatformExporter';
 /**