@playcraft/build 0.0.2 → 0.0.3

package/dist/analyzers/scene-asset-collector.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Scene Asset Dependency Collector
+ *
+ * 分析 PlayCanvas 场景文件，收集所有依赖的资源 ID
+ */
+export interface SceneDependencies {
+    sceneId: string;
+    sceneName: string;
+    directAssets: Set<string>;
+    indirectAssets: Set<string>;
+    scripts: Set<string>;
+}
+/**
+ * 分析场景的资源依赖
+ * @param sceneData 场景数据对象
+ * @param assets 所有资源的映射表
+ * @returns 场景的资源依赖信息
+ */
+export declare function analyzeSceneDependencies(sceneData: any, assets: Record<string, any>): Promise<SceneDependencies>;
+/**
+ * 分析多个场景的资源依赖并合并
+ * @param scenes 场景列表
+ * @param assets 所有资源的映射表
+ * @param globalScriptIds 全局脚本 ID 列表（来自 settings.scripts）
+ * @returns 合并后的资源 ID 集合
+ */
+export declare function collectScenesAssets(scenes: any[], assets: Record<string, any>, globalScriptIds?: Set<string>): Promise<Set<string>>;
+/**
+ * 打印场景依赖统计信息
+ */
+export declare function printSceneDependencies(deps: SceneDependencies): void;

package/dist/analyzers/scene-asset-collector.js

