@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/godot-integration/GodotAssetLibrary.d.ts

@@ -0,0 +1,257 @@
+/**
+ * @file GodotAssetLibrary.ts
+ * @description Godot Asset Library Integration for Nice2Dev Game Engine
+ * PRO-1.9.3: Godot Asset Library Integration
+ *
+ * Features:
+ * - Asset Library browser
+ * - Asset search and filtering
+ * - One-click install
+ * - Version compatibility check
+ * - GDExtension support
+ */
+export type AssetLibraryCategory = '2d_tools' | '3d_tools' | 'shaders' | 'materials' | 'tools' | 'scripts' | 'misc' | 'templates' | 'projects' | 'demos' | 'addons';
+export type AssetLibrarySortBy = 'rating' | 'cost' | 'name' | 'updated';
+export type AssetLibrarySortOrder = 'asc' | 'desc';
+export type AssetSupportLevel = 'official' | 'community' | 'testing';
+export type GodotVersion = '4.3' | '4.2' | '4.1' | '4.0' | '3.5' | '3.4' | string;
+export type GDExtensionPlatform = 'windows' | 'linux' | 'macos' | 'android' | 'ios' | 'web';
+export interface AssetLibraryAsset {
+    /** Asset ID */
+    asset_id: string;
+    /** Asset type (addon, project, etc.) */
+    type: 'addon' | 'project';
+    /** Title */
+    title: string;
+    /** Author username */
+    author: string;
+    /** Author ID */
+    author_id: string;
+    /** Category */
+    category: AssetLibraryCategory;
+    /** Category ID */
+    category_id: string;
+    /** Cost (usually "0" for free) */
+    cost: string;
+    /** Description */
+    description: string;
+    /** Support level */
+    support_level: AssetSupportLevel;
+    /** Godot version */
+    godot_version: GodotVersion;
+    /** Version string */
+    version_string: string;
+    /** Version number for comparison */
+    version: number;
+    /** Rating (0-5) */
+    rating: number;
+    /** Download URL */
+    download_url: string;
+    /** Download hash */
+    download_hash: string;
+    /** Browse URL */
+    browse_url: string;
+    /** Icon URL */
+    icon_url: string;
+    /** Preview images */
+    previews: AssetPreview[];
+    /** Modify date (ISO string) */
+    modify_date: string;
+    /** Tags */
+    tags?: string[];
+}
+export interface AssetPreview {
+    preview_id: string;
+    type: 'image' | 'video';
+    link: string;
+    thumbnail: string;
+}
+export interface AssetLibrarySearchQuery {
+    /** Category filter */
+    category?: AssetLibraryCategory;
+    /** Type filter */
+    type?: 'addon' | 'project' | 'any';
+    /** Search text */
+    filter?: string;
+    /** User filter (by author username) */
+    user?: string;
+    /** Godot version filter */
+    godot_version?: GodotVersion;
+    /** Maximum results */
+    max_results?: number;
+    /** Page offset */
+    page?: number;
+    /** Sort by */
+    sort?: AssetLibrarySortBy;
+    /** Sort order */
+    order?: AssetLibrarySortOrder;
+    /** Support level filter */
+    support?: AssetSupportLevel[];
+    /** Reverse order */
+    reverse?: boolean;
+}
+export interface AssetLibrarySearchResult {
+    result: AssetLibraryAsset[];
+    page: number;
+    page_length: number;
+    pages: number;
+    total_items: number;
+}
+export interface AssetLibraryConfig {
+    apiBaseUrl: string;
+    cacheDuration: number;
+    defaultGodotVersion: GodotVersion;
+    defaultPageSize: number;
+}
+export interface GDExtensionManifest {
+    /** Configuration file format version */
+    config_version: number;
+    /** Extension name */
+    name: string;
+    /** Extension entry symbol */
+    entry_symbol: string;
+    /** Compatibility info */
+    compatibility: {
+        minimum: string;
+        maximum?: string;
+    };
+    /** Library paths per platform */
+    libraries: Record<string, string>;
+    /** Dependencies */
+    dependencies?: Record<string, string[]>;
+    /** Reloadable (for development) */
+    reloadable?: boolean;
+}
+export interface GDExtensionInfo {
+    /** Extension name */
+    name: string;
+    /** Manifest path (relative to project) */
+    manifestPath: string;
+    /** Manifest data */
+    manifest: GDExtensionManifest;
+    /** Is compatible with current Godot version */
+    isCompatible: boolean;
+    /** Supported platforms */
+    platforms: GDExtensionPlatform[];
+    /** Is installed */
+    isInstalled: boolean;
+    /** Nice2Dev binding available */
+    hasNice2DevBinding: boolean;
+}
+export interface GDExtensionBinding {
+    /** Extension name */
+    extensionName: string;
+    /** Nice2Dev types generated */
+    types: GDExtensionType[];
+    /** Nice2Dev methods */
+    methods: GDExtensionMethod[];
+    /** Signals */
+    signals: GDExtensionSignal[];
+}
+export interface GDExtensionType {
+    name: string;
+    baseType: string;
+    isRefCounted: boolean;
+    properties: GDExtensionProperty[];
+}
+export interface GDExtensionProperty {
+    name: string;
+    type: string;
+    getter?: string;
+    setter?: string;
+    default?: string;
+}
+export interface GDExtensionMethod {
+    name: string;
+    returnType: string;
+    arguments: Array<{
+        name: string;
+        type: string;
+        default?: string;
+    }>;
+    isStatic: boolean;
+    isConst: boolean;
+    isVirtual: boolean;
+}
+export interface GDExtensionSignal {
+    name: string;
+    arguments: Array<{
+        name: string;
+        type: string;
+    }>;
+}
+export declare class GodotAssetLibraryBrowser {
+    private config;
+    private cache;
+    private callbacks;
+    constructor(config?: Partial<AssetLibraryConfig>);
+    search(query: AssetLibrarySearchQuery): Promise<AssetLibrarySearchResult>;
+    getAsset(assetId: string): Promise<AssetLibraryAsset | null>;
+    getCategories(): Promise<Array<{
+        id: AssetLibraryCategory;
+        name: string;
+        count?: number;
+    }>>;
+    getPopularAddons(count?: number): Promise<AssetLibraryAsset[]>;
+    getRecentlyUpdated(count?: number): Promise<AssetLibraryAsset[]>;
+    getOfficialAssets(): Promise<AssetLibraryAsset[]>;
+    initiateDownload(assetId: string): Promise<AssetDownloadInfo>;
+    installAddon(assetId: string, projectPath: string): Promise<InstallResult>;
+    checkCompatibility(asset: AssetLibraryAsset, targetVersion: GodotVersion): CompatibilityResult;
+    private getFromCache;
+    private setCache;
+    clearCache(): void;
+    private mockSearch;
+    private mockGetAsset;
+    setCallbacks(callbacks: AssetLibraryCallbacks): void;
+}
+export declare class GDExtensionManager {
+    private extensions;
+    private bindings;
+    private callbacks;
+    constructor();
+    private registerKnownExtensions;
+    getExtension(name: string): GDExtensionInfo | undefined;
+    getAllExtensions(): GDExtensionInfo[];
+    getInstalledExtensions(): GDExtensionInfo[];
+    parseGDExtensionFile(content: string): Promise<GDExtensionManifest>;
+    checkExtensionCompatibility(manifest: GDExtensionManifest, godotVersion: string): boolean;
+    generateBinding(extension: GDExtensionInfo): GDExtensionBinding;
+    getBinding(extensionName: string): GDExtensionBinding | undefined;
+    generateTypeScriptDefinitions(binding: GDExtensionBinding): string;
+    private mapGodotTypeToTS;
+    setCallbacks(callbacks: GDExtensionCallbacks): void;
+}
+export interface AssetDownloadInfo {
+    assetId: string;
+    downloadUrl: string;
+    fileName: string;
+    hash: string;
+}
+export interface InstallResult {
+    success: boolean;
+    assetId: string;
+    installedPath?: string;
+    files: string[];
+    error?: string;
+}
+export interface CompatibilityResult {
+    isCompatible: boolean;
+    reason?: string;
+    severity?: 'warning' | 'error';
+}
+export interface AssetLibraryCallbacks {
+    onSearchComplete?: (result: AssetLibrarySearchResult) => void;
+    onDownloadStart?: (info: AssetDownloadInfo) => void;
+    onDownloadProgress?: (assetId: string, progress: number) => void;
+    onDownloadComplete?: (assetId: string) => void;
+    onInstallComplete?: (result: InstallResult) => void;
+    onError?: (error: Error) => void;
+}
+export interface GDExtensionCallbacks {
+    onExtensionLoaded?: (extension: GDExtensionInfo) => void;
+    onBindingGenerated?: (binding: GDExtensionBinding) => void;
+    onError?: (error: Error) => void;
+}
+export declare function createGodotAssetLibraryBrowser(config?: Partial<AssetLibraryConfig>): GodotAssetLibraryBrowser;
+export declare function createGDExtensionManager(): GDExtensionManager;

