@playcraft/build 0.0.2 → 0.0.4

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,8 @@
 export interface BaseBuildOptions {
     outputDir: string;
+    selectedScenes?: string[];
+    analyze?: boolean;
+    analyzeReportPath?: string;
 }
 export interface BaseBuildOutput {
     outputDir: string;

package/dist/base-builder.js

@@ -2,6 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { build as viteBuild } from 'vite';
+import { visualizer } from 'rollup-plugin-visualizer';
 import { viteSourceBuilderPlugin } from './vite/plugin-source-builder.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -304,6 +305,11 @@ export class BaseBuilder {
                         entryFileNames: '__[name].js',
                         chunkFileNames: '__[name]-[hash].js',
                         assetFileNames: 'files/assets/[name].[ext]',
+                        format: 'iife', // 使用 IIFE 格式，避免 ES 模块的 import 语句
+                        globals: {
+                            'playcanvas': 'pc',
+                            'pc': 'pc',
+                        },
                     },
                     // 外部化 PlayCanvas Engine（不打包）
                     external: ['pc', 'playcanvas'],
@@ -316,7 +322,21 @@ export class BaseBuilder {
                 viteSourceBuilderPlugin({
                     projectDir: this.projectDir,
                     outputDir: this.options.outputDir,
+                    selectedScenes: this.options.selectedScenes,
                 }),
+                // 打包分析报告（如果启用）
+                ...(this.options.analyze ? [
+                    visualizer({
+                        filename: this.options.analyzeReportPath
+                            ? path.join(this.options.outputDir, this.options.analyzeReportPath)
+                            : path.join(this.options.outputDir, 'base-bundle-report.html'),
+                        template: 'treemap',
+                        gzipSize: true,
+                        brotliSize: true,
+                        open: false,
+                        sourcemap: false,
+                    }),
+                ] : []),
             ],
         };
         // 2. 执行 Vite 构建

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/config-builder.js

@@ -6,7 +6,6 @@ import viteImagemin from '@vheemstra/vite-plugin-imagemin';
 import imageminMozjpeg from 'imagemin-mozjpeg';
 import imageminPngquant from 'imagemin-pngquant';
 import imageminWebp from 'imagemin-webp';
-import { visualizer } from 'rollup-plugin-visualizer';
 import { PLATFORM_CONFIGS } from './platform-configs.js';
 import { vitePlayCanvasPlugin } from './plugin-playcanvas.js';
 import { vitePlatformPlugin } from './plugin-platform.js';
@@ -163,19 +162,6 @@ export class ViteConfigBuilder {
                 removeViteModuleLoader: true,
             }));
         }
-        // 6. 打包分析报告
-        if (this.options.analyze) {
-            const reportPath = this.options.analyzeReportPath
-                ? this.options.analyzeReportPath
-                : path.join(outputDir, 'bundle-report.html');
-            plugins.push(visualizer({
-                filename: reportPath,
-                template: 'treemap',
-                gzipSize: true,
-                brotliSize: true,
-                open: false,
-            }));
-        }
         return plugins.filter(Boolean);
     }
     getPlayableOptions(config) {

package/dist/vite/platform-configs.js

@@ -24,7 +24,7 @@ export const PLATFORM_CONFIGS = {
         playable: {
             patchXhrOut: true,
             inlineGameScripts: true,
-            compressEngine: true,
+            compressEngine: false, // 关闭引擎压缩，便于调试
             configJsonInline: true,
         },
     },
@@ -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,25 +23,29 @@ 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);
-                // 3. 内联 __modules__.js
+                // 2. 内联 __game-scripts.js（用户脚本）
+                if (options.inlineGameScripts) {
+                    html = await inlineGameScripts(html, options.baseBuildDir);
+                }
+                // 3. 内联并转换 __settings__.js（传递插件上下文）
+                html = await inlineAndConvertSettings(html, options.baseBuildDir, options, pluginContext);
+                // 4. 内联 __modules__.js
                 html = await inlineModulesScript(html, options.baseBuildDir);
-                // 4. 内联 __start__.js
+                // 5. 内联 __start__.js
                 html = await inlineStartScript(html, options.baseBuildDir, options);
-                // 5. 内联 __loading__.js
+                // 6. 内联 __loading__.js
                 html = await inlineLoadingScript(html, options.baseBuildDir);
