@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/build-cloud/GodotBuildCloud.d.ts

@@ -0,0 +1,475 @@
+/**
+ * @file GodotBuildCloud.ts
+ * @description Godot Build Cloud system for remote compilation
+ * PRO-1.7.2: Godot Build Cloud
+ *
+ * Features:
+ * - Godot Docker Image configuration
+ * - Multi-version support (4.2, 4.3, 4.4+)
+ * - Export templates pre-installed
+ * - Mono/.NET runtime for C# projects
+ * - GDExtension build tools
+ * - REST API for build jobs
+ * - Project conversion (Nice2Dev → Godot)
+ * - Add-on generation
+ */
+export type GodotVersion = '4.2' | '4.3' | '4.4' | 'custom';
+export type GodotPlatform = 'linux' | 'windows' | 'macos' | 'android' | 'ios' | 'web' | 'server_linux' | 'server_windows';
+export type GodotRenderMode = 'forward_plus' | 'mobile' | 'gl_compatibility';
+export type GodotScriptLanguage = 'gdscript' | 'csharp' | 'both';
+export type BuildStatus = 'pending' | 'queued' | 'preparing' | 'exporting' | 'packaging' | 'uploading' | 'completed' | 'failed' | 'cancelled';
+export interface GodotDockerImage {
+    /** Base image tag */
+    tag: string;
+    /** Godot version */
+    godotVersion: GodotVersion;
+    /** Custom version string */
+    customVersion?: string;
+    /** Has Mono/.NET support */
+    monoSupport: boolean;
+    /** .NET SDK version */
+    dotnetVersion?: string;
+    /** Installed export templates */
+    exportTemplates: GodotExportTemplate[];
+    /** Has GDExtension build tools */
+    gdextensionSupport: boolean;
+    /** SCons version */
+    sconsVersion?: string;
+    /** Image size in bytes */
+    size: number;
+    /** Last updated timestamp */
+    lastUpdated: number;
+}
+export interface GodotExportTemplate {
+    platform: GodotPlatform;
+    /** Template type (debug/release) */
+    type: 'debug' | 'release';
+    /** Template file path */
+    path: string;
+    /** Is custom template */
+    isCustom: boolean;
+}
+export declare const GODOT_DOCKER_IMAGES: Record<GodotVersion, GodotDockerImage>;
+export interface GodotBuildConfig {
+    /** Unique build ID */
+    id: string;
+    /** Project name */
+    projectName: string;
+    /** Godot version */
+    godotVersion: GodotVersion;
+    /** Custom version string */
+    customGodotVersion?: string;
+    /** Target platform */
+    platform: GodotPlatform;
+    /** The render mode */
+    renderMode: GodotRenderMode;
+    /** Script language */
+    scriptLanguage: GodotScriptLanguage;
+    /** Export preset name */
+    exportPreset: string;
+    /** Output path */
+    outputPath: string;
+    /** Build options */
+    options: GodotBuildOptions;
+    /** Project settings overrides */
+    projectSettings?: Partial<GodotProjectSettings>;
+    /** Feature tags */
+    featureTags?: string[];
+    /** Custom defines */
+    defines?: string[];
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Pre-export commands */
+    preExportCommands?: string[];
+    /** Post-export commands */
+    postExportCommands?: string[];
+}
+export interface GodotBuildOptions {
+    /** Debug or release export */
+    debug: boolean;
+    /** Export pack/zip only */
+    packOnly: boolean;
+    /** Encrypt resources */
+    encryptionKey?: string;
+    /** Script encryption key */
+    scriptEncryptionKey?: string;
+    /** Export with debug symbols */
+    exportDebugSymbols: boolean;
+    /** Custom export template */
+    customTemplate?: string;
+    /** Use custom build */
+    useCustomBuild: boolean;
+    /** Clean export folder */
+    cleanFirst: boolean;
+}
+export interface GodotProjectSettings {
+    /** Application name */
+    applicationName: string;
+    /** Version */
+    version: string;
+    /** Bundle identifier (Android/iOS) */
+    bundleIdentifier: string;
+    /** Icon path */
+    icon?: string;
+    /** Splash screen path */
+    splashScreen?: string;
+    /** Main scene path */
+    mainScene: string;
+    /** Autoload scripts */
+    autoloads: GodotAutoload[];
+    /** Input actions */
+    inputMap: GodotInputAction[];
+    /** Window settings */
+    window: GodotWindowSettings;
+    /** Physics settings */
+    physics: GodotPhysicsSettings;
+    /** Rendering settings */
+    rendering: GodotRenderingSettings;
+}
+export interface GodotAutoload {
+    name: string;
+    path: string;
+    enabled: boolean;
+}
+export interface GodotInputAction {
+    name: string;
+    deadzone: number;
+    events: GodotInputEvent[];
+}
+export interface GodotInputEvent {
+    type: 'key' | 'mouse_button' | 'joypad_button' | 'joypad_axis';
+    keycode?: number;
+    physical_keycode?: number;
+    unicode?: number;
+    button_index?: number;
+    axis?: number;
+    axis_value?: number;
+    modifiers?: {
+        ctrl?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+        meta?: boolean;
+    };
+}
+export interface GodotWindowSettings {
+    width: number;
+    height: number;
+    resizable: boolean;
+    borderless: boolean;
+    fullscreen: boolean;
+    vsync: 'disabled' | 'enabled' | 'adaptive' | 'mailbox';
+    stretchMode: 'disabled' | 'canvas_items' | 'viewport';
+    stretchAspect: 'ignore' | 'keep' | 'keep_width' | 'keep_height' | 'expand';
+}
+export interface GodotPhysicsSettings {
+    physicsFps: number;
+    physics2d: {
+        defaultGravity: number;
+        defaultGravityVector: {
+            x: number;
+            y: number;
+        };
+        defaultLinearDamp: number;
+        defaultAngularDamp: number;
+    };
+    physics3d: {
+        defaultGravity: number;
+        defaultGravityVector: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        defaultLinearDamp: number;
+        defaultAngularDamp: number;
+    };
+}
+export interface GodotRenderingSettings {
+    renderer: GodotRenderMode;
+    antiAliasing2d: 'disabled' | 'msaa_2x' | 'msaa_4x' | 'msaa_8x';
+    antiAliasing3d: 'disabled' | 'msaa_2x' | 'msaa_4x' | 'msaa_8x' | 'fxaa' | 'taa';
+    environmentDefaults: {
+        defaultEnvironment?: string;
+        ambientLightSource: 'background' | 'disabled' | 'color' | 'sky';
+        ambientLightColor: string;
+        ambientLightEnergy: number;
+    };
+    shadows: {
+        enabled: boolean;
+        quality: 'hard' | 'soft_low' | 'soft_medium' | 'soft_high' | 'soft_ultra';
+        atlasSize: 1024 | 2048 | 4096 | 8192;
+    };
+}
+export interface GodotBuildJob {
+    id: string;
+    config: GodotBuildConfig;
+    status: BuildStatus;
+    progress: number;
+    logs: BuildLogEntry[];
+    startedAt?: number;
+    completedAt?: number;
+    error?: string;
+    warnings: string[];
+    artifacts?: BuildArtifact[];
+    metrics?: BuildMetrics;
+    workerId?: string;
+}
+export interface BuildLogEntry {
+    timestamp: number;
+    level: 'info' | 'warning' | 'error' | 'debug';
+    message: string;
+    source?: string;
+}
+export interface BuildArtifact {
+    name: string;
+    path: string;
+    size: number;
+    checksum: string;
+    downloadUrl?: string;
+    expiresAt?: number;
+}
+export interface BuildMetrics {
+    totalTime: number;
+    prepareTime: number;
+    exportTime: number;
+    packagingTime: number;
+    uploadTime: number;
+    scriptParseTime: number;
+    resourceImportTime: number;
+    shaderCompileTime: number;
+    peakMemory: number;
+    artifactSize: number;
+}
+export interface NiceToGodotConversionConfig {
+    /** Source Nice2Dev project path */
+    sourcePath: string;
+    /** Output Godot project path */
+    outputPath: string;
+    /** Godot version target */
+    targetGodotVersion: GodotVersion;
+    /** Script language to generate */
+    scriptLanguage: GodotScriptLanguage;
+    /** Generate scenes */
+    generateScenes: boolean;
+    /** Convert visual scripts to GDScript/C# */
+    convertVisualScripts: boolean;
+    /** Resource conversion settings */
+    resourceConversion: ResourceConversionSettings;
+    /** Script conversion settings */
+    scriptConversion: ScriptConversionSettings;
+    /** Physics settings mapping */
+    physicsMapping: PhysicsMappingSettings;
+    /** Input map configuration */
+    inputMapSetup: InputMapSettings;
+    /** Autoload setup */
+    autoloadSetup: AutoloadSettings;
+}
+export interface ResourceConversionSettings {
+    /** Convert materials */
+    convertMaterials: boolean;
+    /** Convert shaders */
+    convertShaders: boolean;
+    /** Shader target (Godot Shading Language) */
+    shaderTarget: 'canvas_item' | 'spatial' | 'particles' | 'sky' | 'fog';
+    /** Convert animations */
+    convertAnimations: boolean;
+    /** Import textures */
+    importTextures: boolean;
+    /** Texture import settings */
+    textureSettings: TextureImportSettings;
+    /** Import audio */
+    importAudio: boolean;
+    /** Audio import settings */
+    audioSettings: AudioImportSettings;
+}
+export interface TextureImportSettings {
+    compress: boolean;
+    compressMode: 'lossless' | 'lossy' | 'vram_compressed' | 'vram_uncompressed';
+    maxSize: number;
+    generateMipmaps: boolean;
+    filter: boolean;
+}
+export interface AudioImportSettings {
+    loop: boolean;
+    loopOffset: number;
+    maxRate: 44100 | 48000 | 96000;
+    stereoToMono: boolean;
+}
+export interface ScriptConversionSettings {
+    /** Preserve comments */
+    preserveComments: boolean;
+    /** Generate type hints */
+    generateTypeHints: boolean;
+    /** Use static typing */
+    useStaticTyping: boolean;
+    /** Generate documentation */
+    generateDocumentation: boolean;
+    /** Signal auto-connection */
+    autoConnectSignals: boolean;
+}
+export interface PhysicsMappingSettings {
+    /** Convert 2D physics */
+    convert2D: boolean;
+    /** Convert 3D physics */
+    convert3D: boolean;
+    /** Physics layer mapping */
+    layerMapping: Record<number, number>;
+    /** Default physics material */
+    defaultPhysicsMaterial2D?: string;
+    defaultPhysicsMaterial3D?: string;
+}
+export interface InputMapSettings {
+    /** Generate input map */
+    generateInputMap: boolean;
+    /** Action mappings */
+    actionMappings: Array<{
+        nice2devAction: string;
+        godotAction: string;
+    }>;
+    /** Default deadzone */
+    defaultDeadzone: number;
+}
+export interface AutoloadSettings {
+    /** Generate autoloads */
+    generateAutoloads: boolean;
+    /** Autoload entries */
+    autoloads: Array<{
+        name: string;
+        scriptPath: string;
+        order: number;
+    }>;
+}
+export interface GodotAddonConfig {
+    /** Add-on name */
+    name: string;
+    /** Display name */
+    displayName: string;
+    /** Version */
+    version: string;
+    /** Description */
+    description: string;
+    /** Author */
+    author: string;
+    /** Script (plugin.gd) */
+    scriptName: string;
+    /** Icon path */
+    icon?: string;
+    /** Documentation URL */
+    documentationUrl?: string;
+    /** Scripts to include */
+    scripts: AddonScript[];
+    /** Custom node types */
+    customNodes: CustomNodeType[];
+    /** Editor plugin features */
+    editorFeatures: EditorPluginFeatures;
+}
+export interface AddonScript {
+    path: string;
+    content?: string;
+    isAutoload: boolean;
+}
+export interface CustomNodeType {
+    name: string;
+    extends: string;
+    script: string;
+    icon?: string;
+}
+export interface EditorPluginFeatures {
+    /** Add custom dock */
+    customDock?: {
+        enabled: boolean;
+        name: string;
+        iconPath?: string;
+        position: 'left' | 'right' | 'bottom';
+    };
+    /** Add custom inspector */
+    customInspector?: {
+        enabled: boolean;
+        targetType: string;
+    };
+    /** Add import plugin */
+    importPlugin?: {
+        enabled: boolean;
+        extensions: string[];
+        importerName: string;
+    };
+    /** Add export plugin */
+    exportPlugin?: {
+        enabled: boolean;
+    };
+    /** Custom tool buttons */
+    toolButtons?: Array<{
+        name: string;
+        icon?: string;
+        tooltip?: string;
+    }>;
+}
+export interface GodotBuildCloudCallbacks {
+    onBuildSubmitted?: (job: GodotBuildJob) => void;
+    onBuildStarted?: (job: GodotBuildJob) => void;
+    onBuildProgress?: (job: GodotBuildJob, progress: number) => void;
+    onBuildLog?: (job: GodotBuildJob, log: BuildLogEntry) => void;
+    onBuildCompleted?: (job: GodotBuildJob) => void;
+    onBuildFailed?: (job: GodotBuildJob, error: string) => void;
+    onBuildCancelled?: (job: GodotBuildJob) => void;
+    onArtifactReady?: (job: GodotBuildJob, artifact: BuildArtifact) => void;
+}
+export declare class GodotBuildCloud {
+    private config;
+    private jobs;
+    private callbacks;
+    constructor(config?: Partial<GodotBuildCloud['config']>);
+    submitBuild(config: Partial<GodotBuildConfig>): Promise<GodotBuildJob>;
+    private createFullBuildConfig;
+    private generateJobId;
+    private startBuildSimulation;
+    private getArtifactExtension;
+    private generateChecksum;
+    private addLog;
+    cancelBuild(jobId: string): Promise<boolean>;
+    getJob(jobId: string): GodotBuildJob | undefined;
+    getJobs(): GodotBuildJob[];
+    convertProject(config: NiceToGodotConversionConfig): Promise<ConversionResult>;
+    private generateProjectGodot;
+    private generateExportPresets;
+    private generateDefaultEnvironment;
+    private generateGDScriptGameManager;
+    private generateCSharpGameManager;
+    private generateAutoloadScript;
+    generateAddon(config: GodotAddonConfig): Promise<AddonGenerationResult>;
+    private generatePluginCfg;
+    private generatePluginGd;
+    private generateCustomNodeScript;
+    private generateDockScript;
+    setCallbacks(callbacks: GodotBuildCloudCallbacks): void;
+    clearJobs(): void;
+}
+export interface ConversionResult {
+    success: boolean;
+    convertedFiles: Array<{
+        path: string;
+        type: string;
+        content?: string;
+    }>;
+    warnings: string[];
+    errors: string[];
+}
+export interface AddonGenerationResult {
+    success: boolean;
+    addonPath: string;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+    warnings: string[];
+}
+export declare function generateGodotDockerfile(image: GodotDockerImage): string;
+export declare function createGodotBuildCloud(config?: Partial<{
+    apiBaseUrl: string;
+    apiKey: string;
+    defaultGodotVersion: GodotVersion;
+    maxConcurrentBuilds: number;
+    buildTimeout: number;
+}>): GodotBuildCloud;
+export declare function createGodotBuildConfig(projectName: string, platform: GodotPlatform, options?: Partial<GodotBuildConfig>): Partial<GodotBuildConfig>;
+export declare function createNiceToGodotConfig(sourcePath: string, outputPath: string, options?: Partial<NiceToGodotConversionConfig>): NiceToGodotConversionConfig;
+export declare function createGodotAddonConfig(name: string, version: string, options?: Partial<GodotAddonConfig>): GodotAddonConfig;