package/dist/types/godot-integration/GodotImport.d.ts

@@ -0,0 +1,297 @@
+/**
+ * @file GodotImport.ts
+ * @description Godot Engine Project Import for Nice2Dev Game Engine
+ * PRO-1.9.1: Godot Project Import
+ *
+ * Features:
+ * - .tscn (text scene) parsing
+ * - .scn (binary scene) detection
+ * - .tres resource parsing
+ * - GDScript parser and AST extraction
+ * - Node tree reconstruction
+ * - Signal/connection mapping
+ */
+export type GodotNodeType = 'Node' | 'Node2D' | 'Node3D' | 'Sprite2D' | 'Sprite3D' | 'AnimatedSprite2D' | 'AnimatedSprite3D' | 'Camera2D' | 'Camera3D' | 'CharacterBody2D' | 'CharacterBody3D' | 'RigidBody2D' | 'RigidBody3D' | 'StaticBody2D' | 'StaticBody3D' | 'Area2D' | 'Area3D' | 'CollisionShape2D' | 'CollisionShape3D' | 'MeshInstance3D' | 'DirectionalLight3D' | 'OmniLight3D' | 'SpotLight3D' | 'AudioStreamPlayer' | 'AudioStreamPlayer2D' | 'AudioStreamPlayer3D' | 'AnimationPlayer' | 'AnimationTree' | 'GPUParticles2D' | 'GPUParticles3D' | 'CPUParticles2D' | 'CPUParticles3D' | 'TileMap' | 'TileMapLayer' | 'NavigationAgent2D' | 'NavigationAgent3D' | 'Timer' | 'CanvasLayer' | 'Control' | 'Button' | 'Label' | 'TextureRect' | 'Panel' | 'VBoxContainer' | 'HBoxContainer' | 'GridContainer' | 'LineEdit' | 'TextEdit' | 'ProgressBar' | 'Slider' | 'TabContainer' | 'SubViewport' | 'WorldEnvironment' | string;
+export type GodotResourceType = 'PackedScene' | 'Script' | 'Texture2D' | 'AtlasTexture' | 'SpriteFrames' | 'Material' | 'StandardMaterial3D' | 'ShaderMaterial' | 'CanvasItemMaterial' | 'Shader' | 'AudioStream' | 'AudioStreamWAV' | 'AudioStreamMP3' | 'AudioStreamOggVorbis' | 'Font' | 'FontFile' | 'TileSet' | 'Animation' | 'AnimationLibrary' | 'Mesh' | 'ArrayMesh' | 'PrimitiveMesh' | 'BoxMesh' | 'SphereMesh' | 'CylinderMesh' | 'CapsuleMesh' | 'Environment' | 'Sky' | 'NavigationMesh' | 'PhysicsMaterial' | 'Theme' | 'StyleBox' | 'Gradient' | 'Curve' | 'Curve2D' | 'Curve3D' | string;
+export type GDScriptType = 'null' | 'bool' | 'int' | 'float' | 'String' | 'Vector2' | 'Vector2i' | 'Vector3' | 'Vector3i' | 'Vector4' | 'Vector4i' | 'Rect2' | 'Rect2i' | 'Transform2D' | 'Transform3D' | 'Basis' | 'Quaternion' | 'Color' | 'NodePath' | 'StringName' | 'RID' | 'Object' | 'Array' | 'Dictionary' | 'PackedByteArray' | 'PackedInt32Array' | 'PackedInt64Array' | 'PackedFloat32Array' | 'PackedFloat64Array' | 'PackedStringArray' | 'PackedVector2Array' | 'PackedVector3Array' | 'PackedColorArray' | 'Signal' | 'Callable' | string;
+export interface GodotSceneHeader {
+    loadSteps: number;
+    format: number;
+    uid?: string;
+    type?: string;
+}
+export interface GodotExtResource {
+    id: string | number;
+    type: GodotResourceType;
+    path: string;
+    uid?: string;
+}
+export interface GodotSubResource {
+    id: string | number;
+    type: GodotResourceType;
+    properties: Record<string, unknown>;
+}
+export interface GodotNode {
+    name: string;
+    type: GodotNodeType;
+    parent?: string;
+    instance?: string | number;
+    instancePlaceholder?: string;
+    owner?: string;
+    index?: number;
+    groups?: string[];
+    properties: Record<string, unknown>;
+    children: GodotNode[];
+    script?: string | number;
+    signals?: GodotSignalConnection[];
+}
+export interface GodotSignalConnection {
+    signal: string;
+    from?: string;
+    to: string;
+    method: string;
+    flags?: number;
+    binds?: unknown[];
+}
+export interface GodotConnection {
+    signal: string;
+    from: string;
+    to: string;
+    method: string;
+    flags?: number;
+    binds?: unknown[];
+}
+export interface GodotScene {
+    header: GodotSceneHeader;
+    extResources: GodotExtResource[];
+    subResources: GodotSubResource[];
+    rootNode: GodotNode | null;
+    connections: GodotConnection[];
+    editable?: string[];
+}
+export interface GodotResource {
+    header: GodotResourceHeader;
+    extResources: GodotExtResource[];
+    subResources: GodotSubResource[];
+    resource: {
+        type: GodotResourceType;
+        properties: Record<string, unknown>;
+    };
+}
+export interface GodotResourceHeader {
+    type: GodotResourceType;
+    loadSteps?: number;
+    format: number;
+    uid?: string;
+}
+export interface GDScriptFile {
+    path: string;
+    className?: string;
+    extends: string;
+    classNameToken?: string;
+    isToolScript: boolean;
+    iconPath?: string;
+    signals: GDScriptSignal[];
+    enums: GDScriptEnum[];
+    constants: GDScriptConstant[];
+    exportVars: GDScriptExportVar[];
+    onreadyVars: GDScriptVariable[];
+    variables: GDScriptVariable[];
+    functions: GDScriptFunction[];
+    innerClasses: GDScriptInnerClass[];
+    staticFunctions: GDScriptFunction[];
+    annotations: GDScriptAnnotation[];
+}
+export interface GDScriptSignal {
+    name: string;
+    parameters: GDScriptParameter[];
+    documentation?: string;
+}
+export interface GDScriptEnum {
+    name: string;
+    values: Record<string, number>;
+    documentation?: string;
+}
+export interface GDScriptConstant {
+    name: string;
+    type?: GDScriptType;
+    value: string;
+    documentation?: string;
+}
+export interface GDScriptExportVar {
+    name: string;
+    type?: GDScriptType;
+    default?: string;
+    hint?: string;
+    hintString?: string;
+    exportAnnotations: string[];
+    documentation?: string;
+}
+export interface GDScriptVariable {
+    name: string;
+    type?: GDScriptType;
+    default?: string;
+    setget?: {
+        setter?: string;
+        getter?: string;
+    };
+    documentation?: string;
+}
+export interface GDScriptFunction {
+    name: string;
+    parameters: GDScriptParameter[];
+    returnType?: GDScriptType;
+    isVirtual: boolean;
+    isStatic: boolean;
+    isCoroutine: boolean;
+    body: string;
+    documentation?: string;
+}
+export interface GDScriptParameter {
+    name: string;
+    type?: GDScriptType;
+    default?: string;
+}
+export interface GDScriptInnerClass {
+    name: string;
+    extends?: string;
+    signals: GDScriptSignal[];
+    variables: GDScriptVariable[];
+    functions: GDScriptFunction[];
+}
+export interface GDScriptAnnotation {
+    name: string;
+    arguments?: string[];
+}
+export interface ImportedGodotScene {
+    name: string;
+    path: string;
+    nodes: ImportedGodotNode[];
+    rootNode: ImportedGodotNode | null;
+    connections: GodotConnection[];
+    resources: Map<string, GodotExtResource>;
+}
+export interface ImportedGodotNode {
+    id: string;
+    name: string;
+    type: GodotNodeType;
+    parentId?: string;
+    position?: {
+        x: number;
+        y: number;
+    } | {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: number | {
+        x: number;
+        y: number;
+        z: number;
+    };
+    scale?: {
+        x: number;
+        y: number;
+    } | {
+        x: number;
+        y: number;
+        z: number;
+    };
+    properties: Record<string, unknown>;
+    children: ImportedGodotNode[];
+    script?: GDScriptFile;
+    groups: string[];
+}
+export interface ImportProgress {
+    phase: 'scanning' | 'parsing' | 'converting' | 'complete';
+    current: number;
+    total: number;
+    currentFile?: string;
+    errors: string[];
+    warnings: string[];
+}
+export interface ImportCallbacks {
+    onProgress?: (progress: ImportProgress) => void;
+    onSceneParsed?: (scene: GodotScene) => void;
+    onResourceParsed?: (resource: GodotResource) => void;
+    onScriptParsed?: (script: GDScriptFile) => void;
+    onError?: (error: Error, file: string) => void;
+}
+/**
+ * Parses Godot's text scene format (.tscn)
+ */
+export declare function parseGodotScene(content: string): GodotScene;
+/**
+ * Parses Godot's text resource format (.tres)
+ */
+export declare function parseGodotResource(content: string): GodotResource;
+/**
+ * Parses GDScript files and extracts structure
+ */
+export declare function parseGDScript(content: string, filePath?: string): GDScriptFile;
+export interface GodotProjectConfig {
+    configVersion: number;
+    name: string;
+    features: string[];
+    icon?: string;
+    mainScene?: string;
+    autoloads: Record<string, string>;
+    inputMap: Record<string, GodotInputAction>;
+    layers: {
+        layer2d: Record<string, number>;
+        layer3d: Record<string, number>;
+    };
+}
+export interface GodotInputAction {
+    deadzone: number;
+    events: GodotInputEvent[];
+}
+export interface GodotInputEvent {
+    type: 'key' | 'mouse_button' | 'joypad_button' | 'joypad_motion';
+    device?: number;
+    keycode?: number;
+    physicalKeycode?: number;
+    buttonIndex?: number;
+    axis?: number;
+    axisValue?: number;
+}
+export declare class GodotProjectImporter {
+    private projectPath;
+    private config;
+    private scenes;
+    private resources;
+    private scripts;
+    private callbacks;
+    constructor(callbacks?: ImportCallbacks);
+    /**
+     * Parses project.godot configuration file
+     */
+    parseProjectConfig(content: string): GodotProjectConfig;
+    /**
+     * Imports a scene file and all its dependencies
+     */
+    importScene(content: string, filePath: string): Promise<ImportedGodotScene>;
+    /**
+     * Imports a resource file
+     */
+    importResource(content: string, filePath: string): Promise<GodotResource>;
+    /**
+     * Imports a GDScript file
+     */
+    importScript(content: string, filePath: string): Promise<GDScriptFile>;
+    private convertSceneToImported;
+    private convertNode;
+    private flattenNodes;
+    /**
+     * Gets all imported data
+     */
+    getImportedData(): {
+        config: GodotProjectConfig | null;
+        scenes: Map<string, GodotScene>;
+        resources: Map<string, GodotResource>;
+        scripts: Map<string, GDScriptFile>;
+    };
+    setCallbacks(callbacks: ImportCallbacks): void;
+}
+export declare const GODOT_NODE_MAPPING: Record<string, string>;
+export declare function createGodotProjectImporter(callbacks?: ImportCallbacks): GodotProjectImporter;