-                // 6. 内联 CSS
+                // 7. 内联 CSS
                 html = await inlineCSS(html, options.baseBuildDir, options);
-                // 7. 处理 manifest.json
+                // 8. 处理 manifest.json
                 html = await inlineManifest(html, options.baseBuildDir, 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 +83,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 +103,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 +168,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 +180,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 +194,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);
@@ -369,6 +379,8 @@ async function inlineModulesScript(html, baseBuildDir) {
 }
 /**
  * 内联 __game-scripts.js
+ * 注意：脚本需要在 pc.AppBase 创建后执行，所以插入到 </body> 之前
+ * 同时包装成一个函数，在 DOMContentLoaded 后执行，确保 PlayCanvas 引擎已完全初始化
  */
 async function inlineGameScripts(html, baseBuildDir) {
     const gameScriptsPath = path.join(baseBuildDir, '__game-scripts.js');
@@ -380,13 +392,36 @@ async function inlineGameScripts(html, baseBuildDir) {
         return html;
     }
     const gameScriptsCode = await fs.readFile(gameScriptsPath, 'utf-8');
-    // 在 </head> 之前或第一个 <script> 标签之后插入游戏脚本
-    if (html.includes('</head>')) {
-        html = html.replace('</head>', `<script>${gameScriptsCode}</script>\n</head>`);
+    // 将脚本包装，确保在 pc.script 初始化后执行
+    // pc.createScript 需要 pc.script._scripts 已初始化
+    const wrappedCode = `
+<script>
+(function() {
+  // 等待 pc.script 准备好
+  function initGameScripts() {
+    if (typeof pc === 'undefined' || !pc.script) {
+      setTimeout(initGameScripts, 10);
+      return;
+    }
+    ${gameScriptsCode}
+  }
+  // 延迟执行，确保引擎初始化完成
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initGameScripts);
+  } else {
+    setTimeout(initGameScripts, 0);
+  }
+})();
+</script>`;
+    // 在 </body> 之前插入，确保在其他脚本之后执行
+    if (html.includes('</body>')) {
+        html = html.replace('</body>', `${wrappedCode}\n</body>`);
+    }
+    else if (html.includes('</html>')) {
+        html = html.replace('</html>', `${wrappedCode}\n</html>`);
     }
     else {
-        // 如果没有 </head>，在第一个 <body> 标签之后插入
-        html = html.replace('<body>', `<body>\n<script>${gameScriptsCode}</script>\n`);
+        html += wrappedCode;
     }
     return html;
 }
@@ -507,16 +542,44 @@ async function injectPhysicsLibrary(html, options) {
     if (!library) {
         return html;
     }
-    const filename = library === 'p2' ? 'p2.min.js' : 'cannon.min.js';
-    const code = await readPatchFile(filename);
-    if (!code) {
+    let scriptsToInject = [];
+    if (library === 'p2') {
+        // Inject p2.js (2D physics)
+        const p2Code = await readPatchFile('p2.min.js');
+        if (p2Code) {
+            scriptsToInject.push(`<script>${p2Code}</script>`);
+        }
+    }
+    else if (library === 'cannon') {
+        // Inject Cannon.js (3D physics) + adapter
+        // Get __dirname equivalent in ES modules
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const physicsDir = path.join(__dirname, '../../physics');
+        try {
+            // 1. Cannon.js engine
+            const cannonPath = path.join(physicsDir, 'cannon-es-bundle.js');
+            const cannonCode = await fs.readFile(cannonPath, 'utf-8');
+            scriptsToInject.push(`<script>${cannonCode}</script>`);
+            // 2. Rigidbody adapter (compatibility layer)
+            const adapterPath = path.join(physicsDir, 'cannon-rigidbody-adapter.js');
+            const adapterCode = await fs.readFile(adapterPath, 'utf-8');
+            scriptsToInject.push(`<script>${adapterCode}</script>`);
+            console.log('[PlayCanvas Plugin] Injected Cannon.js physics engine with rigidbody adapter');
+        }
+        catch (error) {
+            console.warn('[PlayCanvas Plugin] Failed to load Cannon.js files:', error);
+            return html;
+        }
+    }
+    if (scriptsToInject.length === 0) {
         return html;
     }
-    const tag = `<script>${code}</script>`;
+    const injectedScripts = scriptsToInject.join('\n');
     if (html.includes('</head>')) {
-        return html.replace('</head>', `${tag}\n</head>`);
+        return html.replace('</head>', `${injectedScripts}\n</head>`);
     }
-    return `${tag}\n${html}`;
+    return `${injectedScripts}\n${html}`;
 }
 function isAmmoModule(module) {
     const moduleName = module.moduleName?.toLowerCase() ?? '';
@@ -528,12 +591,16 @@ 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 skippedScripts = [];
+    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 +610,61 @@ async function inlineConfigAssetUrls(configJson, baseBuildDir) {
             continue;
         }
         const cleanUrl = url.split('?')[0];
+        const fileName = cleanUrl.toLowerCase();
+        // 跳过指向 __game-scripts.js 的脚本资源
+        // 这些资源已经被打包到 __game-scripts.js 中，不需要单独内联
+        // __game-scripts.js 会通过 transformIndexHtml 钩子内联到 HTML 中
+        if (cleanUrl === '__game-scripts.js' || asset.type === 'script') {
+            skippedScripts.push(asset.name || assetId);
+            continue;
+        }
+        // 跳过物理引擎缓存文件和大型文本文件
+        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 +677,31 @@ 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} 个文件`);
+        }
+    }
+    if (skippedScripts.length > 0) {
+        console.log(`\n📦 跳过了 ${skippedScripts.length} 个脚本资源（已打包到 __game-scripts.js）`);
+        if (skippedScripts.length <= 10) {
+            skippedScripts.forEach(name => console.log(`  - ${name}`));
+        }
+        else {
+            skippedScripts.slice(0, 5).forEach(name => console.log(`  - ${name}`));
+            console.log(`  ... 还有 ${skippedScripts.length - 5} 个脚本`);
+        }
+    }
     return configJson;
 }
 async function inlineLogoInStartScript(startCode, baseBuildDir) {
@@ -574,6 +715,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) {
@@ -690,11 +905,9 @@ async function buildCompressedEngineScript(engineCode) {
     const base64 = Buffer.from(compressed).toString('base64');
     // 遵循 PlayCanvas 官方 one-page.js 的实现方式
     // 参考: https://github.com/playcanvas/playcanvas-rest-api-tools/blob/main/one-page.js
-    // 1. 使用 new Buffer(base64, "base64") 解码 base64
-    // 2. 使用 Buffer.from(lz4.decompress(e)).toString() 解压并转字符串
-    // 3. 使用 innerText 设置脚本内容
-    // 4. 插入到当前脚本之前（保持执行顺序）
-    const wrapper = `!function(){var e=new Buffer("${base64}","base64"),n=Buffer.from(lz4.decompress(e)).toString(),r=document.createElement("script");r.async=!1,r.innerText=n,document.currentScript.parentNode.insertBefore(r,document.currentScript)}();`;
+    // 官方使用 new Buffer() 因为 lz4.js 提供了 Buffer polyfill
+    // 使用 textContent 而不是 innerText 以避免浏览器对内容的处理
+    const wrapper = `!function(){var e=new Buffer("${base64}","base64"),n=Buffer.from(lz4.decompress(e)).toString(),r=document.createElement("script");r.async=!1,r.textContent=n,document.currentScript.parentNode.insertBefore(r,document.currentScript)}();`;
     return `<script>${wrapper}</script>`;
 }
 async function loadLz4Module() {

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,14 +86,20 @@ 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');
             console.log('[SourceBuilder] 生成 config.json');
             // 生成 __settings__.js
-            const settings = generateSettings(projectConfig);
+            // 如果 config.scenes 中有场景，使用第一个场景的 URL
+            const firstScenePath = config.scenes && config.scenes.length > 0
+                ? config.scenes[0].url
+                : undefined;
+            const settings = generateSettings(projectConfig, firstScenePath);
             await fs.writeFile(path.join(options.outputDir, '__settings__.js'), settings, 'utf-8');
             console.log('[SourceBuilder] 生成 __settings__.js');
             // 复制模板文件
@@ -77,8 +108,8 @@ export function viteSourceBuilderPlugin(options) {
             // 复制资源文件
             await copyAssets(projectConfig, options.projectDir, options.outputDir, config.assets);
             console.log('[SourceBuilder] 复制资源文件');
-            // 生成场景文件
-            await generateSceneFiles(projectConfig, options.projectDir, options.outputDir);
+            // 生成场景文件（只生成 config 中包含的场景）
+            await generateSceneFiles(projectConfig, options.projectDir, options.outputDir, config.scenes);
             console.log('[SourceBuilder] 生成场景文件');
         },
     };
@@ -102,6 +133,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 +240,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();
-}
 /**
  * 复制模板文件
  */
@@ -211,12 +279,18 @@ async function copyAssets(projectConfig, projectDir, outputDir, assetsOverride)
     const assets = assetsOverride || (projectConfig.format === 'playcanvas'
         ? projectConfig.assets
         : projectConfig.assets);
+    // 使用 Set 去重，避免重复复制同一个文件
+    const copiedUrls = new Set();
     // 遍历 assets
     for (const [assetId, asset] of Object.entries(assets)) {
         const assetData = asset;
         if (!assetData.file?.url || assetData.file.url.startsWith('data:')) {
             continue;
         }
+        // 跳过已经复制过的 URL
+        if (copiedUrls.has(assetData.file.url)) {
+            continue;
+        }
         const sourcePath = path.join(projectDir, assetData.file.url);
         const targetPath = path.join(outputDir, assetData.file.url);
         try {
@@ -227,6 +301,8 @@ async function copyAssets(projectConfig, projectDir, outputDir, assetsOverride)
             await fs.mkdir(targetDir, { recursive: true });
             // 复制文件
             await fs.copyFile(sourcePath, targetPath);
+            // 标记为已复制
+            copiedUrls.add(assetData.file.url);
         }
         catch (error) {
             // 资源文件可能不存在（可能是内联的）
@@ -237,14 +313,23 @@ async function copyAssets(projectConfig, projectDir, outputDir, assetsOverride)
 /**
  * 生成场景文件
  */
-async function generateSceneFiles(projectConfig, projectDir, outputDir) {
+async function generateSceneFiles(projectConfig, projectDir, outputDir, selectedScenes) {
     if (projectConfig.format === 'playcanvas') {
         const pcProject = projectConfig;
         // PlayCanvas 格式：scenes.json 中已包含场景数据
         if (pcProject.scenes) {
-            const scenes = Array.isArray(pcProject.scenes)
+            let scenes = Array.isArray(pcProject.scenes)
                 ? pcProject.scenes
                 : Object.entries(pcProject.scenes).map(([id, scene]) => ({ id, ...scene }));
+            // 如果提供了 selectedScenes，只生成这些场景
+            if (selectedScenes && selectedScenes.length > 0) {
+                const selectedUrls = new Set(selectedScenes.map(s => s.url));
+                scenes = scenes.filter((scene) => {
+                    const sceneId = scene.id || scene.name || 'scene';
+                    const sceneUrl = `${sceneId}.json`;
+                    return selectedUrls.has(sceneUrl);
+                });
+            }
             for (const scene of scenes) {
                 const sceneData = scene;
                 const sceneId = sceneData.id || sceneData.name || 'scene';
@@ -257,7 +342,16 @@ async function generateSceneFiles(projectConfig, projectDir, outputDir) {
     else {
         // PlayCraft 格式：从 scenes/ 目录读取
         const pcProject = projectConfig;
-        for (const scene of pcProject.scenes) {
+        let scenes = pcProject.scenes;
+        // 如果提供了 selectedScenes，只生成这些场景
+        if (selectedScenes && selectedScenes.length > 0) {
+            const selectedNames = new Set(selectedScenes.map(s => s.name));
+            scenes = scenes.filter((scene) => {
+                const sceneName = scene.name || scene.id || 'scene';
+                return selectedNames.has(sceneName);
+            });
+        }
+        for (const scene of scenes) {
             const sceneData = scene;
             const sceneId = sceneData.id || sceneData.name || 'scene';
             const scenePath = path.join(outputDir, `${sceneId}.json`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/build",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "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"

package/templates/patches/one-page-inline-game-scripts.js

@@ -1,5 +1,13 @@
 (function () {
   pc.ScriptHandler.prototype._loadScript = function (url, callback) {
+    // 如果 URL 不是 data URL（如 __game-scripts.js），则跳过加载
+    // 因为脚本已经在 HTML 中作为 <script> 标签执行过了
+    if (!url.startsWith('data:')) {
+      // 直接调用回调，不创建新的脚本元素
+      callback(null, url, null);
+      return;
+    }
+
     var head = document.head;
     var element = document.createElement('script');
     this._cache[url] = element;