@nice2dev/game-engine 0.1.0 → 1.0.3

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

@@ -0,0 +1,331 @@
+/**
+ * @file DragonBonesImporter.ts
+ * @description DragonBones Skeletal Animation Importer
+ * PRO-1.3: Scene Format Interoperability
+ *
+ * DragonBones is a free, open-source 2D skeletal animation tool.
+ *
+ * File Types:
+ * - *_ske.json - Skeleton data
+ * - *_tex.json - Texture atlas data
+ * - *_tex.png - Texture image
+ */
+import { SceneImporter, ImportOptions, ImportResult, ParsedScene, ImportError } from './SceneImporter';
+/** DragonBones Skeleton Data */
+export interface DBSkeletonData {
+    frameRate: number;
+    name: string;
+    version: string;
+    compatibleVersion?: string;
+    armature: DBArmature[];
+}
+/** DragonBones Armature */
+export interface DBArmature {
+    name: string;
+    type?: 'Armature' | 'Stage' | 'MovieClip';
+    frameRate?: number;
+    aabb: DBAABB;
+    bone: DBBone[];
+    slot: DBSlot[];
+    skin: DBSkin[];
+    ik?: DBIKConstraint[];
+    path?: DBPathConstraint[];
+    animation: DBAnimation[];
+    defaultActions?: DBAction[];
+    canvas?: DBCanvas;
+}
+/** DragonBones AABB */
+export interface DBAABB {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** DragonBones Bone */
+export interface DBBone {
+    name: string;
+    parent?: string;
+    length?: number;
+    transform?: DBTransform;
+    inheritTranslation?: boolean;
+    inheritRotation?: boolean;
+    inheritScale?: boolean;
+    inheritReflection?: boolean;
+}
+/** DragonBones Transform */
+export interface DBTransform {
+    x?: number;
+    y?: number;
+    skX?: number;
+    skY?: number;
+    scX?: number;
+    scY?: number;
+}
+/** DragonBones Slot */
+export interface DBSlot {
+    name: string;
+    parent: string;
+    displayIndex?: number;
+    color?: DBColor;
+    blendMode?: 'normal' | 'add' | 'alpha' | 'darken' | 'difference' | 'erase' | 'hardlight' | 'invert' | 'layer' | 'lighten' | 'multiply' | 'overlay' | 'screen' | 'subtract';
+}
+/** DragonBones Color */
+export interface DBColor {
+    aM?: number;
+    rM?: number;
+    gM?: number;
+    bM?: number;
+    aO?: number;
+    rO?: number;
+    gO?: number;
+    bO?: number;
+}
+/** DragonBones Skin */
+export interface DBSkin {
+    name: string;
+    slot: DBSkinSlot[];
+}
+/** DragonBones Skin Slot */
+export interface DBSkinSlot {
+    name: string;
+    display: DBDisplay[];
+}
+/** DragonBones Display */
+export type DBDisplay = DBImageDisplay | DBMeshDisplay | DBArmatureDisplay | DBBoundingBoxDisplay | DBPathDisplay;
+export interface DBDisplayBase {
+    name: string;
+    type?: 'image' | 'mesh' | 'armature' | 'boundingBox' | 'path';
+    transform?: DBTransform;
+}
+export interface DBImageDisplay extends DBDisplayBase {
+    type?: 'image';
+    path?: string;
+    pivot?: {
+        x: number;
+        y: number;
+    };
+}
+export interface DBMeshDisplay extends DBDisplayBase {
+    type: 'mesh';
+    path?: string;
+    width: number;
+    height: number;
+    vertices: number[];
+    uvs: number[];
+    triangles: number[];
+    weights?: number[];
+    slotPose?: number[];
+    bonePose?: number[];
+    edges?: number[];
+    userEdges?: number[];
+}
+export interface DBArmatureDisplay extends DBDisplayBase {
+    type: 'armature';
+    path?: string;
+    inheritAnimation?: boolean;
+    actions?: DBAction[];
+}
+export interface DBBoundingBoxDisplay extends DBDisplayBase {
+    type: 'boundingBox';
+    subType?: 'rectangle' | 'ellipse' | 'polygon';
+    width?: number;
+    height?: number;
+    vertices?: number[];
+    color?: number;
+}
+export interface DBPathDisplay extends DBDisplayBase {
+    type: 'path';
+    closed?: boolean;
+    constantSpeed?: boolean;
+    vertices: number[];
+    lengths?: number[];
+}
+/** DragonBones IK Constraint */
+export interface DBIKConstraint {
+    name: string;
+    bone: string;
+    target: string;
+    chain?: number;
+    bendPositive?: boolean;
+    weight?: number;
+}
+/** DragonBones Path Constraint */
+export interface DBPathConstraint {
+    name: string;
+    bones: string[];
+    target: string;
+    positionMode?: 'fixed' | 'percent';
+    spacingMode?: 'fixed' | 'percent' | 'length';
+    rotateMode?: 'tangent' | 'chain' | 'chainScale';
+    position?: number;
+    spacing?: number;
+    rotateMix?: number;
+    translateMix?: number;
+}
+/** DragonBones Animation */
+export interface DBAnimation {
+    name: string;
+    duration: number;
+    playTimes?: number;
+    fadeInTime?: number;
+    frame?: DBMainFrame[];
+    bone?: DBBoneTimeline[];
+    slot?: DBSlotTimeline[];
+    ffd?: DBFFDTimeline[];
+    ik?: DBIKTimeline[];
+    zOrder?: DBZOrderFrame[];
+}
+/** DragonBones Main Frame (events) */
+export interface DBMainFrame {
+    duration: number;
+    event?: string;
+    events?: DBEvent[];
+    actions?: DBAction[];
+    sound?: string;
+}
+export interface DBEvent {
+    name: string;
+    bone?: string;
+    ints?: number[];
+    floats?: number[];
+    strings?: string[];
+}
+export interface DBAction {
+    type: 'play' | 'frame' | 'sound';
+    name?: string;
+}
+/** DragonBones Bone Timeline */
+export interface DBBoneTimeline {
+    name: string;
+    translateFrame?: DBTranslateFrame[];
+    rotateFrame?: DBRotateFrame[];
+    scaleFrame?: DBScaleFrame[];
+    frame?: DBBoneFrame[];
+}
+export interface DBTranslateFrame {
+    duration?: number;
+    tweenEasing?: number | null;
+    curve?: number[];
+    x?: number;
+    y?: number;
+}
+export interface DBRotateFrame {
+    duration?: number;
+    tweenEasing?: number | null;
+    curve?: number[];
+    rotate?: number;
+    skew?: number;
+}
+export interface DBScaleFrame {
+    duration?: number;
+    tweenEasing?: number | null;
+    curve?: number[];
+    x?: number;
+    y?: number;
+}
+export interface DBBoneFrame {
+    duration?: number;
+    tweenEasing?: number | null;
+    curve?: number[];
+    transform?: DBTransform;
+}
+/** DragonBones Slot Timeline */
+export interface DBSlotTimeline {
+    name: string;
+    displayFrame?: DBDisplayFrame[];
+    colorFrame?: DBColorFrame[];
+    frame?: DBSlotFrame[];
+}
+export interface DBDisplayFrame {
+    duration?: number;
+    value?: number;
+    actions?: DBAction[];
+}
+export interface DBColorFrame {
+    duration?: number;
+    tweenEasing?: number | null;
+    curve?: number[];
+    value?: DBColor;
+}
+export interface DBSlotFrame {
+    duration?: number;
+    tweenEasing?: number | null;
+    displayIndex?: number;
+    color?: DBColor;
+    actions?: DBAction[];
+}
+/** DragonBones FFD Timeline (mesh deformation) */
+export interface DBFFDTimeline {
+    name: string;
+    skin: string;
+    slot: string;
+    frame: DBFFDFrame[];
+}
+export interface DBFFDFrame {
+    duration?: number;
+    tweenEasing?: number | null;
+    curve?: number[];
+    offset?: number;
+    vertices?: number[];
+}
+/** DragonBones IK Timeline */
+export interface DBIKTimeline {
+    name: string;
+    frame: DBIKFrame[];
+}
+export interface DBIKFrame {
+    duration?: number;
+    tweenEasing?: number | null;
+    curve?: number[];
+    bendPositive?: boolean;
+    weight?: number;
+}
+/** DragonBones Z-Order Frame */
+export interface DBZOrderFrame {
+    duration?: number;
+    zOrder?: number[];
+}
+/** DragonBones Canvas */
+export interface DBCanvas {
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+    color?: number;
+}
+/** DragonBones Texture Atlas Data */
+export interface DBTextureAtlas {
+    name: string;
+    imagePath: string;
+    width: number;
+    height: number;
+    SubTexture: DBSubTexture[];
+}
+export interface DBSubTexture {
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    frameX?: number;
+    frameY?: number;
+    frameWidth?: number;
+    frameHeight?: number;
+}
+export declare class DragonBonesImporter extends SceneImporter {
+    private textureAtlas;
+    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 convertArmatureToScene;
+    private convertArmatureToParsed;
+    private createBoneHierarchy;
+    private addSlotToEntity;
+    private findBoneEntity;
+    private convertAnimation;
+    private convertColor;
+    private readFile;
+}
+export declare function createDragonBonesImporter(): DragonBonesImporter;

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

@@ -0,0 +1,375 @@
+/**
+ * @file GameMakerImporter.ts
+ * @description GameMaker Studio 2 Room Importer
+ * PRO-1.3: Scene Format Interoperability
+ *
+ * Supports GameMaker Studio 2 .yy format (JSON-based).
+ *
+ * File Types:
+ * - *.yy - Room, object, sprite, script files
+ * - *.yyp - Project file
+ */
+import { SceneImporter, ImportOptions, ImportResult, ParsedScene, ImportError } from './SceneImporter';
+/** GameMaker Resource Reference */
+export interface GMResourceRef {
+    name: string;
+    path: string;
+}
+/** GameMaker Resource ID */
+export interface GMId {
+    name: string;
+    path: string;
+}
+/** GameMaker Color Format */
+export type GMColor = number;
+/** GameMaker Room */
+export interface GMRoom {
+    resourceType: 'GMRoom';
+    resourceVersion: string;
+    name: string;
+    roomSettings: GMRoomSettings;
+    viewSettings: GMViewSettings;
+    physicsSettings: GMPhysicsSettings;
+    parent: GMResourceRef;
+    layers: GMLayerInstance[];
+    instanceCreationOrder: GMResourceRef[];
+    creationCodeFile: string;
+    inheritCode: boolean;
+    inheritCreationOrder: boolean;
+    inheritLayers: boolean;
+    isDnd: boolean;
+    volume: number;
+    inheritRoomSettings?: boolean;
+    inheritViewSettings?: boolean;
+    inheritPhysicsSettings?: boolean;
+    tags?: string[];
+}
+/** GameMaker Room Settings */
+export interface GMRoomSettings {
+    Width: number;
+    Height: number;
+    inheritRoomSettings: boolean;
+    persistent: boolean;
+}
+/** GameMaker View Settings */
+export interface GMViewSettings {
+    inheritViewSettings: boolean;
+    enableViews: boolean;
+    clearViewBackground: boolean;
+    clearDisplayBuffer: boolean;
+}
+/** GameMaker Physics Settings */
+export interface GMPhysicsSettings {
+    inheritPhysicsSettings: boolean;
+    PhysicsWorld: boolean;
+    PhysicsWorldGravityX: number;
+    PhysicsWorldGravityY: number;
+    PhysicsWorldPixToMetres: number;
+}
+/** Base GameMaker Layer */
+export interface GMLayerBase {
+    resourceType: string;
+    resourceVersion: string;
+    name: string;
+    depth: number;
+    visible: boolean;
+    hspeed: number;
+    vspeed: number;
+    x: number;
+    y: number;
+    effectEnabled: boolean;
+    effectType: string | null;
+    gridX: number;
+    gridY: number;
+    layers: GMLayerInstance[];
+    hierarchyFrozen: boolean;
+    inheritLayerDepth: boolean;
+    inheritLayerSettings: boolean;
+    inheritSubLayers: boolean;
+    inheritVisibility: boolean;
+    userdefinedDepth: boolean;
+    properties?: GMLayerProperty[];
+}
+export type GMLayerInstance = GMInstanceLayer | GMTileLayer | GMBackgroundLayer | GMAssetLayer | GMPathLayer | GMEffectLayer | GMFolderLayer;
+/** GameMaker Instance Layer */
+export interface GMInstanceLayer extends GMLayerBase {
+    resourceType: 'GMRLayer';
+    instances: GMRoomInstance[];
+}
+/** GameMaker Tile Layer */
+export interface GMTileLayer extends GMLayerBase {
+    resourceType: 'GMRTileLayer';
+    tilesetId: GMResourceRef | null;
+    tiles: GMTileData;
+    x: number;
+    y: number;
+}
+/** GameMaker Tile Data */
+export interface GMTileData {
+    TileDataFormat: number;
+    SerialiseWidth: number;
+    SerialiseHeight: number;
+    TileCompressedData: number[];
+    TileSerialiseData: number[];
+}
+/** GameMaker Background Layer */
+export interface GMBackgroundLayer extends GMLayerBase {
+    resourceType: 'GMRBackgroundLayer';
+    spriteId: GMResourceRef | null;
+    colour: GMColor;
+    stretch: boolean;
+    htiled: boolean;
+    vtiled: boolean;
+    userdefinedAnimFPS: boolean;
+    animationFPS: number;
+    animationSpeedType: number;
+}
+/** GameMaker Asset Layer */
+export interface GMAssetLayer extends GMLayerBase {
+    resourceType: 'GMRAssetLayer';
+    assets: GMRoomAsset[];
+}
+/** GameMaker Path Layer */
+export interface GMPathLayer extends GMLayerBase {
+    resourceType: 'GMRPathLayer';
+    pathId: GMResourceRef | null;
+    colour: GMColor;
+}
+/** GameMaker Effect Layer */
+export interface GMEffectLayer extends GMLayerBase {
+    resourceType: 'GMREffectLayer';
+}
+/** GameMaker Folder Layer */
+export interface GMFolderLayer extends GMLayerBase {
+    resourceType: 'GMRLayer';
+    instances?: never;
+}
+/** GameMaker Room Instance */
+export interface GMRoomInstance {
+    resourceType: 'GMRInstance';
+    resourceVersion: string;
+    name: string;
+    objectId: GMResourceRef;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+    colour: GMColor;
+    imageIndex: number;
+    imageSpeed: number;
+    inheritCode: boolean;
+    inheritedItemId: GMResourceRef | null;
+    inheritItemSettings: boolean;
+    isDnd: boolean;
+    frozen: boolean;
+    ignore: boolean;
+    creationCode: string;
+    properties: GMInstanceProperty[];
+    tags?: string[];
+}
+/** GameMaker Room Asset */
+export interface GMRoomAsset {
+    resourceType: 'GMRSpriteGraphic' | 'GMRSequenceGraphic' | 'GMRParticleGraphic';
+    resourceVersion: string;
+    name: string;
+    spriteId?: GMResourceRef;
+    sequenceId?: GMResourceRef;
+    headPosition: number;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+    colour: GMColor;
+    animationSpeed: number;
+    animationSpeedType: number;
+    ignore: boolean;
+    frozen: boolean;
+    inheritedItemId: GMResourceRef | null;
+    inheritItemSettings: boolean;
+    tags?: string[];
+}
+/** GameMaker Instance Property */
+export interface GMInstanceProperty {
+    propertyId: GMResourceRef;
+    objectId: GMResourceRef;
+    value: string;
+}
+/** GameMaker Layer Property */
+export interface GMLayerProperty {
+    propertyId: GMResourceRef;
+    value: string;
+}
+/** GameMaker Object */
+export interface GMObject {
+    resourceType: 'GMObject';
+    resourceVersion: string;
+    name: string;
+    spriteId: GMResourceRef | null;
+    solid: boolean;
+    visible: boolean;
+    managed: boolean;
+    spriteMaskId: GMResourceRef | null;
+    persistent: boolean;
+    parentObjectId: GMResourceRef | null;
+    physicsObject: boolean;
+    physicsSensor: boolean;
+    physicsShape: number;
+    physicsGroup: number;
+    physicsDensity: number;
+    physicsRestitution: number;
+    physicsLinearDamping: number;
+    physicsAngularDamping: number;
+    physicsFriction: number;
+    physicsStartAwake: boolean;
+    physicsKinematic: boolean;
+    physicsShapePoints: GMPhysicsPoint[];
+    eventList: GMEvent[];
+    properties: GMObjectProperty[];
+    overriddenProperties: GMObjectProperty[];
+    parent: GMResourceRef;
+}
+/** GameMaker Physics Point */
+export interface GMPhysicsPoint {
+    x: number;
+    y: number;
+}
+/** GameMaker Event */
+export interface GMEvent {
+    resourceType: 'GMEvent';
+    resourceVersion: string;
+    isDnD: boolean;
+    eventNum: number;
+    eventType: number;
+    collisionObjectId?: GMResourceRef;
+    parent: GMResourceRef;
+}
+/** GameMaker Object Property */
+export interface GMObjectProperty {
+    resourceType: 'GMObjectProperty';
+    resourceVersion: string;
+    name: string;
+    varType: number;
+    value: string;
+    rangeEnabled: boolean;
+    rangeMin: number;
+    rangeMax: number;
+    listItems: string[];
+    multiselect: boolean;
+    filters: string[];
+}
+/** GameMaker Sprite */
+export interface GMSprite {
+    resourceType: 'GMSprite';
+    resourceVersion: string;
+    name: string;
+    width: number;
+    height: number;
+    bbox_left: number;
+    bbox_right: number;
+    bbox_top: number;
+    bbox_bottom: number;
+    origin: number;
+    xorigin: number;
+    yorigin: number;
+    frames: GMSpriteFrame[];
+    sequence: GMSpriteSequence;
+    layers: GMSpriteLayer[];
+    nineSlice: GMNineSlice | null;
+    parent: GMResourceRef;
+    bboxMode: number;
+    collisionKind: number;
+    collisionTolerance: number;
+    edgeFiltering: boolean;
+    For3D: boolean;
+    gridX: number;
+    gridY: number;
+    HTile: boolean;
+    VTile: boolean;
+    premultiplyAlpha: boolean;
+    textureGroupId: GMResourceRef;
+}
+/** GameMaker Sprite Frame */
+export interface GMSpriteFrame {
+    resourceType: 'GMSpriteFrame';
+    resourceVersion: string;
+    name: string;
+    compositeImage: GMResourceRef;
+    images: GMResourceRef[];
+}
+/** GameMaker Sprite Sequence */
+export interface GMSpriteSequence {
+    resourceType: 'GMSequence';
+    resourceVersion: string;
+    name: string;
+    playback: number;
+    playbackSpeed: number;
+    playbackSpeedType: number;
+    length: number;
+    tracks: unknown[];
+    visibleRange: unknown | null;
+    lockOrigin: boolean;
+    showBackdrop: boolean;
+    showBackdropImage: boolean;
+    backdropImagePath: string;
+    backdropImageOpacity: number;
+    backdropWidth: number;
+    backdropHeight: number;
+    backdropXOffset: number;
+    backdropYOffset: number;
+    xorigin: number;
+    yorigin: number;
+    volume: number;
+    events: unknown;
+    moments: unknown;
+}
+/** GameMaker Sprite Layer */
+export interface GMSpriteLayer {
+    resourceType: 'GMImageLayer';
+    resourceVersion: string;
+    name: string;
+    visible: boolean;
+    isLocked: boolean;
+    blendMode: number;
+    opacity: number;
+}
+/** GameMaker Nine Slice */
+export interface GMNineSlice {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    guideColour: GMColor[];
+    highlightColour: GMColor;
+    highlightStyle: number;
+    enabled: boolean;
+    tileMode: number[];
+}
+export declare class GameMakerImporter extends SceneImporter {
+    private objects;
+    private sprites;
+    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 isRoomFile;
+    private isSpriteFile;
+    private isObjectFile;
+    private convertRoomToScene;
+    private convertRoomToParsed;
+    private convertLayer;
+    private convertLayerToParsed;
+    private convertInstance;
+    private convertInstanceToParsed;
+    private convertTileLayer;
+    private decompressTileData;
+    private convertBackgroundLayer;
+    private convertAsset;
+    private convertSpriteToAsset;
+    private extractAssetsFromLayers;
+    private colorToHex;
+    private readFile;
+}
+export declare function createGameMakerImporter(): GameMakerImporter;