@cc-component/cc-core 1.2.8 → 1.2.9

package/assets/core/home.meta

@@ -2,7 +2,7 @@
   "ver": "1.2.0",
   "importer": "directory",
   "imported": true,
-  "uuid": "b8e0e668-5502-4e93-a3b1-3e31cdc2a6c4",
+  "uuid": "ded0ad88-c80b-4ac2-8e1c-75afc3701fc8",
   "files": [],
   "subMetas": {},
   "userData": {

package/assets/core/interface/App.ts

@@ -0,0 +1,545 @@
+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 { ELoggerLevel } from "../lib/logger/ELoggerLevel";
+import { SkeletonAnim } from "../home/BaseSkeleton";
+
+export class App {
+    /**当前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 time(): TimeManager { return this.instance._timeManager };
+    /**多语言模块 */
+    static get language(): LanguageManager { return this.instance._language };
+    /**消息 */
+    static get message(): EventManager { return this.instance._message };
+    /**声音 */
+    static get sound(): AudioUtil { return this.instance._sound };
+
+
+    _gui: LayerUI;
+    _http: HttpManager;
+    _storage: StorageManager;
+    _scenesParm: ISceneParam = { param: undefined, bundleName: "", sceneName: "", };
+    _timeManager: TimeManager;
+    _language: LanguageManager;
+    _message: EventManager;
+    _sound: AudioUtil;
+
+    private static instance: App | null = null;
+    public static get Ins(): App {
+        if (!App.instance) { App.instance = new App(); }
+        return App.instance;
+    }
+    private 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 (!EDITOR) { if (App.Ins._gui) { return } }
+        /**资源下载配置 */
+        assetManager.downloader.maxConcurrency = 10;
+        assetManager.downloader.maxRequestsPerFrame = 6;
+        assetManager.downloader.maxRetryCount = 100
+        assetManager.downloader.retryInterval = 2000
+        const self = App.Ins;
+        // 存储层 
+        self._storage = new StorageManager();
+        /**时间管理器 */
+        self._timeManager = new TimeManager();
+        self._language = new LanguageManager();
+        // 加载资源配置
+        self._gui = new LayerUI();
+        self._http = new HttpManager();
+        self._message = new EventManager();
+        self._sound = new AudioUtil();
+
+        if (EDITOR) { return }//编辑器环境，不执行下面逻辑
+        Logger.setLevel(ELoggerLevel.Error);
+        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) App.gui.loading_call.open?.(() => { })
+        else App.gui.loading_call.close?.()
+        App.OpenBlockEvents(LayerType.LayerBlockEventsUI, is_show)
+    }
+
+    /**
+        * 加载资源并自动记录
+        * @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); }
+    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 async PlayOneShot(sound: AudioClip | string, volume: number = 1) { this.sound.playOneShot(sound, volume) }
+    static async Play(sound: AudioClip | string, volume: number = 1.0) { this.sound.play(sound, volume) }
+    static async Stop() { this.sound.stop() }
+    static async Pause() { this.sound.pause() }
+    static async Resume() { this.sound.resume() }
+    static MusicVolume(volume: number) { this.sound.music_volume = volume }
+    static SoundVolume(volume: number) { this.sound.sound_volume = volume }
+    static GetMusicVolume() { return this.sound.music_volume }
+    static GetSoundVolume() { return this.sound.sound_volume }
+
+    /**
+    * ================事件===================
+    */
+    static Emit(eventName: string, params: any) { this.message.emit(eventName, params); }
+    static On(eventName: string, callback: any, target?: any) { this.message.on(eventName, callback, target); }
+    static Off(eventName: string, callback?: any, target?: any) { this.message.off(eventName, callback, target); }
+    static OffAll(target: any) { this.message.OffAll(target); }
+
+    //#region 监听模块消息
+    static OnRequstNet(param: { open: (finish: (isOk: boolean) => void) => void }) { App.http.open = param.open; }
+    static OnLoading(param: { open: (finish: () => void) => void, close: () => void }) { App.gui.loading_call = param; }
+    static OnProgess(param: { open: (finish: () => void) => void, close: () => void, progess: (progress: number) => void }) { App.gui.progess = param; }
+
+    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 {
+                    App.OpenBlockEvents(LayerType.LayerBlockEventsNet, true);
+
+                    const url = App.gui.current_config.httpServer + config.url
+                    Logger.debug(`${config.type === HttpType.GET ? "GET请求" : "POST请求"} url:${url} `, `\n 参数：`, params);
+                    let ret: HttpReturn<any>;
+                    if (config.type === HttpType.GET) {
+                        ret = await App.http.getJson(config.url, params);
+                    } else if (config.type === HttpType.POST) {
+                        ret = await App.http.postJson(config.url, params, ext);
+                    }
+
+                    Logger.debug(`${config.type === HttpType.GET ? "GET请求" : "POST请求"} 结果 url:${url}\n`, ` 参数：`, params);
+                    Logger.debug(`返回结果：`, ret.res);
+                    //Logger.warn(`返回结果：${JSON.stringify(ret.res)}`);
+
+                    App.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) }
+                            App.http.open?.(finish)
+                            //param.callBack = (isOk: boolean) => resolve(isOk);
+                        });
+
+                        if (!userChoice) {
+                            Logger.debug("用户取消请求");
+                            originalReject("取消了"); // 用户取消，调用原始 reject
+                            return;
+                        }
+                    }
+                    App.OpenBlockEvents(LayerType.LayerBlockEventsNet, true);
+                    // 继续重试，但避免直接递归调用
+                    setTimeout(attemptRequest, 100); // 使用 setTimeout 避免栈溢出
+                }
+            };
+            // 开始第一次请求
+            attemptRequest();
+        });
+    }
+
+
+    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 (App.IsWindowOpen(className)) {
+                    const view = App.GetOpenWindow<Component>(config);
+                    resolve(view as T);
+                    //延迟100毫秒防止连点
+                    setTimeout(() => { App.OpenBlockEvents(LayerType.LayerBlockEventsUI, false) }, 100);
+                    return;
+                }
+                else if (App.IsWindowOpen(className)) {
+                    Logger.warn("重复打开窗口-请检查", config.path)
+                    return;
+                }
+                //console.error('打开:', Array.from(App.Instance.openedWindows.keys()), config.path);
+                App.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 App.LoadWindow<T>(config, param);
+
+                App.gui.GetLayer(config.layer).addChild(view.node);
+
+                // 添加关闭事件监听
+                App.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
+                App.instance.ShowLayerUI(config, false)
+                //收集打开的窗口
+                if (!App.Ins.openWindowLayer.has(config.layer)) {
+                    App.Ins.openWindowLayer.set(config.layer, []);//LayerUI层
+                }
+                const list = App.Ins.openWindowLayer.get(config.layer)
+                list.push(className);
+                const layerUI_list = App.Ins.openWindowLayer.get(LayerType.LayerUI)
+                if (layerUI_list && layerUI_list.length > 0) App.gui.GetLayer(LayerType.LayerGame).active = false;
+                Logger.debug('LayerType.LayerUI 打开窗口记录:', className, list);
+                App.Emit(SystemMessage.OpenWindow, className)
+
+                resolve(view);
+                //延迟100毫秒防止连点
+                setTimeout(() => { App.OpenBlockEvents(LayerType.LayerBlockEventsUI, false) }, 100);
+            } catch (error) {
+                console.error("打开窗口失败:", error);
+                App.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) {//默认记录
+                    App.Ins.openedWindows.set(className, null);
+                    App.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) {//默认记录
+                    App.Ins.openedWindows.set(className, view);
+                    App.Ins.openedWindowsConfig.set(className, config);
+                }
+                //@ts-ignore
+                view.window_name = className;
+                //@ts-ignore
+                view.config = config;
+                //@ts-ignore
+                if (param) view.param = param;
+                resolve(view);
+            } catch (error) {
+                console.error("加载窗口失败:", config.path, error);
+                reject(error);
+            }
+        });
+    }
+
+    static async RootWindow<T extends Component>(config: IBundleConfig, param?: IWindowParam): Promise<T> {
+        await App.CloseAll([LayerType.LayerUI, LayerType.LayerDialog, LayerType.LayerPopUp])
+        return App.OpenWindow(config)
+    }
+
+    static async CloseAll(layer_list: LayerType[]) {
+        const windows = App.GetOpenedWindowNames()
+        await new Promise<void>((resolve, reject) => {
+            //销毁已有的窗口
+            const destroyPromises: Promise<void>[] = []; // 用于存储每个销毁事件的 Promise
+            windows.forEach(className => {
+                const config = App.Ins.openedWindowsConfig.get(className);
+                if (layer_list.includes(config.layer)) {
+                    const view = App.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) { App.gui.GetLayer(type).active = is_show; }
+    static async CloseLoading() {
+        App.OpenBlockEvents(LayerType.LayerBlockEventsUI, false)
+        App.OpenBlockEvents(LayerType.LayerBlockEventsNet, false)
+    }
+
+    static async OpenScene(param: ISceneParam) {
+        App.OpenBlockEvents(LayerType.LayerBlockEventsUI, true)
+        await new Promise<void>(resolve => { App.gui.progess?.open?.(() => { resolve() }) })
+        //关闭所有窗口
+        await App.CloseAll([LayerType.LayerUI, LayerType.LayerDialog, LayerType.LayerPopUp, LayerType.LayerGame])
+        App.scenesParm.param = param
+        let scene = await ResourceManager.loadScene(param.bundleName, param.sceneName, (pro) => { });
+        if (scene) {
+            ResourceManager.runScene(scene);
+        } else {
+            param.error?.("加载场景失败");
+        }
+        App.OpenBlockEvents(LayerType.LayerBlockEventsUI, false)
+    }
+
+    //#region 记录打开的窗口
+    // 关闭指定窗口
+    static CloseWindow(className: string): boolean {
+        const instance = App.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 {
+            Logger.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 = App.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 {
+                App.gui.GetLayer(LayerType.LayerGame).active = true;
+            }
+        }
+    }
+    // 移除窗口记录
+    private removeWindowRecord(className: string) {
+        const config = App.Ins.openedWindowsConfig.get(className);
+        const list_layer = App.Ins.openWindowLayer.get(config.layer)
+        list_layer.pop();//移除最后一个
+        if (config.layer === LayerType.LayerUI) {
+            this.ShowLayerUI(config, true)
+        }
+        Logger.debug('LayerType.LayerUI 移除窗口记录:', className, list_layer);
+        this.openedWindows.delete(className);
+        this.openedWindowsConfig.delete(className);
+        App.Emit(SystemMessage.CloseWindow, className)
+    }
+
+    // 通过配置关闭窗口
+    static CloseWindowTarget(config: IBundleConfig): boolean { return App.CloseWindow(config.path.split('/').pop()); }
+
+    // 关闭所有窗口
+    static CloseAllWindows(): number {
+        const instance = App.Ins;
+        let closedCount = 0;
+        // 创建副本以避免在迭代时修改Map
+        const windowsToClose = new Array(...instance.openedWindows.entries());
+        for (const [className, window] of windowsToClose) {
+            if (App.CloseWindow(className)) {
+                closedCount++;
+            }
+        }
+        Logger.debug(`共关闭 ${closedCount} 个窗口`);
+        return closedCount;
+    }
+
+    // 检查窗口是否已打开
+    static IsWindowOpen(className: string): boolean { return App.Ins.openedWindows.has(className); }
+    // 获取已打开的窗口实例
+    static GetOpenWindow<T extends Component>(config: IBundleConfig): T {
+        const className = config.path.split('/').pop();
+        const window = App.Ins.openedWindows.get(className);
+        return window ? window as T : null;
+    }
+    // 获取已打开的窗口实例
+    static GetOpenWindows<T extends Component>(): T[] { return Array.from(App.Ins.openedWindows.values()) as T[]; }
+    // 获取已打开的窗口实例
+    static GetOpenWindowsConfig(): IBundleConfig[] { return Array.from(App.Ins.openedWindowsConfig.values()); }
+    // 获取所有已打开的窗口名称
+    static GetOpenedWindowNames(): string[] { return Array.from(App.Ins.openedWindows.keys()); }
+
+
+    //#region  常用
+
+    /**播放skpine动画 */
+    static PlaySpine(skeleton: sp.Skeleton, animations: { name: string, loop?: boolean, call?: (name?: string) => void, event?: (name?: string) => void }[]) { SkeletonAnim.Play(skeleton, animations); }
+
+    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 = App.GetAsset<SpriteFrame>(bundleName, path, SpriteFrame)
+        if (sprite) {
+            if (isValid(sp, true)) {
+                sp.spriteFrame = sprite;
+                params?.callback?.()
+            }
+            else {
+                Logger.debug("图片已销毁")
+            }
+            return;
+        }
+        App.LoadAsset(bundleName, path, SpriteFrame).then((spriteFrame) => {
+            if (sp) {
+                if (isValid(sp, true)) {
+                    sp.spriteFrame = spriteFrame;
+                    params?.callback?.()
+                }
+                else {
+                    Logger.debug("图片已销毁")
+                }
+            }
+        })
+    }
+
+
+    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 = App.GetAsset<sp.SkeletonData>(bundleName, path, sp.SkeletonData)
+        if (skeletonData) {
+            if (spine) {
+                if (isValid(spine, true)) {
+                    spine.skeletonData = skeletonData;
+                    params?.callback?.()
+                }
+            }
+            return;
+        }
+        App.LoadAsset(bundleName, path, sp.SkeletonData).then((skeletonData) => {
+            if (spine) {
+                if (isValid(spine, true)) {
+                    spine.skeletonData = skeletonData;
+                    params?.callback?.()
+                }
+                else {
+                    Logger.debug("动画已销毁")
+                }
+            }
+        })
+    }
+
+    //#region 运行补丁
+    // 默认实现函数
+    static DefaultFunction(param?: any, callBack?: Function) {
+        Logger.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] = App.DefaultFunction;
+            }
+        }
+    }
+}
+
+window.App = App;
+
+
+
+

package/assets/core/interface/{MainModule.ts.meta → App.ts.meta}

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "2a625de7-3c1a-46f8-b2a9-4bcf30407cf6",
+  "uuid": "c7104320-8366-4695-aecf-60046ff3e79c",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/interface/ISceneParam.ts.meta

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "4daf387d-aef9-46f1-abed-5890401f68f2",
+  "uuid": "e7bac7b1-1bef-47e2-b2fd-2fa27b179b73",
   "files": [],
   "subMetas": {},
   "userData": {}