@nice2dev/game-engine 1.0.2 → 1.0.4

package/dist/types/import/OgmoImporter.d.ts

@@ -0,0 +1,237 @@
+/**
+ * @file OgmoImporter.ts
+ * @description OGMO Editor Level Importer
+ * PRO-1.3: Scene Format Interoperability
+ *
+ * OGMO Editor is a free, open-source 2D level editor.
+ * Supports OGMO 3 format (JSON-based).
+ *
+ * File Types:
+ * - .ogmo - Project file
+ * - .json - Level file (usually named *.ogmo.json or just *.json)
+ */
+import { SceneImporter, ImportOptions, ImportResult, ParsedScene, ImportError } from './SceneImporter';
+/** OGMO 3 Project File */
+export interface OgmoProject {
+    name: string;
+    ogmoVersion: string;
+    levelPaths?: string[];
+    backgroundColor: string;
+    gridColor: string;
+    anglesRadians: boolean;
+    directoryDepth: number;
+    layerGridDefaultSize: {
+        x: number;
+        y: number;
+    };
+    levelDefaultSize: {
+        x: number;
+        y: number;
+    };
+    levelMinSize: {
+        x: number;
+        y: number;
+    };
+    levelMaxSize: {
+        x: number;
+        y: number;
+    };
+    levelNamePattern?: string;
+    levelValues?: OgmoValueDef[];
+    defaultExportMode: string;
+    compactExport: boolean;
+    externalScript?: string;
+    playCommand?: string;
+    entityTags?: string[];
+    layers: OgmoLayerDef[];
+    entities: OgmoEntityDef[];
+    tilesets: OgmoTilesetDef[];
+}
+/** OGMO Layer Definition */
+export interface OgmoLayerDef {
+    name: string;
+    gridSize: {
+        x: number;
+        y: number;
+    };
+    exportID: string;
+    definition: 'tile' | 'entity' | 'decal';
+    /** For tile layers */
+    tileset?: string;
+    /** For entity layers */
+    requiredTags?: string[];
+    excludedTags?: string[];
+    /** For decal layers */
+    folder?: string;
+    scaleable?: boolean;
+    rotatable?: boolean;
+    tintable?: boolean;
+}
+/** OGMO Entity Definition */
+export interface OgmoEntityDef {
+    name: string;
+    exportID: string;
+    limit: number;
+    size: {
+        x: number;
+        y: number;
+    };
+    origin: {
+        x: number;
+        y: number;
+    };
+    originAnchored: boolean;
+    shape: OgmoEntityShape;
+    color: string;
+    tileX: boolean;
+    tileY: boolean;
+    tileSize: {
+        x: number;
+        y: number;
+    };
+    resizeableX: boolean;
+    resizeableY: boolean;
+    rotatable: boolean;
+    rotationDegrees: number;
+    canFlipX: boolean;
+    canFlipY: boolean;
+    canSetColor: boolean;
+    hasNodes: boolean;
+    nodeLimit: number;
+    nodeDisplay: 'path' | 'circuit' | 'fan' | 'none';
+    nodeGhost: boolean;
+    tags: string[];
+    values: OgmoValueDef[];
+    texture?: string;
+    textureX?: number;
+    textureY?: number;
+}
+export type OgmoEntityShape = {
+    label: 'Rectangle' | 'Ellipse' | 'Cross' | 'Diamond' | 'Octagon' | 'Point';
+} | {
+    label: 'Ellipse';
+} | {
+    label: 'Cross';
+} | {
+    label: 'Diamond';
+} | {
+    label: 'Octagon';
+} | {
+    label: 'Point';
+};
+/** OGMO Tileset Definition */
+export interface OgmoTilesetDef {
+    name: string;
+    path: string;
+    image: string;
+    tileWidth: number;
+    tileHeight: number;
+    tileSeparationX: number;
+    tileSeparationY: number;
+}
+/** OGMO Value Definition (custom properties) */
+export interface OgmoValueDef {
+    name: string;
+    definition: 'Bool' | 'Int' | 'Float' | 'String' | 'Text' | 'Enum' | 'Color' | 'FilePath';
+    defaults: unknown;
+    bounded?: boolean;
+    min?: number;
+    max?: number;
+    choices?: string[];
+}
+/** OGMO 3 Level File */
+export interface OgmoLevel {
+    ogmoVersion: string;
+    width: number;
+    height: number;
+    offsetX: number;
+    offsetY: number;
+    values?: Record<string, unknown>;
+    layers: OgmoLayerInstance[];
+}
+/** OGMO Layer Instance */
+export interface OgmoLayerInstance {
+    name: string;
+    _eid: string;
+    offsetX: number;
+    offsetY: number;
+    gridCellWidth: number;
+    gridCellHeight: number;
+    gridCellsX: number;
+    gridCellsY: number;
+    /** Tile layers */
+    tileset?: string;
+    data?: number[];
+    data2D?: number[][];
+    dataCoords?: Array<[number, number]>;
+    dataCoords2D?: Array<Array<[number, number]>>;
+    exportMode?: '1D' | '2D' | 'CSV' | 'Coords (1D)' | 'Coords (2D)';
+    arrayMode?: '1D' | '2D';
+    /** Entity layers */
+    entities?: OgmoEntityInstance[];
+    /** Decal layers */
+    decals?: OgmoDecalInstance[];
+    /** Grid layer (for collision/pathfinding) */
+    grid?: string[];
+    grid2D?: string[][];
+}
+/** OGMO Entity Instance */
+export interface OgmoEntityInstance {
+    name: string;
+    id: number;
+    _eid: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    originX?: number;
+    originY?: number;
+    rotation?: number;
+    flippedX?: boolean;
+    flippedY?: boolean;
+    color?: string;
+    nodes?: Array<{
+        x: number;
+        y: number;
+    }>;
+    values?: Record<string, unknown>;
+}
+/** OGMO Decal Instance */
+export interface OgmoDecalInstance {
+    x: number;
+    y: number;
+    texture: string;
+    scaleX?: number;
+    scaleY?: number;
+    rotation?: number;
+    color?: string;
+    originX?: number;
+    originY?: number;
+}
+export declare class OgmoImporter extends SceneImporter {
+    private project;
+    private entityDefs;
+    private tilesetDefs;
+    private layerDefs;
+    constructor();
+    canHandle(filePath: string): boolean;
+    import(options: ImportOptions): Promise<ImportResult>;
+    parseFile(content: string | ArrayBuffer, filePath: string): Promise<ParsedScene | null>;
+    validate(sourcePath: string): Promise<ImportError[]>;
+    private isProjectFile;
+    private isLevelFile;
+    private indexDefinitions;
+    private convertLevelToScene;
+    private convertLevelToParsed;
+    private convertLayer;
+    private convertLayerToParsed;
+    private convertTileLayer;
+    private convertEntity;
+    private convertEntityToParsed;
+    private convertDecal;
+    private convertGridLayer;
+    private readFile;
+    private resolvePath;
+    private extractFileName;
+}
+export declare function createOgmoImporter(): OgmoImporter;