@@ -0,0 +1,225 @@
+/**
+ * Scene Asset Dependency Collector
+ *
+ * 分析 PlayCanvas 场景文件，收集所有依赖的资源 ID
+ */
+/**
+ * 分析场景的资源依赖
+ * @param sceneData 场景数据对象
+ * @param assets 所有资源的映射表
+ * @returns 场景的资源依赖信息
+ */
+export async function analyzeSceneDependencies(sceneData, assets) {
+    const deps = {
+        sceneId: sceneData.id || sceneData.scene || 'unknown',
+        sceneName: sceneData.name || 'Unknown Scene',
+        directAssets: new Set(),
+        indirectAssets: new Set(),
+        scripts: new Set(),
+    };
+    // 1. 遍历所有实体
+    if (sceneData.entities) {
+        for (const [entityId, entity] of Object.entries(sceneData.entities)) {
+            collectEntityAssets(entity, deps, assets);
+        }
+    }
+    // 2. 递归收集间接依赖
+    collectIndirectDependencies(deps, assets);
+    return deps;
+}
+/**
+ * 收集实体的资源引用
+ */
+function collectEntityAssets(entity, deps, assets) {
+    if (!entity || typeof entity !== 'object')
+        return;
+    // 扫描所有组件
+    if (entity.components) {
+        for (const [componentName, componentData] of Object.entries(entity.components)) {
+            if (componentData && typeof componentData === 'object') {
+                // 递归扫描组件数据，查找资源 ID
+                findAssetIds(componentData, deps, assets);
+            }
+        }
+    }
+    // 扫描其他可能包含资源引用的字段
+    const fieldsToScan = ['script', 'scripts', 'data', 'attributes'];
+    for (const field of fieldsToScan) {
+        if (entity[field]) {
+            findAssetIds(entity[field], deps, assets);
+        }
+    }
+}
+/**
+ * 递归查找 JSON 中的资源 ID
+ * PlayCanvas 中资源 ID 通常是数字或数字字符串
+ */
+function findAssetIds(obj, deps, assets, depth = 0) {
+    // 防止无限递归
+    if (depth > 15)
+        return;
+    if (obj === null || obj === undefined)
+        return;
+    // 检查是否是资源 ID
+    if (typeof obj === 'number' || typeof obj === 'string') {
+        const assetId = String(obj);
+        // 验证是否是真实的资源 ID
+        if (assets[assetId]) {
+            const asset = assets[assetId];
+            deps.directAssets.add(assetId);
+            // 如果是脚本资源，单独记录
+            if (asset.type === 'script') {
+                deps.scripts.add(assetId);
+            }
+        }
+        return;
+    }
+    // 递归处理数组
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            findAssetIds(item, deps, assets, depth + 1);
+        }
+        return;
+    }
+    // 递归处理对象
+    if (typeof obj === 'object') {
+        for (const [key, value] of Object.entries(obj)) {
+            // 跳过一些不包含资源引用的字段
+            if (key === 'position' || key === 'rotation' || key === 'scale' ||
+                key === 'enabled' || key === 'name' || key === 'parent' ||
+                key === 'children') {
+                continue;
+            }
+            findAssetIds(value, deps, assets, depth + 1);
+        }
+    }
+}
+/**
+ * 收集间接依赖（材质 → 纹理，模型 → 材质等）
+ */
+function collectIndirectDependencies(deps, assets) {
+    const visited = new Set();
+    const queue = Array.from(deps.directAssets);
+    while (queue.length > 0) {
+        const assetId = queue.shift();
+        if (visited.has(assetId))
+            continue;
+        visited.add(assetId);
+        const asset = assets[assetId];
+        if (!asset)
+            continue;
+        // 检查不同类型资源的依赖
+        switch (asset.type) {
+            case 'material':
+                // 材质可能引用纹理
+                findAssetIdsInData(asset.data, deps, assets, queue, visited);
+                break;
+            case 'model':
+                // 模型可能引用材质
+                findAssetIdsInData(asset.data, deps, assets, queue, visited);
+                // 检查材质映射
+                if (asset.data?.mapping) {
+                    for (const [meshName, materialId] of Object.entries(asset.data.mapping)) {
+                        if (typeof materialId === 'number' || typeof materialId === 'string') {
+                            const id = String(materialId);
+                            if (assets[id] && !visited.has(id) && !deps.directAssets.has(id)) {
+                                deps.indirectAssets.add(id);
+                                queue.push(id);
+                            }
+                        }
+                    }
+                }
+                break;
+            case 'cubemap':
+            case 'texture':
+                // 纹理资源通常是叶子节点，但可能引用其他纹理（如合成纹理）
+                findAssetIdsInData(asset.data, deps, assets, queue, visited);
+                break;
+            case 'sprite':
+                // Sprite 可能引用纹理图集
+                if (asset.data?.textureAtlasAsset) {
+                    const id = String(asset.data.textureAtlasAsset);
+                    if (assets[id] && !visited.has(id) && !deps.directAssets.has(id)) {
+                        deps.indirectAssets.add(id);
+                        queue.push(id);
+                    }
+                }
+                findAssetIdsInData(asset.data, deps, assets, queue, visited);
+                break;
+        }
+    }
+}
+/**
+ * 在资源数据中查找资源 ID
+ */
+function findAssetIdsInData(data, deps, assets, queue, visited) {
+    if (!data)
+        return;
+    // 递归扫描 data 对象
+    const scan = (obj, depth = 0) => {
+        if (depth > 10)
+            return;
+        if (obj === null || obj === undefined)
+            return;
+        if (typeof obj === 'number' || typeof obj === 'string') {
+            const id = String(obj);
+            if (assets[id] && !visited.has(id) && !deps.directAssets.has(id)) {
+                deps.indirectAssets.add(id);
+                queue.push(id);
+            }
+        }
+        else if (Array.isArray(obj)) {
+            for (const item of obj) {
+                scan(item, depth + 1);
+            }
+        }
+        else if (typeof obj === 'object') {
+            for (const [key, value] of Object.entries(obj)) {
+                // 跳过明显不是资源引用的字段
+                if (key === 'name' || key === 'enabled' || key === 'position' ||
+                    key === 'rotation' || key === 'scale') {
+                    continue;
+                }
+                scan(value, depth + 1);
+            }
+        }
+    };
+    scan(data);
+}
+/**
+ * 分析多个场景的资源依赖并合并
+ * @param scenes 场景列表
+ * @param assets 所有资源的映射表
+ * @param globalScriptIds 全局脚本 ID 列表（来自 settings.scripts）
+ * @returns 合并后的资源 ID 集合
+ */
+export async function collectScenesAssets(scenes, assets, globalScriptIds) {
+    const allAssetIds = new Set();
+    for (const scene of scenes) {
+        const deps = await analyzeSceneDependencies(scene, assets);
+        // 合并直接依赖和间接依赖
+        for (const id of deps.directAssets)
+            allAssetIds.add(id);
+        for (const id of deps.indirectAssets)
+            allAssetIds.add(id);
+        for (const id of deps.scripts)
+            allAssetIds.add(id);
+    }
+    // 包含全局脚本（在 settings.scripts 中声明的）
+    if (globalScriptIds) {
+        for (const id of globalScriptIds) {
+            allAssetIds.add(id);
+        }
+    }
+    return allAssetIds;
+}
+/**
+ * 打印场景依赖统计信息
+ */
+export function printSceneDependencies(deps) {
+    console.log(`\n📊 场景: ${deps.sceneName} (ID: ${deps.sceneId})`);
+    console.log(`  - 直接引用资源: ${deps.directAssets.size} 个`);
+    console.log(`  - 间接依赖资源: ${deps.indirectAssets.size} 个`);
+    console.log(`  - 脚本资源: ${deps.scripts.size} 个`);
+    console.log(`  - 总计: ${deps.directAssets.size + deps.indirectAssets.size} 个资源`);
+}

package/dist/base-builder.d.ts

@@ -1,5 +1,6 @@
 export interface BaseBuildOptions {
     outputDir: string;
+    selectedScenes?: string[];
 }
 export interface BaseBuildOutput {
     outputDir: string;

package/dist/base-builder.js

@@ -316,6 +316,7 @@ export class BaseBuilder {
                 viteSourceBuilderPlugin({
                     projectDir: this.projectDir,
                     outputDir: this.options.outputDir,
+                    selectedScenes: this.options.selectedScenes,
                 }),
             ],
         };

package/dist/generators/config-generator.d.ts

@@ -1,7 +1,10 @@
 import { PlayCanvasProject } from '../loaders/playcanvas-loader.js';
 import { PlayCraftProject } from '../loaders/playcraft-loader.js';
 export type ProjectConfig = PlayCanvasProject | PlayCraftProject;
+export interface GenerateConfigOptions {
+    selectedScenes?: string[];
+}
 /**
  * 生成 PlayCanvas 构建产物格式的 config.json
  */
-export declare function generateConfig(projectConfig: ProjectConfig): any;
+export declare function generateConfig(projectConfig: ProjectConfig, options?: GenerateConfigOptions): Promise<any>;

package/dist/generators/config-generator.js

