@cc-component/cc-core 1.2.8

package/assets/core/interface/MainModule.ts

@@ -0,0 +1,1019 @@
+import { Asset, assetManager, AudioClip, Canvas, CCObject, Constructor, director, find, game, instantiate, js, misc, Node, Prefab, resources, Size, tween, UITransform, v3, Vec3, view, Widget } from "cc";
+import { AudioUtil } from "../home/AudioUtil";
+import { BYTEDANCE, DEBUG, EDITOR } from "cc/env";
+import { EventManager } from "../home/EventManager";
+import { ResourceManager } from "../home/ResourceManager";
+import { ISceneParam } from "./ISceneParam";
+import { ParabolaTween } from "../home/ParabolaTween";
+import { Component } from "cc";
+import { isValid } from "cc";
+import { EnvironmentConfig, IConfig } from "../config/IConfig";
+import { LayerUI } from "../config/LayerUI";
+import { Sprite, SpriteFrame, sp } from "cc";
+import { HttpManager, HttpReturn } from "../lib/net/net/HttpManager";
+import { StorageManager } from "../home/StorageManager";
+import { TimeManager } from "../home/TimeManager";
+import { LanguageManager } from "../lib/language/Language";
+import { BundleConfigName, HttpType, IBundleConfig, IExtData, IHttpConfig, IInitConfig, IWindowParam, SystemMessage } from "../config/CommonEnum";
+import { LayerType } from "../config/LayerType";
+import { Logger } from "../lib/Logger";
+import { Main } from "electron";
+
+
+// const { keepClassName } = keepClass;
+
+// @keepClassName
+export class MainModule {
+    /**当前bundle */
+    static get bundleName(): string { return this.instance._gui.bundleName };
+    /**界面层 */
+    static get gui(): LayerUI { return this.instance._gui };
+    /**网络 */
+    static get http(): HttpManager { return this.instance._http };
+    /**存储层 */
+    static get storage(): StorageManager { return this.instance._storage };
+    /**场景参数 */
+    static get scenesParm(): ISceneParam { return this.instance._scenesParm };
+    /**时间管理 */
+    static get timeManager(): TimeManager { return this.instance._timeManager };
+    /**多语言模块 */
+    static get language(): LanguageManager {
+
+        return this.instance._language
+    };
+
+
+    _gui: LayerUI;
+    _http: HttpManager;
+    _storage: StorageManager;
+    _scenesParm: ISceneParam = {
+        param: undefined,
+        bundleName: "",
+        sceneName: "",
+    };
+    _timeManager: TimeManager;
+    /** 多语言模块 */
+    _language: LanguageManager;
+
+
+    private static instance: MainModule | null = null;
+    public static get Ins(): MainModule {
+        if (!MainModule.instance) { MainModule.instance = new MainModule(); }
+        return MainModule.instance;
+    }
+    constructor() {
+
+    }
+
+    time: number = 0
+    private openedWindows: Map<string, Component> = new Map();
+    private openedWindowsConfig: Map<string, IBundleConfig> = new Map();
+
+    private openWindowLayer: Map<string, string[]> = new Map();
+
+    static async InitGameConfig(param: IInitConfig) {
+        if (MainModule.Ins._gui) { return }
+
+        /**资源下载配置 */
+        assetManager.downloader.maxConcurrency = 10;
+        assetManager.downloader.maxRequestsPerFrame = 6;
+        assetManager.downloader.maxRetryCount = 100
+        assetManager.downloader.retryInterval = 2000
+        const self = MainModule.Ins;
+        // 存储层 
+        self._storage = new StorageManager();
+        /**时间管理器 */
+        self._timeManager = new TimeManager();
+        self._language = new LanguageManager();
+        // 加载资源配置
+        self._gui = new LayerUI();
+        self._http = new HttpManager();
+        if (!EDITOR) {
+            await self._gui.loadConfig(param);
+            const config: EnvironmentConfig = self._gui.current_config;
+            // 免网络
+            self._http.server = config.httpServer;
+            self._http.timeout = config.httpTimeout;
+        }
+        console.log("初始化完成")
+    }
+
+    static OpenLoading(is_show: boolean) {
+        if (is_show)
+            MainModule.gui.loading_call.open?.(() => { })
+        else
+            MainModule.gui.loading_call.close?.()
+        MainModule.OpenBlockEvents(LayerType.LayerBlockEventsUI, is_show)
+
+    }
+
+
+
+    //设置微信按钮的大小和位置
+    static GetWxRatio(node: Node) {
+
+        let width = node.getComponent(UITransform).contentSize.width;
+        let height = node.getComponent(UITransform).contentSize.height;
+        let windowSize = view.getVisibleSize();
+        // console.log(windowSize);
+        //  console.log("屏幕：", windowSize);
+        let leftRatio = node.worldPosition.x / windowSize.width;
+        let topRatio = 1 - (node.worldPosition.y / windowSize.height);
+
+        // let scale = 1334/windowSize.height;
+        // console.error("比例",scale,node.position.y);
+        // node.position = v3(node.position.x,node.position.y*scale)
+        // console.error("2比例",scale,node.position.y);
+
+        return { width: width, height: height, topRatio: topRatio, leftRatio: leftRatio }
+    }
+
+    //业务
+    //加载LoadResources
+    static async LoadResources(pre: Function, finish?: Function) {
+        resources.preloadDir("prefabs", (finished: number, total: number, item: any) => {
+            pre(parseInt((finished / total * 100).toFixed(1)));
+        }, () => {
+            finish && finish();
+        })
+    }
+    /**
+        * 加载资源并自动记录
+        * @param bundleName Bundle 名称
+        * @param path 资源路径
+        * @param type 资源类型
+        * @returns 加载的资源
+        */
+    public static getAsset<T extends Asset>(bundleName: string, path: string, type?: { new(): T }): T {
+        // 加载资源
+        return ResourceManager.getAsset(bundleName, path, type)
+    }
+    public static async loadAsset<T extends Asset>(
+        bundleName: string,
+        path: string,
+        type: { new(): T }
+    ): Promise<T> {
+        // 加载资源
+        return ResourceManager.loadAsset(bundleName, path, type)
+    }
+    static releaseAssetsByBundle(bundleName: string) {
+        ResourceManager.instance.releaseAssetsByBundle(bundleName);
+        // if (DEBUG) {
+        //     setTimeout(() => {
+        //         ResourceManager.instance.LogAssetsAll()
+        //     }, 1000)
+        // }
+        //ResourceManager.instance.releaseAssetsByBundle(BundleConfigName.common);//释放通用资源
+    }
+
+    static releaseAsset(bundleName: string, node: Node) {
+        ResourceManager.instance.releaseAsset(node, bundleName)
+    }
+
+    static releaseAssetPath(path: string, bundleName: string): void {
+        ResourceManager.instance.releaseAssetPath(path, bundleName)
+    }
+
+    static async preloadDir(bundleName: string, dirName: string, pre: Function) {
+        return ResourceManager.preloadDir(bundleName, dirName, pre)
+    }
+
+    static async loadDir(bundleName: string, dirName: string, type: any, pre: Function) {
+        return ResourceManager.loadDir(bundleName, dirName, type, pre)
+    }
+
+
+
+    static DeepCopy<T>(obj: T): T {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+
+        if (Array.isArray(obj)) {
+            const arrCopy = [] as any[];
+            for (const item of obj) {
+                arrCopy.push(MainModule.DeepCopy(item));
+            }
+            return arrCopy as unknown as T;
+        }
+
+        const objCopy = {} as { [key: string]: any };
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                objCopy[key] = MainModule.DeepCopy(obj[key]);
+            }
+        }
+
+        return objCopy as T;
+    }
+
+
+
+    //音乐
+    static async playOneShot(sound: AudioClip | string, volume: number = 0.5) {
+        AudioUtil.inst.playOneShot(sound, volume)
+    }
+
+    static async play(sound: AudioClip | string, volume: number = 1.0) {
+        let isMusic = MainModule.storage.getBoolean("musicButton")
+        // console.error("音乐", isMusic);
+
+        if (!isMusic) {
+            MainModule.storage.set("musicButton", false)
+        }
+        isMusic = MainModule.storage.getBoolean("musicButton")
+
+        if (isMusic) {
+            AudioUtil.inst.play(sound, volume)
+        }
+
+        //   console.error('声音---',isMusic);
+
+    }
+
+    static async stop() {
+        AudioUtil.inst.stop()
+    }
+
+    static async pause() {
+        AudioUtil.inst.pause()
+    }
+    static async resume() {
+        AudioUtil.inst.resume()
+    }
+
+    static musicVolume(volume: number) {
+        AudioUtil.inst.music_volume = volume
+    }
+    static soundVolume(volume: number) {
+        AudioUtil.inst.sound_volume = volume
+    }
+
+    static getMusicVolume() {
+        return AudioUtil.inst.music_volume
+    }
+    static getSoundVolume() {
+        return AudioUtil.inst.sound_volume
+    }
+
+    static async playJump(sound: AudioClip | string, volume: number = 1.0) {
+        AudioUtil.inst.playJump(sound, volume)
+        //   console.error('声音---',isMusic);
+    }
+
+    static async stopJump() {
+        AudioUtil.inst.stopJump()
+    }
+
+    // static async Http<T>(config: IHttpConfig, params?: any, ext?: { is_show_alert?: boolean }): Promise<HttpReturn<T>> {
+    //     return new Promise<HttpReturn<any>>(async (resolve, reject) => {
+    //         MainModule.OpenBlockEvents(LayerType.LayerBlockEventsNet, true)
+    //         console.warn(`发起${config.type === HttpType.GET ? "GET请求" : "POST请求"} url:${config.url}\n 参数：${params}`,);
+    //         let ret: HttpReturn<any>;
+    //         if (config.type == HttpType.GET) {
+    //             ret = await MainModule.http.getJson(config.url, params);
+    //         } else if (config.type == HttpType.POST) {
+    //             ret = await MainModule.http.postJson(config.url, params);
+    //         }
+    //         console.warn(`${config.type === HttpType.GET ? "GET请求" : "POST请求"} url:${config.url}\n 参数：${params}`);
+    //         console.warn(`返回结果：${ret}`);
+    //         console.warn(`返回结果：${JSON.stringify(ret.res)}`);
+    //         MainModule.OpenBlockEvents(LayerType.LayerBlockEventsNet, false)
+    //         if (ret.isSucc) {
+    //             resolve(ret.res)
+    //         }
+    //         else {
+    //             console.log(ret.err);
+    //             if (ext && ext.is_show_alert || (ext === undefined || ext.is_show_alert === undefined)) {
+    //                 const param = { des: "网络断开,请检查网络!", enterStr: "重试？", cancelStr: "取消", isDestory: false }
+    //                 const view = await CommonModule.OpenAlertWindow(param);
+    //                 view.callBack = (isOk: boolean) => {
+    //                     if (isOk) {
+    //                         MainModule.Http(config, params).then(resolve).catch(reject);
+    //                     } else {
+    //                         reject?.(ret.err)
+    //                     }
+    //                 }
+    //             } else {
+    //                 reject?.(ret.err)
+    //             }
+    //             // 
+    //         }
+    //     })
+    // }
+
+    static async Requst<T>(
+        config: IHttpConfig,
+        params?: any,
+        ext?: IExtData
+    ): Promise<HttpReturn<T>> {
+        return new Promise<HttpReturn<any>>(async (originalResolve, originalReject) => {
+            let retries = 0; // 当前重试次数
+            const maxRetries = 5; // 最大重试次数
+
+            // 内部辅助函数，用于执行请求逻辑
+            const attemptRequest = async () => {
+                try {
+                    MainModule.OpenBlockEvents(LayerType.LayerBlockEventsNet, true);
+
+                    const url = MainModule.gui.current_config.httpServer + config.url
+                    console.log(`${config.type === HttpType.GET ? "GET请求" : "POST请求"} url:${url} `, `\n 参数：`, params);
+                    let ret: HttpReturn<any>;
+                    if (config.type === HttpType.GET) {
+                        ret = await MainModule.http.getJson(config.url, params);
+                    } else if (config.type === HttpType.POST) {
+                        ret = await MainModule.http.postJson(config.url, params, ext);
+                    }
+
+                    console.log(`${config.type === HttpType.GET ? "GET请求" : "POST请求"} 结果 url:${url}\n`, ` 参数：`, params);
+                    console.log(`返回结果：`, ret.res);
+                    //console.warn(`返回结果：${JSON.stringify(ret.res)}`);
+
+                    MainModule.OpenBlockEvents(LayerType.LayerBlockEventsNet, false);
+                    if (ret.isSucc) {
+                        originalResolve(ret.res); // 请求成功，调用原始 resolve
+                    } else {
+                        throw new Error(ret.err); // 请求失败，抛出错误以触发重试逻辑
+                    }
+                } catch (error) {
+                    console.error(`请求失败: ${error.message}`);
+                    retries++;
+
+                    if (retries > maxRetries) {
+                        console.error("达到最大重试次数，请求失败");
+                        originalReject(error); // 达到最大重试次数后调用原始 reject
+                        return;
+                    }
+
+                    if (ext && ext.is_show_alert || (ext === undefined || ext.is_show_alert === undefined)) {
+
+                        const userChoice = await new Promise<boolean>((resolve) => {
+                            const finish = (isOk: boolean) => { resolve(isOk) }
+                            MainModule.http.open?.(finish)
+                            //param.callBack = (isOk: boolean) => resolve(isOk);
+                        });
+
+                        if (!userChoice) {
+                            console.log("用户取消请求");
+                            originalReject("取消了"); // 用户取消，调用原始 reject
+                            return;
+                        }
+
+
+                    }
+                    MainModule.OpenBlockEvents(LayerType.LayerBlockEventsNet, true);
+                    // 继续重试，但避免直接递归调用
+                    setTimeout(attemptRequest, 100); // 使用 setTimeout 避免栈溢出
+                }
+            };
+
+            // 开始第一次请求
+            attemptRequest();
+        });
+    }
+
+
+    //获取真实的时间挫
+    static DateNow() {
+        let time = Date.now()
+        if (MainModule.Ins.time > 0) {//客户端比服务器时间快
+            time = time - MainModule.Ins.time;
+        } else {//客户端比服务器时间慢
+            time = time + Math.abs(MainModule.Ins.time)
+        }
+        return time
+    }
+
+    static UpdateTime(old: number) {
+        MainModule.Ins.time = parseInt(old.toFixed(0));
+    }
+
+
+    static async OpenWindow<T extends Component>(config: IBundleConfig, param?: IWindowParam): Promise<T> {
+        return new Promise<T>(async (resolve, reject) => {
+            try {
+                const className = config.name ?? config.path.split('/').pop();
+                if (MainModule.IsWindowOpen(className)) {
+                    const view = MainModule.GetOpenWindow<Component>(config);
+                    resolve(view as T);
+                    //延迟100毫秒防止连点
+                    setTimeout(() => { MainModule.OpenBlockEvents(LayerType.LayerBlockEventsUI, false) }, 100);
+                    return;
+                }
+                else if (MainModule.IsWindowOpen(className)) {
+                    console.warn("重复打开窗口-请检查", config.path)
+                    return;
+                }
+                //console.error('打开:', Array.from(MainModule.Instance.openedWindows.keys()), config.path);
+                MainModule.OpenBlockEvents(LayerType.LayerBlockEventsUI, true)
+                if (!param) {
+                    param = {}
+                }
+                const call = param?.callBack;
+                const backCallback = (arg1: any, arg2: any) => {
+                    call?.(arg1, arg2)
+                }
+                if (param instanceof Object)
+                    param.callBack = backCallback;
+
+                const view = await MainModule.LoadWindow<T>(config, param);
+
+                MainModule.gui.GetLayer(config.layer).addChild(view.node);
+
+                // 添加关闭事件监听
+                MainModule.Ins.setupCloseListener(view, className);
+
+                if (config.is_load_sub) {
+                    (view as any).root.active = false;
+                    await new Promise<void>((resolve, reject) => { (view as any).finish_sub = resolve; });
+                    (view as any).root.active = true;
+                }
+
+                view.node.getComponent(Widget)?.updateAlignment();
+
+                //隐藏底层的UI
+                MainModule.instance.ShowLayerUI(config, false)
+                //收集打开的窗口
+                if (!MainModule.Ins.openWindowLayer.has(config.layer)) {
+                    MainModule.Ins.openWindowLayer.set(config.layer, []);//LayerUI层
+                }
+                const list = MainModule.Ins.openWindowLayer.get(config.layer)
+                list.push(className);
+                const layerUI_list = MainModule.Ins.openWindowLayer.get(LayerType.LayerUI)
+                if (layerUI_list && layerUI_list.length > 0) MainModule.gui.GetLayer(LayerType.LayerGame).active = false;
+                console.log('LayerType.LayerUI 打开窗口记录:', className, list);
+                MainModule.Emit(SystemMessage.OpenWindow, className)
+
+                resolve(view);
+                //延迟100毫秒防止连点
+                setTimeout(() => { MainModule.OpenBlockEvents(LayerType.LayerBlockEventsUI, false) }, 100);
+            } catch (error) {
+                console.error("打开窗口失败:", error);
+                MainModule.CloseLoading()
+                reject(error);
+            }
+        });
+    }
+    static async LoadWindow<T extends Component>(config: IBundleConfig, param?: IWindowParam): Promise<T> {
+        return new Promise<T>(async (resolve, reject) => {
+            try {
+                const className = config.name ?? config.path.split('/').pop();
+                // 记录打开的窗口--先占位
+                if (config.is_record === undefined || config.is_record) {//默认记录
+                    MainModule.Ins.openedWindows.set(className, null);
+                    MainModule.Ins.openedWindowsConfig.set(className, config);
+                }
+                //await Await(1000)
+                const prefab = await ResourceManager.loadAsset<Prefab>(config.bundle, config.path)
+                const node = instantiate(prefab);
+
+                const view = ((node.getComponent(className)) || (node.addComponent(className))) as T;
+                if (config.is_record === undefined || config.is_record) {//默认记录
+                    MainModule.Ins.openedWindows.set(className, view);
+                    MainModule.Ins.openedWindowsConfig.set(className, config);
+                }
+                //@ts-ignore
+                view.window_name = className;
+                //@ts-ignore
+                view.config = config;
+                //@ts-ignore
+                if (param) view.param = param;
+                // if (config.is_add_layer) {
+                //     MainModule.gui.GetLayer(config.layer).addChild(view.node);
+                // }
+
+                resolve(view);
+            } catch (error) {
+                console.error("加载窗口失败:", config.path, error);
+                reject(error);
+            }
+        });
+    }
+
+    static async RootWindow<T extends Component>(config: IBundleConfig, param?: IWindowParam): Promise<T> {
+        await MainModule.CloseAll([LayerType.LayerUI, LayerType.LayerDialog, LayerType.LayerPopUp])
+        //打开
+        return MainModule.OpenWindow(config)
+    }
+
+    static async CloseAll(layer_list: LayerType[]) {
+        const windows = MainModule.GetOpenedWindowNames()
+        await new Promise<void>((resolve, reject) => {
+            //销毁已有的窗口
+            const destroyPromises: Promise<void>[] = []; // 用于存储每个销毁事件的 Promise
+            windows.forEach(className => {
+                const config = MainModule.Ins.openedWindowsConfig.get(className);
+                if (layer_list.includes(config.layer)) {
+                    const view = MainModule.GetOpenWindow<any>(config);
+                    // 创建一个 Promise 来等待 NODE_DESTROYED 事件完成
+                    const destroyPromise = new Promise<void>((destroyResolve) => {
+                        if (view.node && isValid(view.node, true)) {
+                            view.node.once(Node.EventType.NODE_DESTROYED, () => {
+                                destroyResolve(); // 当前节点销毁后 resolve
+                            });
+                        } else {
+                            destroyResolve(); // 当前节点销毁后 resolve
+                        }
+                    });
+                    destroyPromises.push(destroyPromise); // 将 Promise 添加到集合中
+                    if (view && view.node && isValid(view.node, true)) {
+                        view.node.destroy(); // 关闭窗口
+                    }
+                }
+            })
+            // 等待所有销毁事件完成后再 resolve 外层 Promise
+            Promise.all(destroyPromises).then(() => resolve());
+        });
+    }
+    static OpenBlockEvents(type: LayerType, is_show: boolean) {
+        MainModule.gui.GetLayer(type).active = is_show;
+    }
+    static async CloseLoading() {
+        MainModule.OpenBlockEvents(LayerType.LayerBlockEventsUI, false)
+        MainModule.OpenBlockEvents(LayerType.LayerBlockEventsNet, false)
+    }
+
+    static async OpenScene(param: ISceneParam) {
+        MainModule.OpenBlockEvents(LayerType.LayerBlockEventsUI, true)
+        await new Promise<void>(resolve => { MainModule.gui.progess?.open?.(() => { resolve() }) })
+        //关闭所有窗口
+        await MainModule.CloseAll([LayerType.LayerUI, LayerType.LayerDialog, LayerType.LayerPopUp, LayerType.LayerGame])
+        MainModule.scenesParm.param = param
+        let scene = await ResourceManager.loadScene(param.bundleName, param.sceneName, (pro) => { });
+        if (scene) {
+            ResourceManager.runScene(scene);
+        } else {
+            param.error?.("加载场景失败");
+        }
+        MainModule.OpenBlockEvents(LayerType.LayerBlockEventsUI, false)
+    }
+
+    static LoadSprite(sp: Sprite, params: { path: string, bundle?: string, callback?: () => void }) {
+        const path = params.path + '/spriteFrame'
+        const bundleName = params ? (params.bundle ?? 'game') : "game"
+        const sprite = MainModule.getAsset<SpriteFrame>(bundleName, path, SpriteFrame)
+        if (sprite) {
+            if (isValid(sp, true)) {
+                sp.spriteFrame = sprite;
+                params?.callback?.()
+            }
+            else {
+                console.log("图片已销毁")
+            }
+            return;
+        }
+        MainModule.loadAsset(bundleName, path, SpriteFrame).then((spriteFrame) => {
+            if (sp) {
+                if (isValid(sp, true)) {
+                    sp.spriteFrame = spriteFrame;
+                    params?.callback?.()
+                }
+                else {
+                    console.log("图片已销毁")
+                }
+            }
+        })
+    }
+
+
+    static LoadSpine(spine: sp.Skeleton, params: { path: string, bundle?: string, callback?: () => void }) {
+        const path = params.path
+        const bundleName = params ? (params.bundle ?? 'game') : "game"
+        const skeletonData = MainModule.getAsset<sp.SkeletonData>(bundleName, path, sp.SkeletonData)
+        if (skeletonData) {
+            if (spine) {
+                if (isValid(spine, true)) {
+                    spine.skeletonData = skeletonData;
+                    params?.callback?.()
+                }
+            }
+            return;
+        }
+        MainModule.loadAsset(bundleName, path, sp.SkeletonData).then((skeletonData) => {
+            if (spine) {
+                if (isValid(spine, true)) {
+                    spine.skeletonData = skeletonData;
+                    params?.callback?.()
+                }
+                else {
+                    console.log("动画已销毁")
+                }
+            }
+        })
+    }
+
+
+
+    //抖音排行榜数据
+    public static UpdatePlayerRankData_tt(count: number) {
+        const isdy = MainModule.IsDouYin()
+        // console.error('抖音22==', isdy)
+
+        if (!isdy) { return }
+        // const playerLevel = MeCenter.Ins.player.playerLevel;
+        // const levelName = MeCenter.Ins.player.levelName;
+        // const levelScore = MeCenter.Ins.player.levelScore;
+        // const count = MeCenter.Ins.player.levelScore;
+
+        // const value = `【${levelName}】x${levelScore}星` + ' 大逃杀:' + count + '块'
+        const value = '【大逃杀】' + count + '块'
+
+        if (BYTEDANCE) {
+            //一个moba游戏，想要对用户的段位进行排序
+            //@ts-ignore
+            tt.setImRankData({
+                dataType: 1, //成绩为枚举类型，因为段位不是一个数字
+                value: value, //该用户段位为白银
+                priority: count, //dataType为 1，需要权重，该游戏排序为 青铜（1）、白银（2）、黄金（3）、王者（4），因此此处传2
+                extra: "extra",
+                zoneId: "default",
+                success(res) {
+                    console.log(`排行榜设置成功: ${res}`);
+                },
+                fail(res) {
+                    console.log(`排行榜设置失败: ${res.errMsg}`);
+                },
+            });
+        }
+
+    }
+
+    public static IsDouYin() {
+        if (BYTEDANCE) {
+            //@ts-ignore
+            const info = tt.getSystemInfoSync();
+            console.log('-------抖音', info.appName);
+            const appName = info.appName;
+            if (appName.toUpperCase() === "DOUYIN") {//抖音
+                // do something
+                return true
+            }
+            else if (appName.toUpperCase() === "TOUTIAO") {//今日头条
+                // do something
+            }
+            else if (appName.toUpperCase() === "TOUTIAO_PRO") {//今日头条专业版
+                // do something
+            }
+            else if (appName.toUpperCase() === 'NEWS_ARTICLE_LITE') {//今日头条极速版
+                // do something
+            }
+            else if (appName.toUpperCase() === "DOUYIN_LITE") {//抖音极速版
+                // do something
+                return true
+            }
+            else if (appName.toUpperCase() === "LIVE_STREAM") {//抖音火山版
+                // do something
+                return true
+            }
+            else if (appName.toUpperCase() === "TIKTOK") {//TikTok
+                // do something
+                return true
+            }
+            else if (appName.toUpperCase() === "MUSICALLY") {//TikTok.M
+                // do something
+                return true
+            }
+            else if (appName.toUpperCase() === "XiGua") {//西瓜视频
+                // do something
+            }
+            else if (appName.toUpperCase() === "PPX") {//皮皮虾
+                // do something
+            }
+            else if (appName.toUpperCase() === "automobile") {//懂车帝
+                // do something
+            }
+            else if (appName.toUpperCase() === "DeliverManager") {//巨量
+                // do something
+            }
+            else if (appName.toUpperCase() === "Reading") {//番茄小说
+                // do something
+            }
+            else if (appName.toUpperCase() === "xiaohe") {//小河
+                // do something
+            }
+            return false
+        }
+        return false
+
+
+    }
+
+
+    //游戏结束动画
+    static StartPlayEndAnimation(cameraNode, targetNode, callBackFinish: Function) {
+        // 获取相机节点
+        // 创建一个Tween对象，让相机沿着路径移动
+        const self = this
+        const callBack = function () {
+            cameraNode.lookAt(targetNode.worldPosition);
+        }
+
+        const list = MainModule.Ins.GetListPos(20, 30, targetNode.worldPosition)
+        let list_tw = []
+        list.forEach((pos, index) => {
+            const tw = tween(cameraNode).to(index === 0 ? 1 : (index === 19 ? 0.5 : 0.2), { worldPosition: pos }, {
+                onUpdate: () => {
+                    callBack();
+                }
+            }) // 沿着路径移动
+
+            list_tw.push(tw);
+        });
+        const ttw = tween(cameraNode)
+        list_tw.forEach(element => {
+            ttw.then(element);
+        });
+
+        ttw.call(() => {
+            callBackFinish && callBackFinish();
+        }).start()
+    }
+
+    GetListPos(objectCount: number, circleRadius: number, startPos: Vec3) {
+        let list: Vec3[] = []
+        // 生成指定数量的物体，并按照圆形排列
+        for (let i = 0; i < objectCount; i++) {
+            // 计算每个物体在圆周上的角度
+            let angle = (i / objectCount) * 2 * Math.PI;
+
+            // 计算每个物体在圆周上的位置
+            let x = startPos.x + circleRadius * Math.cos(angle);
+            let z = startPos.z + circleRadius * Math.sin(angle);
+
+            // 创建物体
+            const pos = v3(x, 15, z);
+            list.push(pos)
+        }
+        return list
+    }
+
+    //抛物线
+    //计算贝塞尔曲线坐标函数
+    static twoBezier(k3, startPos, controlPos, endPos) {
+        let twoBezier = (t: number, p1: Vec3, cp: Vec3, p2: Vec3) => {
+            let x = (1 - t) * (1 - t) * p1.x + 2 * t * (1 - t) * cp.x + t * t * p2.x;
+            let y = (1 - t) * (1 - t) * p1.y + 2 * t * (1 - t) * cp.y + t * t * p2.y;
+            return new Vec3(x, y, 0);
+        };
+
+        let result_pos = twoBezier(k3, startPos, controlPos, endPos)
+        return result_pos
+    }
+    static customEaseOutInWithSpeed(t) {
+        let speedFactor = 0.6
+        if (t < 0.5) {
+            return 0.5 * MainModule.customEaseOut(2 * t, speedFactor);
+        } else {
+            return 0.5 * MainModule.customEaseIn(2 * t - 1, speedFactor) + 0.5;
+        }
+    }
+
+    static customEaseOut(t, speedFactor) {
+        return 1 - Math.pow(1 - t, 2 * speedFactor);
+    }
+
+    static customEaseIn(t, speedFactor) {
+        return Math.pow(t, 2 * speedFactor);
+    }
+
+    //检测碰撞
+    static Collision(box1: { x1: number, y1: number, x2: number, y2: number },
+        box2: { x1: number, y1: number, x2: number, y2: number }): boolean {
+
+
+        // 碰撞检测逻辑
+        return !(box1.x2 <= box2.x1 || box1.x1 >= box2.x2 ||
+            box1.y2 <= box2.y1 || box1.y1 >= box2.y2);
+    }
+
+    //朝向
+    static CalculateAngle(pointA: Vec3, pointB: Vec3): number {
+        // const dx = pointB.x - pointA.x;
+        // const dy = pointB.y - pointA.y;
+        // return Math.atan2(dy, dx) * (180 / Math.PI);
+
+        const dx = pointB.x - pointA.x;
+        const dy = pointB.y - pointA.y;
+        let angle = Math.atan2(dy, dx)
+        angle = angle * (180 / Math.PI);
+        return angle
+    }
+
+    static LookAtTarget(self: Vec3, target: Vec3) {
+        if (target == null) { return }
+        // //计算朝向
+        let angle = MainModule.CalculateAngle(self, target);
+        //物体朝向
+        return v3(0, 0, angle);
+    }
+    /**向量的新的位置 */
+    static DirectionPosition(start: Vec3, endPos: Vec3, scalar: number) {
+        const direction = endPos.clone().subtract(start);
+        const pos = direction.normalize().multiplyScalar(scalar);
+        return pos
+    }
+
+    /**
+     * 开始抛物线缓动
+     * @param item 运动节点
+     * @param target_postion 目标位置
+     * @param update 更新 运动中回调
+     * @param offset_ratio 最高点 的偏移量
+     * @param time 动画时间
+     */
+    static RunParabolaTween(item: Node, target_postion: Vec3, update: (ratio: number) => void, param?: { offset_ratio?: number, is_random: boolean, time?: number, start_position?: Vec3 }) {
+        new ParabolaTween().RunParabolaTween(item, target_postion, update, param);
+    }
+
+    /**
+     * ================事件===================
+     */
+    static Emit(eventName: string, params: any) {
+        EventManager.ins.emit(eventName, params);
+    }
+    static On(eventName: string, callback: any, target?: any) {
+        EventManager.ins.on(eventName, callback, target);
+    }
+    static Off(eventName: string, callback?: any, target?: any) {
+        EventManager.ins.off(eventName, callback, target);
+    }
+    static OffAll(target: any) {
+        EventManager.ins.OffAll(target);
+    }
+    //#region 记录打开的窗口
+    // 关闭指定窗口
+    static CloseWindow(className: string): boolean {
+        const instance = MainModule.Ins;
+        const window = instance.openedWindows.get(className);
+        if (window) {
+            try {
+                // 调用窗口的关闭方法（如果存在）
+                if (typeof (window as any).onClose === 'function') {
+                    (window as any).onClose();
+                }
+                // 销毁节点
+                if (window.node && isValid(window.node, true)) {
+                    window.node.destroy();
+                }
+                // 清除记录
+                instance.openedWindows.delete(className);
+                instance.openedWindowsConfig.delete(className);
+                return true;
+            } catch (error) {
+                console.error(`关闭窗口 ${className} 时出错:`, error);
+                return false;
+            }
+        } else {
+            console.warn(`窗口 ${className} 未找到或未打开`);
+            return false;
+        }
+    }
+
+    // 设置窗口关闭监听
+    private setupCloseListener(view: Component, className: string) {
+        view.node["old_destroy"] = view.node.destroy
+        view.node.destroy = () => {
+            this.removeWindowRecord(className);
+            return view.node["old_destroy"]()
+        }
+        // 监听节点销毁事件
+        // view.node.once(Node.EventType.NODE_DESTROYED, () => {
+        //     this.removeWindowRecord(className);
+        // });
+    }
+
+    ShowLayerUI(config: IBundleConfig, is_show: boolean) {
+        if (config.layer === LayerType.LayerUI) {
+            const list_layer = MainModule.Ins.openWindowLayer.get(config.layer)
+            if (list_layer && list_layer.length > 0) {
+                const last_name = list_layer[list_layer.length - 1];
+                const com = this.openedWindows.get(last_name);
+                if (com && com.isValid) {
+                    com.node.active = is_show;
+                }
+            } else {
+                MainModule.gui.GetLayer(LayerType.LayerGame).active = true;
+            }
+        }
+    }
+    // 移除窗口记录
+    private removeWindowRecord(className: string) {
+        const config = MainModule.Ins.openedWindowsConfig.get(className);
+        if (config.layer === LayerType.LayerUI) {
+            const list_layer = MainModule.Ins.openWindowLayer.get(config.layer)
+            list_layer.pop();//移除最后一个
+            this.ShowLayerUI(config, true)
+            console.log('LayerType.LayerUI 移除窗口记录:', className, list_layer);
+        }
+
+        this.openedWindows.delete(className);
+        this.openedWindowsConfig.delete(className);
+        MainModule.Emit(SystemMessage.CloseWindow, className)
+    }
+
+
+    // 通过配置关闭窗口
+    static CloseWindowTarget(config: IBundleConfig): boolean {
+        const className = config.path.split('/').pop();
+        return MainModule.CloseWindow(className);
+    }
+
+    // 关闭所有窗口
+    static CloseAllWindows(): number {
+        const instance = MainModule.Ins;
+        let closedCount = 0;
+
+        // 创建副本以避免在迭代时修改Map
+        const windowsToClose = new Array(...instance.openedWindows.entries());
+
+        for (const [className, window] of windowsToClose) {
+            if (MainModule.CloseWindow(className)) {
+                closedCount++;
+            }
+        }
+
+        console.log(`共关闭 ${closedCount} 个窗口`);
+        return closedCount;
+    }
+
+    // 检查窗口是否已打开
+    static IsWindowOpen(className: string): boolean {
+        return MainModule.Ins.openedWindows.has(className);
+    }
+
+    // 获取已打开的窗口实例
+    static GetOpenWindow<T extends Component>(config: IBundleConfig): T | null {
+        const className = config.path.split('/').pop();
+        const window = MainModule.Ins.openedWindows.get(className);
+        return window ? window as T : null;
+    }
+
+    // 获取所有已打开的窗口名称
+    static GetOpenedWindowNames(): string[] {
+        return Array.from(MainModule.Ins.openedWindows.keys());
+    }
+
+    /**任务进度队列 */
+    static PromiseQueue<T>(promises: Promise<T>[], onProgress: (completed: number, total: number) => void): Promise<T[]> {
+        const total = promises.length;
+        let completed = 0;
+
+        // 包装每个 Promise，以便在完成时触发进度更新
+        const trackedPromises = promises.map(promise =>
+            promise.then(result => {
+                completed++;
+                onProgress(completed, total); // 更新进度
+                return result;
+            })
+        );
+
+        // 返回一个新的 Promise.all，确保所有任务完成后返回结果
+        return Promise.all(trackedPromises);
+    }
+    /**播放skpine动画 */
+    static PlaySpine(skeleton: sp.Skeleton, animations: { name: string, loop?: boolean, call?: (name?: string) => void, event?: (name?: string) => void }[]) {
+        MainModule.PlaySpine(skeleton, animations);
+    }
+
+    //#region 运行补丁
+    // 默认实现函数
+    static DefaultFunction(param?: any, callBack?: Function) {
+        console.warn('调用了默认方法，可能该方法未实现', param);
+        callBack?.();
+    }
+    /**
+     * 为 target 补全缺失的方法
+     * @param target 目标类/对象
+s     */
+    static RegisterModule(target: any) {
+        if (!target) { return }
+        const allKeys = Object.keys(target);
+        for (const key of allKeys) {
+            const desc = Object.getOwnPropertyDescriptor(target, key);
+            if (desc?.get || desc?.set) continue; // ✅ 正确跳过 getter/setter
+            if (!desc?.writable) continue;         // ✅ 跳过只读（防御性）
+            if (typeof target[key] !== 'function') { // ⚠️ 问题在这里！
+                target[key] = MainModule.DefaultFunction;
+            }
+        }
+    }
+
+    //#region 监听模块消息
+    static OnRequstNet(param: { open: (finish: (isOk: boolean) => void) => void }) {
+        MainModule.http.open = param.open;
+    }
+
+    static OnLoading(param: { open: (finish: () => void) => void, close: () => void }) {
+        MainModule.gui.loading_call = param;
+    }
+
+    static OnProgess(param: { open: (finish: () => void) => void, close: () => void, progess: (progress: number) => void }) {
+        MainModule.gui.progess = param;
+    }
+}
+
+window.MainModule = MainModule;
+
+
+
+