package/dist/types/import/RPGMakerImporter.d.ts

@@ -0,0 +1,186 @@
+/**
+ * @file RPGMakerImporter.ts
+ * @description RPG Maker Map Importer
+ * PRO-1.3: Scene Format Interoperability
+ *
+ * Supports RPG Maker MV/MZ JSON map format.
+ *
+ * File Types:
+ * - Map*.json - Map files
+ * - Tilesets.json - Tileset definitions
+ * - Actors.json, Enemies.json, etc. - Database files
+ */
+import { SceneImporter, ImportOptions, ImportResult, ParsedScene, ImportError } from './SceneImporter';
+/** RPG Maker MV/MZ Map */
+export interface RPGMakerMap {
+    autoplayBgm: boolean;
+    autoplayBgs: boolean;
+    battleback1Name: string;
+    battleback2Name: string;
+    bgm: RPGMakerAudio;
+    bgs: RPGMakerAudio;
+    disableDashing: boolean;
+    displayName: string;
+    encounterList: RPGMakerEncounter[];
+    encounterStep: number;
+    height: number;
+    width: number;
+    note: string;
+    parallaxLoopX: boolean;
+    parallaxLoopY: boolean;
+    parallaxName: string;
+    parallaxShow: boolean;
+    parallaxSx: number;
+    parallaxSy: number;
+    scrollType: number;
+    specifyBattleback: boolean;
+    tilesetId: number;
+    data: number[];
+    events: (RPGMakerEvent | null)[];
+}
+/** RPG Maker Event */
+export interface RPGMakerEvent {
+    id: number;
+    name: string;
+    note: string;
+    x: number;
+    y: number;
+    pages: RPGMakerEventPage[];
+}
+/** RPG Maker Event Page */
+export interface RPGMakerEventPage {
+    conditions: RPGMakerConditions;
+    directionFix: boolean;
+    image: RPGMakerEventImage;
+    list: RPGMakerCommand[];
+    moveFrequency: number;
+    moveRoute: RPGMakerMoveRoute;
+    moveSpeed: number;
+    moveType: number;
+    priorityType: number;
+    stepAnime: boolean;
+    through: boolean;
+    trigger: number;
+    walkAnime: boolean;
+}
+/** RPG Maker Event Image */
+export interface RPGMakerEventImage {
+    characterIndex: number;
+    characterName: string;
+    direction: number;
+    pattern: number;
+    tileId: number;
+}
+/** RPG Maker Event Conditions */
+export interface RPGMakerConditions {
+    actorId: number;
+    actorValid: boolean;
+    itemId: number;
+    itemValid: boolean;
+    selfSwitchCh: string;
+    selfSwitchValid: boolean;
+    switch1Id: number;
+    switch1Valid: boolean;
+    switch2Id: number;
+    switch2Valid: boolean;
+    variableId: number;
+    variableValid: boolean;
+    variableValue: number;
+}
+/** RPG Maker Event Command */
+export interface RPGMakerCommand {
+    code: number;
+    indent: number;
+    parameters: unknown[];
+}
+/** RPG Maker Move Route */
+export interface RPGMakerMoveRoute {
+    list: RPGMakerMoveCommand[];
+    repeat: boolean;
+    skippable: boolean;
+    wait: boolean;
+}
+/** RPG Maker Move Command */
+export interface RPGMakerMoveCommand {
+    code: number;
+    parameters?: unknown[];
+}
+/** RPG Maker Audio */
+export interface RPGMakerAudio {
+    name: string;
+    pan: number;
+    pitch: number;
+    volume: number;
+}
+/** RPG Maker Encounter */
+export interface RPGMakerEncounter {
+    regionSet: number[];
+    troopId: number;
+    weight: number;
+}
+/** RPG Maker Tileset Definition */
+export interface RPGMakerTileset {
+    id: number;
+    flags: number[];
+    mode: number;
+    name: string;
+    note: string;
+    tilesetNames: string[];
+}
+/** RPG Maker Actor */
+export interface RPGMakerActor {
+    id: number;
+    battlerName: string;
+    characterIndex: number;
+    characterName: string;
+    classId: number;
+    equips: number[];
+    faceIndex: number;
+    faceName: string;
+    traits: RPGMakerTrait[];
+    initialLevel: number;
+    maxLevel: number;
+    name: string;
+    nickname: string;
+    note: string;
+    profile: string;
+}
+/** RPG Maker Trait */
+export interface RPGMakerTrait {
+    code: number;
+    dataId: number;
+    value: number;
+}
+/** RPG Maker Common Event */
+export interface RPGMakerCommonEvent {
+    id: number;
+    list: RPGMakerCommand[];
+    name: string;
+    switchId: number;
+    trigger: number;
+}
+export declare class RPGMakerImporter extends SceneImporter {
+    private tilesets;
+    private commonEvents;
+    constructor();
+    canHandle(filePath: string): boolean;
+    import(options: ImportOptions): Promise<ImportResult>;
+    parseFile(content: string | ArrayBuffer, filePath: string): Promise<ParsedScene | null>;
+    validate(sourcePath: string): Promise<ImportError[]>;
+    private isMapFile;
+    private convertMapToScene;
+    private convertMapToParsed;
+    private createTilemapLayers;
+    private extractLayerData;
+    private convertEvent;
+    private convertEventToParsed;
+    private getActivePage;
+    private getTriggerName;
+    private getPriorityName;
+    private simplifyCommands;
+    private createParallaxEntity;
+    private readFile;
+    private getDataPath;
+    private extractFileName;
+}
+export declare function createRPGMakerImporter(): RPGMakerImporter;