@@ -1,3 +1,4 @@
+import { collectScenesAssets, printSceneDependencies, analyzeSceneDependencies } from '../analyzers/scene-asset-collector.js';
 function shouldIncludeAsset(asset, scriptIds, requiredScriptIds) {
     if (!asset) {
         return false;
@@ -41,7 +42,7 @@ function collectRequiredScriptIds(assets) {
 /**
  * 生成 PlayCanvas 构建产物格式的 config.json
  */
-export function generateConfig(projectConfig) {
+export async function generateConfig(projectConfig, options) {
     if (projectConfig.format === 'playcanvas') {
         const pcProject = projectConfig;
         // 从 PlayCanvas 项目格式生成 config.json
@@ -56,30 +57,62 @@ export function generateConfig(projectConfig) {
             config.application_properties.batchGroups = [];
         }
         // 处理场景
+        let allScenes = [];
         if (pcProject.scenes) {
-            if (Array.isArray(pcProject.scenes)) {
-                config.scenes = pcProject.scenes.map((scene) => ({
-                    name: scene.name || scene.id,
-                    url: scene.url || scene.file || `${scene.id}.json`,
-                }));
-            }
-            else {
-                // scenes.json 是对象格式
-                config.scenes = Object.entries(pcProject.scenes).map(([id, scene]) => ({
-                    name: scene.name || id,
-                    url: scene.url || scene.file || `${id}.json`,
-                }));
-            }
+            allScenes = Array.isArray(pcProject.scenes)
+                ? pcProject.scenes
+                : Object.entries(pcProject.scenes).map(([id, scene]) => ({ id, ...scene }));
+        }
+        // 场景过滤：如果指定了选中的场景，则只包含这些场景
+        let selectedScenes = allScenes;
+        if (options?.selectedScenes && options.selectedScenes.length > 0) {
+            selectedScenes = allScenes.filter(scene => {
+                const sceneId = String(scene.id || scene.scene);
+                const sceneName = scene.name || '';
+                return options.selectedScenes.some(selected => selected === sceneId || selected === sceneName);
+            });
+            console.log(`\n🎬 场景过滤:`);
+            console.log(`  - 总场景数: ${allScenes.length}`);
+            console.log(`  - 选中场景: ${selectedScenes.length}`);
+            selectedScenes.forEach(scene => {
+                console.log(`    • ${scene.name || scene.id}`);
+            });
         }
-        // 处理资产（过滤非运行时资产）
+        config.scenes = selectedScenes.map((scene) => ({
+            name: scene.name || scene.id,
+            url: scene.url || scene.file || `${scene.id}.json`,
+        }));
+        // 处理资产：基于场景过滤
         if (pcProject.assets) {
             const scriptIds = new Set((pcProject.project.settings?.scripts || []).map((id) => String(id)));
             const requiredScriptIds = collectRequiredScriptIds(pcProject.assets);
+            let allowedAssetIds = null;
+            // 如果启用了场景过滤，分析场景依赖
+            if (options?.selectedScenes && options.selectedScenes.length > 0 && selectedScenes.length > 0) {
+                console.log(`\n🔍 分析场景资源依赖...`);
+                allowedAssetIds = await collectScenesAssets(selectedScenes, pcProject.assets, scriptIds);
+                // 打印每个场景的依赖统计
+                for (const scene of selectedScenes) {
+                    const deps = await analyzeSceneDependencies(scene, pcProject.assets);
+                    printSceneDependencies(deps);
+                }
+                console.log(`\n📊 资源过滤统计:`);
+                console.log(`  - 总资源数: ${Object.keys(pcProject.assets).length}`);
+                console.log(`  - 全局脚本: ${scriptIds.size}`);
+                console.log(`  - 场景依赖: ${allowedAssetIds.size}`);
+                console.log(`  - 将节省: ${Object.keys(pcProject.assets).length - allowedAssetIds.size} 个资源 (${((1 - allowedAssetIds.size / Object.keys(pcProject.assets).length) * 100).toFixed(1)}%)`);
+            }
             const filtered = {};
             for (const [assetId, asset] of Object.entries(pcProject.assets)) {
-                if (shouldIncludeAsset(asset, scriptIds, requiredScriptIds)) {
-                    filtered[assetId] = asset;
+                // 基本过滤（非运行时资产）
+                if (!shouldIncludeAsset(asset, scriptIds, requiredScriptIds)) {
+                    continue;
                 }
+                // 场景过滤：如果启用，只包含场景依赖的资源
+                if (allowedAssetIds && !allowedAssetIds.has(assetId)) {
+                    continue;
+                }
+                filtered[assetId] = asset;
             }
             config.assets = filtered;
         }
@@ -99,21 +132,58 @@ export function generateConfig(projectConfig) {
             config.application_properties.batchGroups = [];
         }
         // 处理场景
-        if (pcProject.scenes && pcProject.scenes.length > 0) {
-            config.scenes = pcProject.scenes.map((scene) => ({
+        let allScenes = pcProject.scenes || [];
+        let selectedScenes = allScenes;
+        if (options?.selectedScenes && options.selectedScenes.length > 0 && allScenes.length > 0) {
+            selectedScenes = allScenes.filter(scene => {
+                const sceneId = String(scene.id || scene.name);
+                const sceneName = scene.name || '';
+                return options.selectedScenes.some(selected => selected === sceneId || selected === sceneName);
+            });
+            console.log(`\n🎬 场景过滤:`);
+            console.log(`  - 总场景数: ${allScenes.length}`);
+            console.log(`  - 选中场景: ${selectedScenes.length}`);
+            selectedScenes.forEach(scene => {
+                console.log(`    • ${scene.name || scene.id}`);
+            });
+        }
+        if (selectedScenes.length > 0) {
+            config.scenes = selectedScenes.map((scene) => ({
                 name: scene.name || scene.id,
                 url: scene.url || `${scene.id || 'scene'}.json`,
             }));
         }
-        // 处理资产（过滤非运行时资产）
+        // 处理资产：基于场景过滤
         if (pcProject.assets) {
             const scriptIds = new Set((pcProject.manifest.settings?.scripts || []).map((id) => String(id)));
             const requiredScriptIds = collectRequiredScriptIds(pcProject.assets);
+            let allowedAssetIds = null;
+            // 如果启用了场景过滤，分析场景依赖
+            if (options?.selectedScenes && options.selectedScenes.length > 0 && selectedScenes.length > 0) {
+                console.log(`\n🔍 分析场景资源依赖...`);
+                allowedAssetIds = await collectScenesAssets(selectedScenes, pcProject.assets, scriptIds);
+                // 打印每个场景的依赖统计
+                for (const scene of selectedScenes) {
+                    const deps = await analyzeSceneDependencies(scene, pcProject.assets);
+                    printSceneDependencies(deps);
+                }
+                console.log(`\n📊 资源过滤统计:`);
+                console.log(`  - 总资源数: ${Object.keys(pcProject.assets).length}`);
+                console.log(`  - 全局脚本: ${scriptIds.size}`);
+                console.log(`  - 场景依赖: ${allowedAssetIds.size}`);
+                console.log(`  - 将节省: ${Object.keys(pcProject.assets).length - allowedAssetIds.size} 个资源 (${((1 - allowedAssetIds.size / Object.keys(pcProject.assets).length) * 100).toFixed(1)}%)`);
+            }
             const filtered = {};
             for (const [assetId, asset] of Object.entries(pcProject.assets)) {
-                if (shouldIncludeAsset(asset, scriptIds, requiredScriptIds)) {
-                    filtered[assetId] = asset;
+                // 基本过滤（非运行时资产）
+                if (!shouldIncludeAsset(asset, scriptIds, requiredScriptIds)) {
+                    continue;
+                }
+                // 场景过滤：如果启用，只包含场景依赖的资源
+                if (allowedAssetIds && !allowedAssetIds.has(assetId)) {
+                    continue;
                 }
+                filtered[assetId] = asset;
             }
             config.assets = filtered;
         }

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export type Platform = 'facebook' | 'snapchat' | 'ironsource' | 'applovin' | 'google' | 'tiktok' | 'unity' | 'liftoff' | 'moloco' | 'bigo';
+export type Platform = 'facebook' | 'snapchat' | 'ironsource' | 'applovin' | 'google' | 'tiktok' | 'unity' | 'liftoff' | 'moloco' | 'bigo' | 'inmobi' | 'adikteev' | 'remerge';
 export type OutputFormat = 'html' | 'zip';
 export interface BuildOptions {
     platform: Platform;
@@ -25,6 +25,7 @@ export interface BuildOptions {
     skipBuild?: boolean;
     buildOptions?: LocalBuildOptions;
     useVite?: boolean;
+    selectedScenes?: string[];
     cssMinify?: boolean;
     jsMinify?: boolean;
     compressImages?: boolean;

package/dist/vite/platform-configs.js

@@ -254,4 +254,80 @@ export const PLATFORM_CONFIGS = {
             externFiles: true,
         },
     },
+    inmobi: {
+        sizeLimit: 5 * 1024 * 1024, // 5MB
+        outputFormat: 'zip',
+        minifyCSS: true,
+        minifyJS: true,
+        compressImages: true,
+        compressModels: true,
+        injectScripts: ['mraid'],
+        outputFileName: 'index.html',
+        includeSourcemap: false,
+        imageQuality: {
+            jpg: 75,
+            png: [0.7, 0.8],
+            webp: 75,
+        },
+        modelCompression: {
+            method: 'draco',
+            quality: 0.8,
+        },
+        playable: {
+            inlineGameScripts: true,
+            externFiles: true,
+            mraidSupport: true,
+        },
+    },
+    adikteev: {
+        sizeLimit: 5 * 1024 * 1024, // 5MB
+        outputFormat: 'html',
+        minifyCSS: true,
+        minifyJS: true,
+        compressImages: true,
+        compressModels: true,
+        injectScripts: ['mraid3'],
+        outputFileName: 'index.html',
+        includeSourcemap: false,
+        imageQuality: {
+            jpg: 75,
+            png: [0.7, 0.8],
+            webp: 75,
+        },
+        modelCompression: {
+            method: 'draco',
+            quality: 0.8,
+        },
+        playable: {
+            patchXhrOut: true,
+            inlineGameScripts: true,
+            configJsonInline: true,
+            mraidSupport: true,
+        },
+    },
+    remerge: {
+        sizeLimit: 5 * 1024 * 1024, // 5MB
+        outputFormat: 'html',
+        minifyCSS: true,
+        minifyJS: true,
+        compressImages: true,
+        compressModels: true,
+        injectScripts: ['fbPlayableAd'],
+        outputFileName: 'index.html',
+        includeSourcemap: false,
+        imageQuality: {
+            jpg: 75,
+            png: [0.7, 0.8],
+            webp: 75,
+        },
+        modelCompression: {
+            method: 'draco',
+            quality: 0.8,
+        },
+        playable: {
+            patchXhrOut: true,
+            inlineGameScripts: true,
+            configJsonInline: true,
+        },
+    },
 };

package/dist/vite/plugin-playcanvas.js

@@ -7,9 +7,15 @@ import { createRequire } from 'module';
  * 处理 PlayCanvas 特定的资源转换和内联
  */
 export function vitePlayCanvasPlugin(options) {
+    // 保存插件上下文，用于调用 Vite 的 load 方法
+    let pluginContext = null;
     return {
         name: 'vite-plugin-playcanvas',
         enforce: 'pre',
+        buildStart() {
+            // 保存插件的 this 上下文
+            pluginContext = this;
+        },
         async transformIndexHtml(html) {
             if (options.ammoReplacement) {
                 html = await injectPhysicsLibrary(html, options);
@@ -17,8 +23,8 @@ export function vitePlayCanvasPlugin(options) {
             if (options.outputFormat === 'html') {
                 // 1. 内联 PlayCanvas Engine + 引擎补丁
                 html = await inlineEngineScript(html, options.baseBuildDir, options);
-                // 2. 内联并转换 __settings__.js
-                html = await inlineAndConvertSettings(html, options.baseBuildDir, options);
+                // 2. 内联并转换 __settings__.js（传递插件上下文）
+                html = await inlineAndConvertSettings(html, options.baseBuildDir, options, pluginContext);
                 // 3. 内联 __modules__.js
                 html = await inlineModulesScript(html, options.baseBuildDir);
                 // 4. 内联 __start__.js
@@ -33,9 +39,9 @@ export function vitePlayCanvasPlugin(options) {
             return html;
         },
         async transform(code, id) {
-            // 转换 __settings__.js 中的资源路径为 data URLs
+            // 转换 __settings__.js 中的资源路径为 data URLs（传递插件上下文）
             if (id.endsWith('__settings__.js')) {
-                return await convertSettingsToDataUrls(code, options.baseBuildDir, options);
+                return await convertSettingsToDataUrls(code, options.baseBuildDir, options, pluginContext);
             }
             return code;
         },
@@ -73,18 +79,18 @@ async function inlineEngineScript(html, baseBuildDir, options) {
 /**
  * 内联并转换 __settings__.js
  */
-async function inlineAndConvertSettings(html, baseBuildDir, options) {
+async function inlineAndConvertSettings(html, baseBuildDir, options, pluginContext) {
     const settingsPath = path.join(baseBuildDir, '__settings__.js');
     try {
         await fs.access(settingsPath);
     }
     catch (error) {
         // __settings__.js 不存在，尝试从 config.json 生成
-        return await generateAndInlineSettings(html, baseBuildDir, options);
+        return await generateAndInlineSettings(html, baseBuildDir, options, pluginContext);
     }
     let settingsCode = await fs.readFile(settingsPath, 'utf-8');
-    // 转换资源URL为data URLs
-    settingsCode = await convertSettingsToDataUrls(settingsCode, baseBuildDir, options);
+    // 转换资源URL为data URLs（传递插件上下文）
+    settingsCode = await convertSettingsToDataUrls(settingsCode, baseBuildDir, options, pluginContext);
     // 替换 script 标签
     const scriptPattern = /<script[^>]*src=["']__settings__\.js["'][^>]*><\/script>/i;
     html = html.replace(scriptPattern, `<script>${settingsCode}</script>`);
@@ -93,12 +99,12 @@ async function inlineAndConvertSettings(html, baseBuildDir, options) {
 /**
  * 生成并内联 settings（如果 __settings__.js 不存在）
  */
-async function generateAndInlineSettings(html, baseBuildDir, options) {
+async function generateAndInlineSettings(html, baseBuildDir, options, pluginContext) {
     const configPath = path.join(baseBuildDir, 'config.json');
     const configContent = await fs.readFile(configPath, 'utf-8');
     let configJson = JSON.parse(configContent);
     if (options.convertDataUrls) {
-        configJson = await inlineConfigAssetUrls(configJson, baseBuildDir);
+        configJson = await inlineConfigAssetUrls(configJson, baseBuildDir, pluginContext);
     }
     if (options.ammoReplacement) {
         configJson = stripAmmoAssets(configJson);
@@ -158,9 +164,9 @@ window.PRELOAD_MODULES = ${JSON.stringify(preloadModules)};
 /**
  * 转换 settings 代码中的资源URL为 data URLs
  */
-async function convertSettingsToDataUrls(settingsCode, baseBuildDir, options) {
-    // 1. 转换 config.json
-    settingsCode = await convertConfigUrl(settingsCode, baseBuildDir, options);
+async function convertSettingsToDataUrls(settingsCode, baseBuildDir, options, pluginContext) {
+    // 1. 转换 config.json（传递插件上下文）
+    settingsCode = await convertConfigUrl(settingsCode, baseBuildDir, options, pluginContext);
     // 2. 转换场景文件
     settingsCode = await convertSceneUrl(settingsCode, baseBuildDir);
     // 3. 转换 PRELOAD_MODULES（优先使用 JS fallback）
@@ -170,7 +176,7 @@ async function convertSettingsToDataUrls(settingsCode, baseBuildDir, options) {
 /**
  * 转换 CONFIG_FILENAME 为 data URL
  */
-async function convertConfigUrl(settingsCode, baseBuildDir, options) {
+async function convertConfigUrl(settingsCode, baseBuildDir, options, pluginContext) {
     const configMatch = settingsCode.match(/window\.CONFIG_FILENAME\s*=\s*"([^"]+)"/);
     if (!configMatch) {
         return settingsCode;
@@ -184,7 +190,7 @@ async function convertConfigUrl(settingsCode, baseBuildDir, options) {
         const configContent = await fs.readFile(fullConfigPath, 'utf-8');
         let configJson = JSON.parse(configContent);
         if (options.convertDataUrls) {
-            configJson = await inlineConfigAssetUrls(configJson, baseBuildDir);
+            configJson = await inlineConfigAssetUrls(configJson, baseBuildDir, pluginContext);
         }
         if (options.ammoReplacement) {
             configJson = stripAmmoAssets(configJson);
@@ -528,12 +534,15 @@ function isAmmoModule(module) {
         wasmUrl.includes('ammo') ||
         fallbackUrl.includes('ammo'));
 }
-async function inlineConfigAssetUrls(configJson, baseBuildDir) {
+async function inlineConfigAssetUrls(configJson, baseBuildDir, pluginContext) {
     if (!configJson?.assets) {
         return configJson;
     }
     const assets = configJson.assets;
-    for (const asset of Object.values(assets)) {
+    const skippedAssets = [];
+    const optimizedAssets = [];
+    const SIZE_LIMIT = 1 * 1024 * 1024; // 1MB - 跳过超过这个大小的文件
+    for (const [assetId, asset] of Object.entries(assets)) {
         const file = asset?.file;
         if (!file?.url || typeof file.url !== 'string') {
             continue;
@@ -543,12 +552,54 @@ async function inlineConfigAssetUrls(configJson, baseBuildDir) {
             continue;
         }
         const cleanUrl = url.split('?')[0];
+        const fileName = cleanUrl.toLowerCase();
+        // 跳过物理引擎缓存文件和大型文本文件
+        if (fileName.endsWith('.pma.txt') ||
+            fileName.includes('browsermetrics') ||
+            fileName.includes('deferredbrowsermetrics') ||
+            (fileName.endsWith('.txt') && file.size && file.size > SIZE_LIMIT)) {
+            skippedAssets.push(`${asset.name || assetId} (${(file.size / 1024 / 1024).toFixed(2)}MB)`);
+            // 标记为不预加载，避免引擎尝试加载
+            asset.preload = false;
+            // 清空 URL，避免加载失败
+            file.url = 'data:text/plain;base64,';
+            continue;
+        }
         const fullPath = path.join(baseBuildDir, cleanUrl);
         try {
+            // ✅ 简化逻辑：直接读取文件并判断是否需要压缩
             const buffer = await fs.readFile(fullPath);
-            const mime = guessMimeType(cleanUrl);
-            file.url = `data:${mime};base64,${buffer.toString('base64')}`;
-            file.size = buffer.length;
+            const originalSize = buffer.length;
+            // 检查实际文件大小，跳过超大文件
+            if (originalSize > SIZE_LIMIT) {
+                skippedAssets.push(`${asset.name || assetId} (${(originalSize / 1024 / 1024).toFixed(2)}MB)`);
+                asset.preload = false;
+                file.url = 'data:text/plain;base64,';
+                continue;
+            }
+            let dataUrl;
+            let finalSize;
+            // ✅ 核心优化：如果是图片，使用 sharp 压缩
+            if (isImageFile(cleanUrl)) {
+                const compressed = await compressImage(buffer, cleanUrl, {
+                    convertToWebP: true,
+                    quality: 75,
+                });
+                dataUrl = `data:${compressed.mime};base64,${compressed.buffer.toString('base64')}`;
+                finalSize = compressed.buffer.length;
+                // 记录优化效果
+                const savings = ((1 - finalSize / originalSize) * 100).toFixed(1);
+                optimizedAssets.push(`${asset.name || assetId}: ${(originalSize / 1024).toFixed(1)}KB → ${(finalSize / 1024).toFixed(1)}KB (-${savings}%)`);
+            }
+            else {
+                // 非图片文件，直接 base64 编码
+                const mime = guessMimeType(cleanUrl);
+                dataUrl = `data:${mime};base64,${buffer.toString('base64')}`;
+                finalSize = originalSize;
+            }
+            // 更新 asset 配置
+            file.url = dataUrl;
+            file.size = finalSize;
             // data URL 不需要 hash/variants，避免引擎追加 ?t=hash 造成无效 URL
             if ('hash' in file) {
                 delete file.hash;
@@ -561,6 +612,21 @@ async function inlineConfigAssetUrls(configJson, baseBuildDir) {
             console.warn(`警告: 资源文件不存在: ${url}`);
         }
     }
+    // 输出统计信息
+    if (optimizedAssets.length > 0) {
+        console.log(`\n✅  通过 Vite 优化了 ${optimizedAssets.length} 个资源:`);
+        optimizedAssets.slice(0, 5).forEach(info => console.log(`  - ${info}`));
+        if (optimizedAssets.length > 5) {
+            console.log(`  ... 还有 ${optimizedAssets.length - 5} 个资源`);
+        }
+    }
+    if (skippedAssets.length > 0) {
+        console.log(`\n⚠️  已跳过 ${skippedAssets.length} 个大型资源文件 (>1MB):`);
+        skippedAssets.slice(0, 10).forEach(name => console.log(`  - ${name}`));
+        if (skippedAssets.length > 10) {
+            console.log(`  ... 还有 ${skippedAssets.length - 10} 个文件`);
+        }
+    }
     return configJson;
 }
 async function inlineLogoInStartScript(startCode, baseBuildDir) {
@@ -574,6 +640,80 @@ async function inlineLogoInStartScript(startCode, baseBuildDir) {
         return startCode;
     }
 }
+/**
+ * 判断是否为图片文件
+ */
+function isImageFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ['.png', '.jpg', '.jpeg', '.webp', '.gif'].includes(ext);
+}
+/**
+ * 使用 sharp 压缩图片
+ * @param buffer 原始图片 buffer
+ * @param filePath 文件路径（用于判断格式）
+ * @param options 压缩选项
+ */
+async function compressImage(buffer, filePath, options) {
+    try {
+        // 动态导入 sharp
+        const sharp = (await import('sharp')).default;
+        const ext = path.extname(filePath).toLowerCase();
+        const convertToWebP = options?.convertToWebP !== false;
+        let image = sharp(buffer);
+        // 获取元数据
+        const metadata = await image.metadata();
+        if (convertToWebP && ['.png', '.jpg', '.jpeg'].includes(ext)) {
+            // 转换为 WebP（节省 60-70% 空间）
+            const quality = options?.quality ?? 75;
+            const webpBuffer = await image
+                .webp({ quality, effort: 6 })
+                .toBuffer();
+            return {
+                buffer: webpBuffer,
+                mime: 'image/webp',
+            };
+        }
+        // 按原格式压缩
+        switch (ext) {
+            case '.png':
+                const pngBuffer = await image
+                    .png({ quality: 80, compressionLevel: 9 })
+                    .toBuffer();
+                return { buffer: pngBuffer, mime: 'image/png' };
+            case '.jpg':
+            case '.jpeg':
+                const jpgBuffer = await image
+                    .jpeg({ quality: options?.quality ?? 80, mozjpeg: true })
+                    .toBuffer();
+                return { buffer: jpgBuffer, mime: 'image/jpeg' };
+            default:
+                // 其他格式不压缩
+                return { buffer, mime: guessMimeType(filePath) };
+        }
+    }
+    catch (error) {
+        // 如果 sharp 失败，返回原始 buffer
+        console.warn(`警告: sharp 压缩失败，使用原始文件:`, error);
+        return { buffer, mime: guessMimeType(filePath) };
+    }
+}
+/**
+ * 从 Vite 返回的代码中提取 data URL
+ */
+function extractDataUrl(code) {
+    // 格式 1: export default "data:..."
+    let match = code.match(/export\s+default\s+["']([^"']*data:[^"']+)["']/);
+    if (match)
+        return match[1];
+    // 格式 2: "data:..."
+    match = code.match(/["']([^"']*data:[^"']+)["']/);
+    if (match)
+        return match[1];
+    // 格式 3: 整个代码就是 data URL
+    if (code.trim().startsWith('data:'))
+        return code.trim();
+    return null;
+}
 function guessMimeType(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {

package/dist/vite/plugin-source-builder.d.ts

@@ -2,6 +2,7 @@ import type { Plugin } from 'vite';
 export interface SourceBuilderPluginOptions {
     projectDir: string;
     outputDir: string;
+    selectedScenes?: string[];
 }
 export interface UserScript {
     id: string;

package/dist/vite/plugin-source-builder.js

@@ -15,6 +15,8 @@ export function viteSourceBuilderPlugin(options) {
     let projectFormat = null;
     let projectConfig = null;
     let userScripts = [];
+    let scriptPathMap = new Map(); // 模块路径 -> 文件系统路径
+    let fileToModuleMap = new Map(); // 文件系统路径 -> 模块路径
     return {
         name: 'vite-plugin-source-builder',
         enforce: 'pre',
@@ -35,23 +37,46 @@ export function viteSourceBuilderPlugin(options) {
             // 3. 收集用户脚本
             userScripts = await collectUserScripts(projectConfig, options.projectDir);
             console.log(`[SourceBuilder] 收集到 ${userScripts.length} 个用户脚本`);
+            // 4. 构建脚本路径映射（基于文件夹层次）
+            const mappings = buildScriptPathMapping(projectConfig, userScripts, options.projectDir);
+            scriptPathMap = mappings.moduleToFile;
+            fileToModuleMap = mappings.fileToModule;
+            console.log(`[SourceBuilder] 构建了 ${scriptPathMap.size} 个路径映射`);
         },
-        // 处理虚拟模块（用户脚本）
-        resolveId(id) {
+        // 处理虚拟入口模块和自定义导入路径
+        resolveId(id, importer) {
             if (id === 'virtual:game-scripts') {
                 return '\0virtual:game-scripts';
             }
+            // 解析自定义导入路径（如 Gameplay/GameplaySystem.mjs）
+            if (scriptPathMap.has(id)) {
+                return scriptPathMap.get(id);
+            }
+            // 处理相对导入（../xxx 或 ./xxx）
+            if (importer && (id.startsWith('./') || id.startsWith('../'))) {
+                // 获取导入者的模块路径
+                const importerModulePath = fileToModuleMap.get(importer);
+                if (importerModulePath) {
+                    // 基于模块路径解析相对导入
+                    const importerDir = path.dirname(importerModulePath);
+                    const resolvedModulePath = path.posix.join(importerDir, id);
+                    // 从模块路径映射中查找实际文件
+                    if (scriptPathMap.has(resolvedModulePath)) {
+                        return scriptPathMap.get(resolvedModulePath);
+                    }
+                }
+            }
             return null;
         },
         load(id) {
             if (id === '\0virtual:game-scripts') {
-                // 合并所有用户脚本
-                const scriptCode = userScripts.length > 0
-                    ? userScripts
-                        .map(s => wrapPlayCanvasScript(s.code, s.name, s))
-                        .join('\n\n')
-                    : '// No user scripts';
-                return scriptCode;
+                // 生成入口文件，直接导入所有真实的脚本文件
+                // 让 Vite 自然地处理这些文件及其依赖关系
+                const imports = userScripts.map(script => {
+                    const scriptPath = path.join(options.projectDir, script.path);
+                    return `import '${scriptPath}';`;
+                }).join('\n');
+                return imports || '// No user scripts';
             }
             return null;
         },
@@ -61,8 +86,10 @@ export function viteSourceBuilderPlugin(options) {
             }
             // 确保输出目录存在
             await fs.mkdir(options.outputDir, { recursive: true });
-            // 生成 config.json
-            const config = generateConfig(projectConfig);
+            // 生成 config.json（支持场景过滤）
+            const config = await generateConfig(projectConfig, {
+                selectedScenes: options.selectedScenes,
+            });
             // 为脚本资产补齐 __game-scripts.js 信息
             await patchScriptAssets(config, options.outputDir);
             await fs.writeFile(path.join(options.outputDir, 'config.json'), JSON.stringify(config, null, 2), 'utf-8');
@@ -102,6 +129,54 @@ async function detectFormat(projectDir) {
     // 默认为 PlayCanvas
     return 'playcanvas';
 }
+/**
+ * 构建脚本路径映射（基于文件夹层次结构）
+ */
+function buildScriptPathMapping(projectConfig, userScripts, projectDir) {
+    const moduleToFile = new Map();
+    const fileToModule = new Map();
+    const assets = projectConfig.format === 'playcanvas'
+        ? projectConfig.assets
+        : projectConfig.assets;
+    // 构建文件夹 ID 到名称的映射
+    const folderMap = new Map();
+    for (const [assetId, asset] of Object.entries(assets)) {
+        const assetData = asset;
+        if (assetData.type === 'folder') {
+            folderMap.set(assetId, assetData.name);
+        }
+    }
+    // 为每个脚本构建模块路径
+    for (const script of userScripts) {
+        const asset = assets[script.id];
+        if (!asset)
+            continue;
+        const pathIds = asset.path || [];
+        const pathNames = [];
+        // 跳过根文件夹（第一个元素），构建路径
+        for (let i = 1; i < pathIds.length; i++) {
+            const folderId = String(pathIds[i]);
+            const folderName = folderMap.get(folderId);
+            if (folderName) {
+                pathNames.push(folderName);
+            }
+        }
+        // 添加文件名
+        const filename = asset.name || asset.file?.filename;
+        if (filename) {
+            pathNames.push(filename);
+        }
+        const modulePath = pathNames.join('/');
+        const fullPath = path.join(projectDir, script.path);
+        // 添加双向映射
+        moduleToFile.set(modulePath, fullPath);
+        fileToModule.set(fullPath, modulePath);
+        // 同时添加不带扩展名的映射
+        const withoutExt = modulePath.replace(/\.mjs$/, '');
+        moduleToFile.set(withoutExt, fullPath);
+    }
+    return { moduleToFile, fileToModule };
+}
 /**
  * 收集用户脚本
  */
@@ -161,17 +236,6 @@ async function collectUserScripts(projectConfig, projectDir) {
     }
     return scripts;
 }
-/**
- * 包装 PlayCanvas 脚本
- */
-function wrapPlayCanvasScript(code, scriptName, script) {
-    // 清理脚本名称（移除特殊字符）
-    const cleanName = scriptName.replace(/[^a-zA-Z0-9_]/g, '_');
-    return `
-var ${cleanName} = pc.createScript('${cleanName}');
-${code}
-  `.trim();
-}
 /**
  * 复制模板文件
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/build",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -38,6 +38,7 @@
     "lightningcss": "^1.27.0",
     "mime-types": "^2.1.35",
     "rollup-plugin-visualizer": "^6.0.5",
+    "sharp": "^0.33.0",
     "terser": "^5.30.0",
     "vite": "^6.0.0",
     "vite-plugin-singlefile": "^2.0.0"