@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/godot-integration/GodotAssetLibrary.js

@@ -0,0 +1,716 @@
+'use strict';
+
+/**
+ * @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
+ */
+// ============================================================
+// Asset Library Browser
+// ============================================================
+class GodotAssetLibraryBrowser {
+    constructor(config) {
+        this.cache = new Map();
+        this.callbacks = {};
+        this.config = {
+            apiBaseUrl: 'https://godotengine.org/asset-library/api',
+            cacheDuration: 300000, // 5 minutes
+            defaultGodotVersion: '4.3',
+            defaultPageSize: 40,
+            ...config,
+        };
+    }
+    // ─── Search & Browse ───────────────────────────────────
+    async search(query) {
+        const cacheKey = `search:${JSON.stringify(query)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        // Build query string
+        const params = new URLSearchParams();
+        if (query.type && query.type !== 'any') {
+            params.append('type', query.type);
+        }
+        if (query.category) {
+            params.append('category', query.category);
+        }
+        if (query.filter) {
+            params.append('filter', query.filter);
+        }
+        if (query.user) {
+            params.append('user', query.user);
+        }
+        if (query.godot_version) {
+            params.append('godot_version', query.godot_version);
+        }
+        if (query.max_results) {
+            params.append('max_results', String(query.max_results));
+        }
+        if (query.page) {
+            params.append('page', String(query.page));
+        }
+        if (query.sort) {
+            params.append('sort', query.sort);
+        }
+        if (query.reverse) {
+            params.append('reverse', 'true');
+        }
+        // In real implementation, fetch from API
+        const result = await this.mockSearch(query);
+        this.setCache(cacheKey, result);
+        this.callbacks.onSearchComplete?.(result);
+        return result;
+    }
+    async getAsset(assetId) {
+        const cacheKey = `asset:${assetId}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        // In real implementation, fetch from API
+        const asset = await this.mockGetAsset(assetId);
+        if (asset) {
+            this.setCache(cacheKey, asset);
+        }
+        return asset;
+    }
+    async getCategories() {
+        return [
+            { id: '2d_tools', name: '2D Tools' },
+            { id: '3d_tools', name: '3D Tools' },
+            { id: 'shaders', name: 'Shaders' },
+            { id: 'materials', name: 'Materials' },
+            { id: 'tools', name: 'Tools' },
+            { id: 'scripts', name: 'Scripts' },
+            { id: 'misc', name: 'Misc' },
+            { id: 'templates', name: 'Templates' },
+            { id: 'projects', name: 'Projects' },
+            { id: 'demos', name: 'Demos' },
+            { id: 'addons', name: 'Add-ons' },
+        ];
+    }
+    async getPopularAddons(count = 10) {
+        const result = await this.search({
+            type: 'addon',
+            sort: 'rating',
+            order: 'desc',
+            max_results: count,
+        });
+        return result.result;
+    }
+    async getRecentlyUpdated(count = 10) {
+        const result = await this.search({
+            sort: 'updated',
+            order: 'desc',
+            max_results: count,
+        });
+        return result.result;
+    }
+    async getOfficialAssets() {
+        const result = await this.search({
+            support: ['official'],
+            sort: 'rating',
+            order: 'desc',
+        });
+        return result.result;
+    }
+    // ─── Download & Install ────────────────────────────────
+    async initiateDownload(assetId) {
+        const asset = await this.getAsset(assetId);
+        if (!asset) {
+            throw new Error('Asset not found');
+        }
+        const downloadInfo = {
+            assetId,
+            downloadUrl: asset.download_url,
+            fileName: `${asset.title.replace(/\s+/g, '_')}_v${asset.version_string}.zip`,
+            hash: asset.download_hash,
+        };
+        this.callbacks.onDownloadStart?.(downloadInfo);
+        return downloadInfo;
+    }
+    async installAddon(assetId, projectPath) {
+        await this.initiateDownload(assetId);
+        // In real implementation:
+        // 1. Download the zip file
+        // 2. Extract to addons/ folder
+        // 3. Verify contents
+        const result = {
+            success: true,
+            assetId,
+            installedPath: `${projectPath}/addons/${assetId}`,
+            files: [],
+        };
+        this.callbacks.onInstallComplete?.(result);
+        return result;
+    }
+    checkCompatibility(asset, targetVersion) {
+        const assetMajor = parseInt(asset.godot_version.split('.')[0], 10);
+        const assetMinor = parseInt(asset.godot_version.split('.')[1], 10);
+        const targetMajor = parseInt(targetVersion.split('.')[0], 10);
+        const targetMinor = parseInt(targetVersion.split('.')[1], 10);
+        if (assetMajor !== targetMajor) {
+            return {
+                isCompatible: false,
+                reason: `Asset requires Godot ${assetMajor}.x, but target is ${targetMajor}.x`,
+                severity: 'error',
+            };
+        }
+        if (assetMinor > targetMinor) {
+            return {
+                isCompatible: false,
+                reason: `Asset requires Godot ${asset.godot_version} or higher`,
+                severity: 'warning',
+            };
+        }
+        return {
+            isCompatible: true,
+        };
+    }
+    // ─── Caching ───────────────────────────────────────────
+    getFromCache(key) {
+        const cached = this.cache.get(key);
+        if (!cached) {
+            return null;
+        }
+        if (Date.now() - cached.timestamp > this.config.cacheDuration) {
+            this.cache.delete(key);
+            return null;
+        }
+        return cached.data;
+    }
+    setCache(key, data) {
+        this.cache.set(key, { data, timestamp: Date.now() });
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+    // ─── Mock Data ─────────────────────────────────────────
+    async mockSearch(query) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const mockAssets = [
+            {
+                asset_id: '1',
+                type: 'addon',
+                title: 'GDQuest Dialogic',
+                author: 'gdquest',
+                author_id: '100',
+                category: 'tools',
+                category_id: '5',
+                cost: '0',
+                description: 'Create dialogs, branching conversations, and cutscenes with a powerful, non-linear node-based editor.',
+                support_level: 'community',
+                godot_version: '4.2',
+                version_string: '2.0.0',
+                version: 200,
+                rating: 4.8,
+                download_url: 'https://example.com/dialogic.zip',
+                download_hash: 'sha256:...',
+                browse_url: 'https://godotengine.org/asset-library/asset/1',
+                icon_url: 'https://example.com/dialogic-icon.png',
+                previews: [],
+                modify_date: '2024-01-15T00:00:00Z',
+                tags: ['dialog', 'visual-novel', 'branching'],
+            },
+            {
+                asset_id: '2',
+                type: 'addon',
+                title: 'Phantom Camera',
+                author: 'ramokz',
+                author_id: '200',
+                category: '3d_tools',
+                category_id: '2',
+                cost: '0',
+                description: 'A dynamic 2D & 3D camera addon for Godot 4.',
+                support_level: 'community',
+                godot_version: '4.2',
+                version_string: '0.6.0',
+                version: 60,
+                rating: 4.9,
+                download_url: 'https://example.com/phantom-camera.zip',
+                download_hash: 'sha256:...',
+                browse_url: 'https://godotengine.org/asset-library/asset/2',
+                icon_url: 'https://example.com/phantom-camera-icon.png',
+                previews: [],
+                modify_date: '2024-02-01T00:00:00Z',
+                tags: ['camera', '2d', '3d', 'cinematic'],
+            },
+            {
+                asset_id: '3',
+                type: 'addon',
+                title: 'GodotSteam',
+                author: 'gramps',
+                author_id: '300',
+                category: 'scripts',
+                category_id: '6',
+                cost: '0',
+                description: 'An ecosystem of tools for Steam integration in the Godot game engine.',
+                support_level: 'community',
+                godot_version: '4.2',
+                version_string: '4.6.0',
+                version: 460,
+                rating: 4.7,
+                download_url: 'https://example.com/godotsteam.zip',
+                download_hash: 'sha256:...',
+                browse_url: 'https://godotengine.org/asset-library/asset/3',
+                icon_url: 'https://example.com/godotsteam-icon.png',
+                previews: [],
+                modify_date: '2024-01-20T00:00:00Z',
+                tags: ['steam', 'networking', 'achievements'],
+            },
+            {
+                asset_id: '4',
+                type: 'addon',
+                title: 'Terrain3D',
+                author: 'outobugi',
+                author_id: '400',
+                category: '3d_tools',
+                category_id: '2',
+                cost: '0',
+                description: 'An editable terrain system for Godot 4, written in C++/GDExtension.',
+                support_level: 'community',
+                godot_version: '4.2',
+                version_string: '0.9.0',
+                version: 90,
+                rating: 4.8,
+                download_url: 'https://example.com/terrain3d.zip',
+                download_hash: 'sha256:...',
+                browse_url: 'https://godotengine.org/asset-library/asset/4',
+                icon_url: 'https://example.com/terrain3d-icon.png',
+                previews: [],
+                modify_date: '2024-01-25T00:00:00Z',
+                tags: ['terrain', '3d', 'gdextension', 'editor'],
+            },
+            {
+                asset_id: '5',
+                type: 'addon',
+                title: 'Godot Jolt',
+                author: 'godot-jolt',
+                author_id: '500',
+                category: 'scripts',
+                category_id: '6',
+                cost: '0',
+                description: 'Godot Jolt is a native extension that allows you to use the Jolt physics engine in Godot.',
+                support_level: 'community',
+                godot_version: '4.2',
+                version_string: '0.11.0',
+                version: 110,
+                rating: 4.9,
+                download_url: 'https://example.com/godot-jolt.zip',
+                download_hash: 'sha256:...',
+                browse_url: 'https://godotengine.org/asset-library/asset/5',
+                icon_url: 'https://example.com/godot-jolt-icon.png',
+                previews: [],
+                modify_date: '2024-02-05T00:00:00Z',
+                tags: ['physics', 'jolt', 'gdextension', '3d'],
+            },
+        ];
+        let filtered = [...mockAssets];
+        // Apply filters
+        if (query.filter) {
+            const filterLower = query.filter.toLowerCase();
+            filtered = filtered.filter((a) => a.title.toLowerCase().includes(filterLower) ||
+                a.description.toLowerCase().includes(filterLower) ||
+                a.tags?.some((t) => t.toLowerCase().includes(filterLower)));
+        }
+        if (query.category) {
+            filtered = filtered.filter((a) => a.category === query.category);
+        }
+        if (query.type && query.type !== 'any') {
+            filtered = filtered.filter((a) => a.type === query.type);
+        }
+        if (query.godot_version) {
+            filtered = filtered.filter((a) => {
+                const assetMajor = parseInt(a.godot_version.split('.')[0], 10);
+                const targetMajor = parseInt(query.godot_version.split('.')[0], 10);
+                return assetMajor === targetMajor;
+            });
+        }
+        if (query.support) {
+            filtered = filtered.filter((a) => query.support.includes(a.support_level));
+        }
+        if (query.user) {
+            filtered = filtered.filter((a) => a.author.toLowerCase() === query.user.toLowerCase());
+        }
+        // Sort
+        switch (query.sort) {
+            case 'rating':
+                filtered.sort((a, b) => b.rating - a.rating);
+                break;
+            case 'name':
+                filtered.sort((a, b) => a.title.localeCompare(b.title));
+                break;
+            case 'updated':
+                filtered.sort((a, b) => new Date(b.modify_date).getTime() - new Date(a.modify_date).getTime());
+                break;
+        }
+        if (query.reverse || query.order === 'asc') {
+            filtered.reverse();
+        }
+        const page = query.page ?? 0;
+        const pageSize = query.max_results ?? this.config.defaultPageSize;
+        const start = page * pageSize;
+        const paged = filtered.slice(start, start + pageSize);
+        return {
+            result: paged,
+            page,
+            page_length: paged.length,
+            pages: Math.ceil(filtered.length / pageSize),
+            total_items: filtered.length,
+        };
+    }
+    async mockGetAsset(assetId) {
+        const result = await this.mockSearch({});
+        return result.result.find((a) => a.asset_id === assetId) ?? null;
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+// ============================================================
+// GDExtension Manager
+// ============================================================
+class GDExtensionManager {
+    constructor() {
+        this.extensions = new Map();
+        this.bindings = new Map();
+        this.callbacks = {};
+        // Initialize with known GDExtensions
+        this.registerKnownExtensions();
+    }
+    registerKnownExtensions() {
+        // Common GDExtensions in the ecosystem
+        const knownExtensions = [
+            {
+                name: 'godot-jolt',
+                manifestPath: 'addons/godot-jolt/godot-jolt.gdextension',
+                manifest: {
+                    config_version: 1,
+                    name: 'godot-jolt',
+                    entry_symbol: 'godot_jolt_main',
+                    compatibility: { minimum: '4.1' },
+                    libraries: {
+                        'windows.x86_64': 'bin/godot-jolt.windows.x86_64.dll',
+                        'linux.x86_64': 'bin/libgodot-jolt.linux.x86_64.so',
+                        macos: 'bin/libgodot-jolt.macos.universal.dylib',
+                    },
+                },
+                isCompatible: true,
+                platforms: ['windows', 'linux', 'macos'],
+                isInstalled: false,
+                hasNice2DevBinding: true,
+            },
+            {
+                name: 'terrain3d',
+                manifestPath: 'addons/terrain_3d/terrain.gdextension',
+                manifest: {
+                    config_version: 1,
+                    name: 'terrain3d',
+                    entry_symbol: 'terrain3d_library_init',
+                    compatibility: { minimum: '4.1' },
+                    libraries: {
+                        'windows.x86_64': 'bin/libterrain.windows.x86_64.dll',
+                        'linux.x86_64': 'bin/libterrain.linux.x86_64.so',
+                        macos: 'bin/libterrain.macos.universal.dylib',
+                    },
+                },
+                isCompatible: true,
+                platforms: ['windows', 'linux', 'macos'],
+                isInstalled: false,
+                hasNice2DevBinding: false,
+            },
+            {
+                name: 'godotsteam',
+                manifestPath: 'addons/godotsteam/godotsteam.gdextension',
+                manifest: {
+                    config_version: 1,
+                    name: 'godotsteam',
+                    entry_symbol: 'steam_library_init',
+                    compatibility: { minimum: '4.1' },
+                    libraries: {
+                        'windows.x86_64': 'bin/godotsteam.windows.x86_64.dll',
+                        'linux.x86_64': 'bin/libgodotsteam.linux.x86_64.so',
+                        macos: 'bin/libgodotsteam.macos.universal.dylib',
+                    },
+                    dependencies: {
+                        'windows.x86_64': ['steam_api64.dll'],
+                        'linux.x86_64': ['libsteam_api.so'],
+                        macos: ['libsteam_api.dylib'],
+                    },
+                },
+                isCompatible: true,
+                platforms: ['windows', 'linux', 'macos'],
+                isInstalled: false,
+                hasNice2DevBinding: true,
+            },
+        ];
+        for (const ext of knownExtensions) {
+            this.extensions.set(ext.name, ext);
+        }
+    }
+    // ─── Extension Management ──────────────────────────────
+    getExtension(name) {
+        return this.extensions.get(name);
+    }
+    getAllExtensions() {
+        return Array.from(this.extensions.values());
+    }
+    getInstalledExtensions() {
+        return Array.from(this.extensions.values()).filter((e) => e.isInstalled);
+    }
+    async parseGDExtensionFile(content) {
+        // GDExtension files are in a INI-like format
+        const manifest = {
+            config_version: 1,
+            name: '',
+            entry_symbol: '',
+            compatibility: { minimum: '4.1' },
+            libraries: {},
+        };
+        let currentSection = '';
+        const lines = content.split('\n');
+        for (let line of lines) {
+            line = line.trim();
+            if (!line || line.startsWith(';')) {
+                continue;
+            }
+            // Section header
+            if (line.startsWith('[') && line.endsWith(']')) {
+                currentSection = line.slice(1, -1);
+                continue;
+            }
+            // Key-value pair
+            if (line.includes('=')) {
+                const eqIndex = line.indexOf('=');
+                const key = line.substring(0, eqIndex).trim();
+                let value = line.substring(eqIndex + 1).trim();
+                // Remove quotes
+                if (value.startsWith('"') && value.endsWith('"')) {
+                    value = value.slice(1, -1);
+                }
+                switch (currentSection) {
+                    case 'configuration':
+                        if (key === 'entry_symbol') {
+                            manifest.entry_symbol = value;
+                        }
+                        if (key === 'compatibility_minimum') {
+                            manifest.compatibility.minimum = value;
+                        }
+                        if (key === 'compatibility_maximum') {
+                            manifest.compatibility.maximum = value;
+                        }
+                        if (key === 'reloadable') {
+                            manifest.reloadable = value === 'true';
+                        }
+                        break;
+                    case 'libraries':
+                        manifest.libraries[key] = value;
+                        break;
+                    case 'dependencies':
+                        if (!manifest.dependencies) {
+                            manifest.dependencies = {};
+                        }
+                        manifest.dependencies[key] = value.split(',').map((v) => v.trim());
+                        break;
+                }
+            }
+        }
+        return manifest;
+    }
+    checkExtensionCompatibility(manifest, godotVersion) {
+        const minParts = manifest.compatibility.minimum.split('.').map(Number);
+        const versionParts = godotVersion.split('.').map(Number);
+        // Check minimum version
+        for (let i = 0; i < minParts.length; i++) {
+            if (versionParts[i] < minParts[i]) {
+                return false;
+            }
+            if (versionParts[i] > minParts[i]) {
+                break;
+            }
+        }
+        // Check maximum version if specified
+        if (manifest.compatibility.maximum) {
+            const maxParts = manifest.compatibility.maximum.split('.').map(Number);
+            for (let i = 0; i < maxParts.length; i++) {
+                if (versionParts[i] > maxParts[i]) {
+                    return false;
+                }
+                if (versionParts[i] < maxParts[i]) {
+                    break;
+                }
+            }
+        }
+        return true;
+    }
+    // ─── Nice2Dev Bindings ─────────────────────────────────
+    generateBinding(extension) {
+        // In real implementation, parse the extension's API and generate TypeScript bindings
+        const binding = {
+            extensionName: extension.name,
+            types: [],
+            methods: [],
+            signals: [],
+        };
+        // Example bindings for godot-jolt
+        if (extension.name === 'godot-jolt') {
+            binding.types = [
+                {
+                    name: 'JoltPhysicsServer3D',
+                    baseType: 'PhysicsServer3D',
+                    isRefCounted: false,
+                    properties: [],
+                },
+                {
+                    name: 'JoltShapeSettings3D',
+                    baseType: 'Resource',
+                    isRefCounted: true,
+                    properties: [{ name: 'margin', type: 'float', default: '0.04' }],
+                },
+            ];
+        }
+        // Example bindings for godotsteam
+        if (extension.name === 'godotsteam') {
+            binding.types = [
+                {
+                    name: 'Steam',
+                    baseType: 'Object',
+                    isRefCounted: false,
+                    properties: [{ name: 'is_initialized', type: 'bool', getter: 'isSteamRunning' }],
+                },
+            ];
+            binding.methods = [
+                {
+                    name: 'steamInit',
+                    returnType: 'Dictionary',
+                    arguments: [{ name: 'retrieve_stats', type: 'bool', default: 'true' }],
+                    isStatic: true,
+                    isConst: false,
+                    isVirtual: false,
+                },
+                {
+                    name: 'getPersonaName',
+                    returnType: 'String',
+                    arguments: [],
+                    isStatic: false,
+                    isConst: true,
+                    isVirtual: false,
+                },
+                {
+                    name: 'setAchievement',
+                    returnType: 'bool',
+                    arguments: [{ name: 'achievement_name', type: 'String' }],
+                    isStatic: false,
+                    isConst: false,
+                    isVirtual: false,
+                },
+            ];
+            binding.signals = [
+                {
+                    name: 'overlay_toggled',
+                    arguments: [{ name: 'active', type: 'bool' }],
+                },
+                {
+                    name: 'current_stats_received',
+                    arguments: [
+                        { name: 'game_id', type: 'int' },
+                        { name: 'result', type: 'int' },
+                    ],
+                },
+            ];
+        }
+        this.bindings.set(extension.name, binding);
+        return binding;
+    }
+    getBinding(extensionName) {
+        return this.bindings.get(extensionName);
+    }
+    generateTypeScriptDefinitions(binding) {
+        let output = `// Nice2Dev GDExtension Bindings for ${binding.extensionName}\n\n`;
+        // Generate types
+        for (const type of binding.types) {
+            output += `export interface ${type.name} extends ${type.baseType} {\n`;
+            for (const prop of type.properties) {
+                output += `  ${prop.name}: ${this.mapGodotTypeToTS(prop.type)};\n`;
+            }
+            output += `}\n\n`;
+        }
+        // Generate method declarations
+        if (binding.methods.length > 0) {
+            output += `export interface ${binding.extensionName}Methods {\n`;
+            for (const method of binding.methods) {
+                const params = method.arguments
+                    .map((a) => `${a.name}: ${this.mapGodotTypeToTS(a.type)}`)
+                    .join(', ');
+                const returnType = this.mapGodotTypeToTS(method.returnType);
+                output += `  ${method.name}(${params}): ${returnType};\n`;
+            }
+            output += `}\n\n`;
+        }
+        // Generate signal declarations
+        if (binding.signals.length > 0) {
+            output += `export interface ${binding.extensionName}Signals {\n`;
+            for (const signal of binding.signals) {
+                const params = signal.arguments
+                    .map((a) => `${a.name}: ${this.mapGodotTypeToTS(a.type)}`)
+                    .join(', ');
+                output += `  ${signal.name}: (${params}) => void;\n`;
+            }
+            output += `}\n`;
+        }
+        return output;
+    }
+    mapGodotTypeToTS(godotType) {
+        const typeMap = {
+            void: 'void',
+            bool: 'boolean',
+            int: 'number',
+            float: 'number',
+            String: 'string',
+            StringName: 'string',
+            NodePath: 'string',
+            Vector2: '{ x: number; y: number }',
+            Vector2i: '{ x: number; y: number }',
+            Vector3: '{ x: number; y: number; z: number }',
+            Vector3i: '{ x: number; y: number; z: number }',
+            Vector4: '{ x: number; y: number; z: number; w: number }',
+            Color: '{ r: number; g: number; b: number; a: number }',
+            Rect2: '{ x: number; y: number; width: number; height: number }',
+            Transform2D: 'Transform2D',
+            Transform3D: 'Transform3D',
+            Array: 'unknown[]',
+            Dictionary: 'Record<string, unknown>',
+            Object: 'unknown',
+            Resource: 'unknown',
+        };
+        return typeMap[godotType] ?? godotType;
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createGodotAssetLibraryBrowser(config) {
+    return new GodotAssetLibraryBrowser(config);
+}
+function createGDExtensionManager() {
+    return new GDExtensionManager();
+}
+
+exports.GDExtensionManager = GDExtensionManager;
+exports.GodotAssetLibraryBrowser = GodotAssetLibraryBrowser;
+exports.createGDExtensionManager = createGDExtensionManager;
+exports.createGodotAssetLibraryBrowser = createGodotAssetLibraryBrowser;
+//# sourceMappingURL=GodotAssetLibrary.js.map