package/dist/types/import/SceneImporter.d.ts

@@ -0,0 +1,276 @@
+/**
+ * @file SceneImporter.ts
+ * @description Base infrastructure for importing scenes from external game engine formats
+ * PRO-1.3: Scene Format Interoperability
+ *
+ * Supports importing from:
+ * - Unity (.unity, .prefab)
+ * - Godot (.tscn, .tres)
+ * - Tiled (.tmx, .tsx)
+ * - LDtk (.ldtk, .ldtkl)
+ * - Aseprite (.aseprite, .ase)
+ * - OGMO (.ogmo, .json)
+ * - GameMaker (.yy)
+ * - Spine (.json, .atlas)
+ * - DragonBones (.json)
+ */
+import type { NiceScene, NiceEntity, NiceAsset, NiceProject } from '../export/PlatformExporter';
+export type ImportSourceType = 'unity' | 'godot' | 'tiled' | 'ldtk' | 'aseprite' | 'ogmo' | 'gamemaker' | 'rpgmaker' | 'spine' | 'dragonbones' | 'live2d' | 'spriter';
+export interface ImportSourceInfo {
+    type: ImportSourceType;
+    name: string;
+    description: string;
+    extensions: string[];
+    supportsAnimation: boolean;
+    supportsLayers: boolean;
+    supportsTilemap: boolean;
+}
+export declare const IMPORT_SOURCES: Record<ImportSourceType, ImportSourceInfo>;
+export interface ImportOptions {
+    /** Source directory/file path */
+    sourcePath: string;
+    /** Target project to import into (optional, creates new if not provided) */
+    targetProject?: NiceProject;
+    /** Import assets (textures, audio, etc.) */
+    importAssets?: boolean;
+    /** Import scripts (convert to Nice2Dev format) */
+    importScripts?: boolean;
+    /** Preserve original structure */
+    preserveStructure?: boolean;
+    /** Convert coordinates (some engines use different origins) */
+    convertCoordinates?: boolean;
+    /** Scale factor for coordiantes */
+    scaleFactor?: number;
+    /** Import animations */
+    importAnimations?: boolean;
+    /** Import tilemap data */
+    importTilemaps?: boolean;
+    /** Import physics data */
+    importPhysics?: boolean;
+    /** Resolve asset dependencies */
+    resolveDependencies?: boolean;
+    /** Custom options specific to source format */
+    customOptions?: Record<string, unknown>;
+}
+export interface ImportResult {
+    success: boolean;
+    project?: NiceProject;
+    scenes: NiceScene[];
+    entities: NiceEntity[];
+    assets: NiceAsset[];
+    errors: ImportError[];
+    warnings: ImportWarning[];
+    statistics: ImportStatistics;
+}
+export interface ImportError {
+    code: string;
+    message: string;
+    file?: string;
+    line?: number;
+    fatal: boolean;
+}
+export interface ImportWarning {
+    code: string;
+    message: string;
+    file?: string;
+    suggestion?: string;
+}
+export interface ImportStatistics {
+    scenesImported: number;
+    entitiesImported: number;
+    assetsImported: number;
+    animationsImported: number;
+    tilemapsImported: number;
+    scriptsConverted: number;
+    importDurationMs: number;
+}
+/** Generic parsed scene structure */
+export interface ParsedScene {
+    name: string;
+    width?: number;
+    height?: number;
+    backgroundColor?: string;
+    layers: ParsedLayer[];
+    entities: ParsedEntity[];
+    properties: Record<string, unknown>;
+}
+export interface ParsedLayer {
+    name: string;
+    type: 'tile' | 'object' | 'image' | 'group';
+    visible: boolean;
+    opacity: number;
+    offsetX: number;
+    offsetY: number;
+    parallaxX?: number;
+    parallaxY?: number;
+    zIndex: number;
+    data?: ParsedTileData;
+    tileData?: ParsedTileData;
+    objects?: ParsedEntity[];
+    properties: Record<string, unknown>;
+}
+export interface ParsedTileData {
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    tiles: number[];
+    tilesetRef?: string;
+}
+export interface ParsedEntity {
+    id: string;
+    name: string;
+    type: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    visible: boolean;
+    components: ParsedComponent[];
+    children: ParsedEntity[];
+    properties: Record<string, unknown>;
+}
+export interface ParsedComponent {
+    type: string;
+    data: Record<string, unknown>;
+}
+export interface ParsedTileset {
+    name: string;
+    imagePath: string;
+    tileWidth: number;
+    tileHeight: number;
+    tileCount: number;
+    columns: number;
+    margin: number;
+    spacing: number;
+    tiles?: ParsedTileInfo[];
+    properties: Record<string, unknown>;
+}
+export interface ParsedTileInfo {
+    id: number;
+    type?: string;
+    properties?: Record<string, unknown>;
+    animation?: ParsedTileAnimation[];
+    collision?: ParsedCollisionShape[];
+}
+export interface ParsedTileAnimation {
+    tileId: number;
+    duration: number;
+}
+export interface ParsedCollisionShape {
+    type: 'rectangle' | 'ellipse' | 'polygon' | 'polyline';
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    points?: {
+        x: number;
+        y: number;
+    }[];
+}
+export interface ParsedAnimation {
+    name: string;
+    frames: ParsedAnimationFrame[];
+    loop: boolean;
+    events?: ParsedAnimationEvent[];
+}
+export interface ParsedAnimationFrame {
+    index: number;
+    duration: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    offsetX?: number;
+    offsetY?: number;
+}
+export interface ParsedAnimationEvent {
+    frame: number;
+    name: string;
+    data?: Record<string, unknown>;
+}
+export interface ParsedAsset {
+    id: string;
+    name: string;
+    type: 'texture' | 'audio' | 'font' | 'shader' | 'script' | 'data' | 'animation' | 'tileset';
+    path: string;
+    data?: ArrayBuffer | string;
+    metadata: Record<string, unknown>;
+}
+export interface ParsedSpriteSheet {
+    name: string;
+    imagePath: string;
+    frames: ParsedSpriteFrame[];
+    animations?: Record<string, ParsedAnimation>;
+}
+export interface ParsedSpriteFrame {
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pivotX?: number;
+    pivotY?: number;
+    trimmed?: boolean;
+    sourceWidth?: number;
+    sourceHeight?: number;
+    offsetX?: number;
+    offsetY?: number;
+}
+export declare abstract class SceneImporter {
+    protected sourceType: ImportSourceType;
+    protected options: ImportOptions;
+    protected errors: ImportError[];
+    protected warnings: ImportWarning[];
+    constructor(sourceType: ImportSourceType);
+    /** Get importer source info */
+    getSourceInfo(): ImportSourceInfo;
+    /** Check if this importer can handle the given file */
+    canHandle(filePath: string): boolean;
+    /** Import scenes/data from source */
+    abstract import(options: ImportOptions): Promise<ImportResult>;
+    /** Parse a single file (for preview or partial import) */
+    abstract parseFile(content: string | ArrayBuffer, filePath: string): Promise<ParsedScene | ParsedAsset | null>;
+    /** Validate source before import */
+    abstract validate(sourcePath: string): Promise<ImportError[]>;
+    protected addError(code: string, message: string, file?: string, line?: number, fatal?: boolean): void;
+    protected addWarning(code: string, message: string, file?: string, suggestion?: string): void;
+    protected clearMessages(): void;
+    /** Convert parsed scene to Nice2Dev scene */
+    protected convertToNiceScene(parsed: ParsedScene): NiceScene;
+    /** Alias for convertToNiceScene (used by subclass importers) */
+    protected convertParsedToNiceScene(parsed: ParsedScene): NiceScene;
+    /** Flatten layer-based entities into single list */
+    protected flattenEntities(entities: ParsedEntity[], layers: ParsedLayer[]): ParsedEntity[];
+    /** Convert parsed entity to Nice2Dev entity */
+    protected convertToNiceEntity(parsed: ParsedEntity): NiceEntity;
+    /** Convert a component from source format to Nice2Dev format */
+    protected convertComponent(parsed: ParsedComponent): NiceEntity['components'][0];
+    /** Convert parsed asset to Nice2Dev asset */
+    protected convertToNiceAsset(parsed: ParsedAsset): NiceAsset;
+    /** Generate unique ID */
+    protected generateId(): string;
+    /** Create empty import result */
+    protected createEmptyResult(): ImportResult;
+    /** Create successful result */
+    protected createResult(scenes: NiceScene[], assets: NiceAsset[], startTime: number, project?: NiceProject): ImportResult;
+}
+/** Parse YAML content (basic implementation) */
+export declare function parseYAML(content: string): unknown;
+/** Parse XML content to object */
+export declare function parseXML(content: string): XMLNode;
+export interface XMLNode {
+    name: string;
+    attributes: Record<string, string>;
+    children: XMLNode[];
+    text: string;
+}
+/** Detect import source type from file */
+export declare function detectSourceType(filePath: string, content?: string): ImportSourceType | null;
+/** Get all available importers */
+export declare function getAvailableImporters(): ImportSourceInfo[];
+/** Check if an importer exists for the given source type */
+export declare function hasImporter(sourceType: ImportSourceType): boolean;