@cc-component/cc-core 1.8.2 → 1.8.4

package/assets/core/config/LayerUI.ts

@@ -4,12 +4,18 @@ import { EnvironmentConfig, IConfig } from './IConfig';
 import { LayerType } from './LayerType';
 import { Canvas, director } from 'cc';
 import { ResourceManager } from '../home/ResourceManager';
-import { IBundleConfig, IInitConfig } from './CommonEnum';
+import { IBundleConfig, IInitConfig, IWindowParam, SystemMessage } from './CommonEnum';
 import { ISceneParam } from '../interface/ISceneParam';
 import { BlockInputEvents } from 'cc';
 import { BaseLaunchComponent } from '../home/BaseLaunchComponent';
 import { AssetManager } from 'cc';
-import { assetManager } from 'cc';
+import { Component } from 'cc';
+import { Prefab, instantiate, isValid } from 'cc';
+import { sp } from 'cc';
+import { SkeletonAnim } from '../home/BaseSkeleton';
+import { Sprite, SpriteFrame } from 'cc';
+import { Game } from 'cc';
+import { game } from 'cc';
 
 const { ccclass, property } = _decorator;
 
@@ -20,14 +26,24 @@ export class LayerUI {
     public get current_config(): EnvironmentConfig {
         return this.config.config[this.config.type]
     }
-    /**获取指定ui层 */
-    public GetLayer(type: LayerType) { return this.ui_map.get(type); }
+
+    private openWindowLayer: Map<string, string[]> = new Map();
+    private openedWindows: Map<string, Component> = new Map();
+    private openedWindowsConfig: Map<string, IBundleConfig> = new Map();
+
+    /** 最上层的UI */
+    public topUI(layer: LayerType) { return this.getTopView(layer) }
+    /**事件阻挡遮罩 */
+    public blockEvents: Node;
+    /**事件阻挡遮罩-用户输入事件时间(秒),小于0表示立即停止屏蔽触摸事件 */
+    public set blockEventsTime(value: number) {
+        this.blockEvents.active = true
+        this.launch.scheduleOnce(() => this.blockEvents.active = false, value);
+    }
 
     /**加载转圈窗口 */
-    public loadingWindow: Node;
     public LayerWindow: Node;
 
-
     private ui_map: Map<string, Node> = new Map();
     bundleName: string = "";
 
@@ -36,22 +52,22 @@ export class LayerUI {
     window: { willOpen: (comp: IBundleConfig, param: any) => void, open: (comp: IBundleConfig) => void, willClose: (comp: IBundleConfig) => void, close: (comp: IBundleConfig) => void }
     scene: ISceneParam
     launch: BaseLaunchComponent;
+    scenesParm: ISceneParam = { param: undefined, bundleName: "", sceneName: "", };
 
     async loadConfig(params: IInitConfig) {
+        //创建常驻节点
         this.launch = await this.LoadLayerWindow(params);
         const parent = this.launch.node
         const data = await App.LoadAsset<JsonAsset>(params.bundleName, "config", JsonAsset)
         this.config = data.json as IConfig;
         App.ReleaseAssetPath('config', params.bundleName)
-        //if (App.GetDebug()) Logger.debug(this.config)
-
+        //创建UI层
         const config = this.config;
         config.gui.forEach(element => {
             const node = LayerUI.CreateNnode(element.name);
             node.parent = parent
             this.ui_map.set(element.name, node);
         });
-        this.initLog();
 
         //事件阻挡层
         [LayerType.LayerBlockEventsUI, LayerType.LayerBlockEventsNet].forEach(element => {
@@ -69,6 +85,8 @@ export class LayerUI {
         Promise.all(list).then(() => {
             this.launch.InitGame();
         });
+        // 👇 设置 FPS（例如 60 帧）
+        game.frameRate = this.current_config.frameRate;
     }
 
     public static CreateNnode(name: string) {
@@ -94,27 +112,343 @@ export class LayerUI {
         });
     }
     setBundleName(value: string) { this.bundleName = value; }
-    initLog() {
-        // const debug = this.config.debug
-        // if (debug) {
-        //     if (App.GetDebug()) Logger.debug("是debug模式");
-        // } else {
-        //     console.log("发布模式");
-        //     console.log = function () { };   // 关闭普通日志输出
-        //     console.warn = function () { };  // 关闭警告输出
-        //     //  console.error = function () { }; // 关闭错误输出
-        //     console.info = function () { }
-        // }
+    getTopView(layer: LayerType) {
+        const list = this.openWindowLayer.get(layer)
+        if (list && list.length > 0) { return this.openedWindows.get(list[list.length - 1]); }
+        else return null
     }
 
+    /**获取指定ui层 */
+    public GetLayer(type: LayerType) { return this.ui_map.get(type); }
     /**重置网络配置 */
-    ResetHttpServer(config: EnvironmentConfig) {
-        Object.assign(this.current_config, config);
+    public ResetHttpServer(config: EnvironmentConfig) { Object.assign(this.current_config, config); }
+
+
+
+    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();
+                config.name = className;
+                if (this.IsWindowOpen(className)) {
+                    const view = this.GetOpenWindow<Component>(config);
+                    resolve(view as T);
+                    //延迟100毫秒防止连点
+                    setTimeout(() => { this.OpenBlockEvents(LayerType.LayerBlockEventsUI, false) }, 100);
+                    return;
+                }
+                else if (this.IsWindowOpen(className)) {
+                    Logger.warn("重复打开窗口-请检查", config.path)
+                    return;
+                }
+                if (!param) { param = {} }
+                this.window?.willOpen?.(config, param)
+                this.OpenBlockEvents(LayerType.LayerBlockEventsUI, true)
+
+                const view = await this.LoadWindow<T>(config, param);
+
+                this.GetLayer(config.layer).addChild(view.node);
+
+                // 添加关闭事件监听
+                this.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
+                this.ShowLayerUI(config, false)
+                //收集打开的窗口
+                if (!this.openWindowLayer.has(config.layer)) {
+                    this.openWindowLayer.set(config.layer, []);//LayerUI层
+                }
+                const list = this.openWindowLayer.get(config.layer)
+                list.push(className);
+                const layerUI_list = this.openWindowLayer.get(LayerType.LayerUI)
+                if (layerUI_list && layerUI_list.length > 0) this.GetLayer(LayerType.LayerGame).active = false;
+                if (App.GetDebug()) Logger.debug('LayerType.LayerUI 打开窗口记录:', className, list);
+                App.Emit(SystemMessage.OpenWindow, className)
+                this.window?.open?.(config)
+
+                resolve(view);
+                //延迟100毫秒防止连点
+                setTimeout(() => { this.OpenBlockEvents(LayerType.LayerBlockEventsUI, false) }, 100);
+            } catch (error) {
+                console.error("打开窗口失败:", error);
+                this.CloseLoading()
+                reject(error);
+            }
+        });
     }
 
+    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();
+                //@ts-ignore
+                config.name = className;
+                // 记录打开的窗口--先占位
+                if (config.is_record === undefined || config.is_record) {//默认记录
+                    this.openedWindows.set(className, null);
+                    this.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) {//默认记录
+                    this.openedWindows.set(className, view);
+                    this.openedWindowsConfig.set(className, config);
+                }
+                //@ts-ignore
+                view.config = config;
+                //@ts-ignore
+                if (param) view.param = param;
 
+                resolve(view);
+            } catch (error) {
+                console.error("加载窗口失败:", config.path, error);
+                reject(error);
+            }
+        });
+    }
 
+    async RootWindow<T extends Component>(config: IBundleConfig, param?: IWindowParam): Promise<T> {
+        await this.CloseAll([LayerType.LayerUI, LayerType.LayerDialog, LayerType.LayerPopUp])
+        return this.OpenWindow(config)
+    }
 
+    async CloseAll(layer_list: LayerType[]) {
+        const windows = this.GetOpenedWindowNames()
+        await new Promise<void>((resolve, reject) => {
+            //销毁已有的窗口
+            const destroyPromises: Promise<void>[] = []; // 用于存储每个销毁事件的 Promise
+            windows.forEach(className => {
+                const config = this.openedWindowsConfig.get(className);
+                if (layer_list.includes(config.layer)) {
+                    const view = this.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)) {
+                        /**关闭事件-当系统级关闭所有打开的界面时。如果关闭界面时需要执行自己的业务逻辑,使用此属性
+                         * eventName：关闭方法名称
+                         * param：参数
+                        */
+                        const closeEvent: { eventName: string, param?: any } = view.closeEvent?.()
+                        if (closeEvent) {
+                            const close: Function = view[closeEvent.eventName]
+                            if (close) { close.call(view, closeEvent.param) }
+                        }
+                        if (view && view.node && view.node.isValid) view.node.destroy(); // 关闭窗口
+                    }
+                }
+            })
+            // 等待所有销毁事件完成后再 resolve 外层 Promise
+            Promise.all(destroyPromises).then(() => resolve());
+        });
+    }
+    OpenBlockEvents(type: LayerType, is_show: boolean) { this.GetLayer(type).active = is_show; }
+    async CloseLoading() {
+        this.OpenBlockEvents(LayerType.LayerBlockEventsUI, false)
+        this.OpenBlockEvents(LayerType.LayerBlockEventsNet, false)
+    }
+
+
+    //#region 记录打开的窗口
+    // 关闭指定窗口
+    CloseWindow(className: string): boolean {
+        const instance = this
+        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) {
+        const config = this.openedWindowsConfig.get(className);
+        const old_destroy = view.node.destroy
+        view.node.destroy = () => {
+            this.removeWindowRecord(className);
+            return old_destroy.call(view.node)
+        }
+        // 监听节点销毁事件
+        // view.node.once(Node.EventType.NODE_DESTROYED, () => {
+        //     this.removeWindowRecord(className);
+        // });
+    }
+
+    ShowLayerUI(config: IBundleConfig, is_show: boolean) {
+        if (config.layer === LayerType.LayerUI) {
+            const list_layer = this.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 {
+                this.GetLayer(LayerType.LayerGame).active = true;
+            }
+        }
+    }
+    // 移除窗口记录
+    private removeWindowRecord(className: string) {
+        const config = this.openedWindowsConfig.get(className);
+        const list_layer = this.openWindowLayer.get(config.layer)
+        list_layer.pop();//移除最后一个
+        if (config.layer === LayerType.LayerUI) {
+            this.ShowLayerUI(config, true)
+        }
+        if (App.GetDebug()) Logger.debug('LayerType.LayerUI 移除窗口记录:', className, list_layer);
+        this.openedWindows.delete(className);
+        this.openedWindowsConfig.delete(className);
+        App.Emit(SystemMessage.CloseWindow, className)
+        this.window?.close?.(config)
+    }
+
+    // 通过配置关闭窗口
+    CloseWindowTarget(config: IBundleConfig): boolean { return this.CloseWindow(config.name ?? config.path.split('/').pop()!); }
+
+    // 关闭所有窗口
+    CloseAllWindows(): number {
+        const instance = this;
+        let closedCount = 0;
+        // 创建副本以避免在迭代时修改Map
+        const windowsToClose = new Array(...this.openedWindows.entries());
+        for (const [className, window] of windowsToClose) {
+            if (this.CloseWindow(className)) {
+                closedCount++;
+            }
+        }
+        if (App.GetDebug()) Logger.debug(`共关闭 ${closedCount} 个窗口`);
+        return closedCount;
+    }
+
+    // 检查窗口是否已打开
+    IsWindowOpen(className: string): boolean { return this.openedWindows.has(className); }
+    // 获取已打开的窗口实例
+    GetOpenWindow<T extends Component>(config: IBundleConfig): T {
+        const className = config.name ?? config.path.split('/').pop();
+        const window = this.openedWindows.get(className);
+        return window ? window as T : null;
+    }
+    // 获取已打开的窗口实例
+    GetOpenWindows<T extends Component>(): T[] { return Array.from(this.openedWindows.values()) as T[]; }
+    // 获取已打开的窗口实例
+    GetOpenWindowsConfig(): IBundleConfig[] { return Array.from(this.openedWindowsConfig.values()); }
+    // 获取所有已打开的窗口名称
+    GetOpenedWindowNames(): string[] { return Array.from(this.openedWindows.keys()); }
+    OpenLoading(is_show: boolean) {
+        if (is_show) this.loading_call.open?.(() => { })
+        else this.loading_call.close?.()
+        this.OpenBlockEvents(LayerType.LayerBlockEventsUI, is_show)
+    }
+
+    /**播放skpine动画 */
+    PlaySpine(skeleton: sp.Skeleton, animations: { name: string, loop?: boolean, call?: (name?: string) => void, event?: (name?: string) => void }[]) { SkeletonAnim.Play(skeleton, animations); }
+
+    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 {
+                if (App.GetDebug()) Logger.debug("图片已销毁")
+            }
+            return;
+        }
+        App.LoadAsset(bundleName, path, SpriteFrame).then((spriteFrame) => {
+            if (sp) {
+                if (isValid(sp, true)) {
+                    sp.spriteFrame = spriteFrame;
+                    params?.callback?.()
+                }
+                else {
+                    if (App.GetDebug()) Logger.debug("图片已销毁")
+                }
+            }
+        })
+    }
+
+
+    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 {
+                    if (App.GetDebug()) Logger.debug("动画已销毁")
+                }
+            }
+        })
+    }
+
+    async OpenScene(param: ISceneParam) {
+        this.scenesParm = param;
+        this.OpenBlockEvents(LayerType.LayerBlockEventsUI, true)
+        await new Promise<void>(resolve => { this.progess?.open?.(param, () => { resolve() }) })
+        //关闭所有窗口
+        await this.CloseAll([LayerType.LayerUI, LayerType.LayerDialog, LayerType.LayerPopUp, LayerType.LayerGame])
+        let scene = await ResourceManager.loadScene(param.bundleName, param.sceneName, (pro) => { });
+        if (scene) {
+            ResourceManager.runScene(scene);
+        } else {
+            param.error?.("加载场景失败");
+        }
+        this.OpenBlockEvents(LayerType.LayerBlockEventsUI, false)
+    }
 }
 
 

package/assets/core/home/EffectSingleCase.ts

@@ -267,7 +267,7 @@ export class EffectSingleCase {
         }
     }
 
-    /**获取节点 */
+    /**获取节点-同步 */
     getNode(params: IPoolParams): Node {
         const name = params.path.split(':').pop();
         var np = this.effects.get(name);
@@ -276,6 +276,19 @@ export class EffectSingleCase {
         return node
     }
 
+    /**获取节点-异步 */
+    async loadNode(params: IPoolParams): Promise<Node> {
+        let node = this.getNode(params)
+        if (!node || (node && !node.isValid)) {
+            if ((node && !node.isValid)) {
+                Logger.debug('节点已销毁,请检测业务逻辑。节点没有进行回收就销毁了界面', params.path)
+            }
+            node = await App.pool.load(params)
+        }
+        this.updateNode(node, params)
+        return node
+    }
+
     /** 加载节点对象 */
     load(params: IPoolParams): Promise<Node> {
         return new Promise(async (resolve, reject) => {

package/assets/core/interface/App.ts

@@ -32,7 +32,7 @@ export class App {
     /**存储层 */
     static get storage(): StorageManager { return this.instance._storage };
     /**场景参数 */
-    static get scenesParm(): ISceneParam { return this.instance._scenesParm };
+    static get scenesParm(): ISceneParam { return this.instance._gui.scenesParm };
     /**时间管理 */
     static get time(): TimeManager { return this.instance._timeManager };
     /**多语言模块 */
@@ -69,9 +69,7 @@ export class App {
 
     time: number = 0
     isDebug = false;
-    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 } }
@@ -105,12 +103,6 @@ export class App {
         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 名称
@@ -139,395 +131,39 @@ export class App {
     static OnLoading(param: { open: (finish: () => void) => void, close: () => void }) { App.gui.loading_call = param; }
     static OnProgess(param: { open: (param: ISceneParam, finish: () => void) => void, close: (param: ISceneParam) => void, progess: (param: ISceneParam, progress: number, time?: number) => void }) { App.gui.progess = param; }
     static OnWindow(param: { willOpen: (comp: IBundleConfig) => void, open: (comp: IBundleConfig) => void, willClose: (comp: IBundleConfig) => void, close: (comp: IBundleConfig) => void }) { App.gui.window = param; }
-    static async Requst<T>(config: IHttpConfig, params?: any, ext?: IExtData): Promise<{ code: number, data: T, msg: string }> {
-        return new Promise<{ code: number, data: T, msg: string }>(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
-                    if (App.GetDebug()) 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);
-                    }
-
-                    if (App.GetDebug()) Logger.debug(`${config.type === HttpType.GET ? "GET请求" : "POST请求"} 结果 url:${url}\n`, ` 参数：`, params);
-                    if (App.GetDebug()) 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.param?.open?.(finish)
-                            //param.callBack = (isOk: boolean) => resolve(isOk);
-                        });
-
-                        if (!userChoice) {
-                            if (App.GetDebug()) Logger.debug("用户取消请求");
-                            originalReject("取消了"); // 用户取消，调用原始 reject
-                            return;
-                        }
-                    }
-                    App.OpenBlockEvents(LayerType.LayerBlockEventsNet, true);
-                    // 继续重试，但避免直接递归调用
-                    setTimeout(attemptRequest, 100); // 使用 setTimeout 避免栈溢出
-                }
-            };
-            // 开始第一次请求
-            attemptRequest();
-        });
-    }
+    static async Requst<T>(config: IHttpConfig, params?: any, ext?: IExtData): Promise<{ code: number, data: T, msg: string }> { return App.http.Requst<T>(config, params, ext); }
     /**重置网络配置 */
     static ResetHttpServer(config: EnvironmentConfig) { App.instance._gui.ResetHttpServer(config); }
 
-
-    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();
-                config.name = className;
-                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;
-                }
-                if (!param) { param = {} }
-                App.gui.window?.willOpen?.(config, param)
-                //console.error('打开:', Array.from(App.Instance.openedWindows.keys()), config.path);
-                App.OpenBlockEvents(LayerType.LayerBlockEventsUI, true)
-
-                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;
-                if (App.GetDebug()) Logger.debug('LayerType.LayerUI 打开窗口记录:', className, list);
-                App.Emit(SystemMessage.OpenWindow, className)
-                App.gui.window?.open?.(config)
-
-                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();
-                //@ts-ignore
-                config.name = className;
-                // 记录打开的窗口--先占位
-                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.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)) {
-                        /**关闭事件-当系统级关闭所有打开的界面时。如果关闭界面时需要执行自己的业务逻辑,使用此属性
-                         * eventName：关闭方法名称
-                         * param：参数
-                        */
-                        const closeEvent: { eventName: string, param?: any } = view.closeEvent?.()
-                        if (closeEvent) {
-                            const close: Function = view[closeEvent.eventName]
-                            if (close) { close.call(view, closeEvent.param) }
-                        }
-                        if (view && view.node && view.node.isValid) 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?.(param, () => { resolve() }) })
-        //关闭所有窗口
-        await App.CloseAll([LayerType.LayerUI, LayerType.LayerDialog, LayerType.LayerPopUp, LayerType.LayerGame])
-        App.Ins._scenesParm = 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) {
-        const config = App.Ins.openedWindowsConfig.get(className);
-        const old_destroy = view.node.destroy
-        view.node.destroy = () => {
-            this.removeWindowRecord(className);
-            return old_destroy.call(view.node)
-        }
-        // 监听节点销毁事件
-        // 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)
-        }
-        if (App.GetDebug()) Logger.debug('LayerType.LayerUI 移除窗口记录:', className, list_layer);
-        this.openedWindows.delete(className);
-        this.openedWindowsConfig.delete(className);
-        App.Emit(SystemMessage.CloseWindow, className)
-        App.gui.window?.close?.(config)
-    }
-
-    // 通过配置关闭窗口
-    static CloseWindowTarget(config: IBundleConfig): boolean { return App.CloseWindow(config.name ?? 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++;
-            }
-        }
-        if (App.GetDebug()) 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.name ?? 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  常用
     static Debug(isDebug: boolean) { this.instance.isDebug = isDebug }
     static GetDebug() { return this.instance.isDebug }
+    /**打开场景 */
+    static async OpenScene(param: ISceneParam) { await this.gui.OpenScene(param); }
     /**播放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 {
-                if (App.GetDebug()) Logger.debug("图片已销毁")
-            }
-            return;
-        }
-        App.LoadAsset(bundleName, path, SpriteFrame).then((spriteFrame) => {
-            if (sp) {
-                if (isValid(sp, true)) {
-                    sp.spriteFrame = spriteFrame;
-                    params?.callback?.()
-                }
-                else {
-                    if (App.GetDebug()) 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 {
-                    if (App.GetDebug()) Logger.debug("动画已销毁")
-                }
-            }
-        })
-    }
-
+    static LoadSprite(sp: Sprite, params: { path: string, bundle?: string, callback?: () => void }) { App.gui.LoadSprite(sp, params) }
+    static LoadSpine(spine: sp.Skeleton, params: { path: string, bundle?: string, callback?: () => void }) { App.gui.LoadSpine(spine, params) }
+    /**打开遮罩 */
+    static OpenBlockEvents(type: LayerType, is_show: boolean) { App.gui.OpenBlockEvents(type, is_show) }
+    /**加载窗口 */
+    static LoadWindow<T extends Component>(config: IBundleConfig, param?: IWindowParam): Promise<T> { return App.gui.LoadWindow(config, param) }
+    /**打开窗口 */
+    static OpenWindow<T extends Component>(config: IBundleConfig, param?: IWindowParam): Promise<T> { return App.gui.OpenWindow(config, param) }
+    /**打开窗口--根窗口  备注移除层： LayerType.LayerUI, LayerType.LayerDialog, LayerType.LayerPopUp 里的窗口*/
+    static RootWindow<T extends Component>(config: IBundleConfig, param?: IWindowParam): Promise<T> { return App.gui.RootWindow(config, param) }
+    /**通过配置关闭窗口*/
+    static CloseWindowTarget(config: IBundleConfig): boolean { return App.gui.CloseWindowTarget(config) }
+    /**获取所有已打开的窗口名称 */
+    static GetOpenedWindowNames(): string[] { return App.gui.GetOpenedWindowNames() }
+    /**获取已打开的窗口实例*/
+    static GetOpenWindow<T extends Component>(config: IBundleConfig): T { return App.gui.GetOpenWindow(config) }
+    // 获取已打开的窗口实例-对象
+    static GetOpenWindows<T extends Component>(): T[] { return App.gui.GetOpenWindows<T>() }
+    // 获取已打开的窗口实例-配置
+    static GetOpenWindowsConfig(): IBundleConfig[] { return App.gui.GetOpenWindowsConfig() }
+    /** 显示加载转圈*/
+    static OpenLoading(is_show: boolean) { App.gui.OpenLoading(is_show) }
     //#region 运行补丁
     // 默认实现函数
     static DefaultFunction(param?: any, callBack?: Function) {
@@ -552,6 +188,8 @@ s     */
     }
 
     static PromiseQueue<T>(promises: Promise<T>[], onProgress: (completed: number, total: number) => void): Promise<T[]> { return App.Ins._tools.PromiseQueue(promises, onProgress) }
+
+
 }
 
 window.App = App;

package/assets/core/interface/Interface.ts

@@ -114,10 +114,6 @@ declare global {
     function CloseWindowTarget(config: { path: string; bundle: string }): boolean;
     /**为 target 补全缺失的方法 */
     function RegisterModule(target: any)
-    /**✅✅✅监听窗口的打开 */
-    //App.On(SystemMessage.OpenWindow)
-    /**✅✅✅监听窗口的关闭 */
-    //App.On(SystemMessage.CloseWindow)
     /**获取所有已打开的窗口名称 */
     function GetOpenedWindowNames(): string[]
     /**获取已打开的窗口实例*/
@@ -132,8 +128,6 @@ declare global {
     /**开启打印日志 */
     function Debug(isDebug: boolean);
     function GetDebug(): boolean;
-
-
     /**=======================================✅✅常用工具======================= */
     // function TwoBezier(param1, param2, param3, param4);
     // function CustomEaseOutInWithSpeed(param)

package/assets/core/lib/net/net/HttpManager.ts

@@ -5,7 +5,7 @@
  * @LastEditTime: 2022-09-09 18:10:50
  */
 
-import { IExtData } from "db://assets/cc-core";
+import { HttpType, IExtData, IHttpConfig, LayerType } from "db://assets/cc-core";
 
 
 /** HTTP请求返回值 */
@@ -304,4 +304,70 @@ export class HttpManager {
         }
         return result.substring(0, result.length - 1);
     }
+
+
+
+    /**扩展请求 */
+    async Requst<T>(config: IHttpConfig, params?: any, ext?: IExtData): Promise<{ code: number, data: T, msg: string }> {
+        return new Promise<{ code: number, data: T, msg: string }>(async (originalResolve, originalReject) => {
+            let retries = 0; // 当前重试次数
+            const maxRetries = 5; // 最大重试次数
+            // 内部辅助函数，用于执行请求逻辑
+            const attemptRequest = async () => {
+                try {
+                    App.gui.OpenBlockEvents(LayerType.LayerBlockEventsNet, true);
+
+                    const url = App.gui.current_config.httpServer + config.url
+                    if (App.GetDebug()) 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);
+                    }
+
+                    if (App.GetDebug()) Logger.debug(`${config.type === HttpType.GET ? "GET请求" : "POST请求"} 结果 url:${url}\n`, ` 参数：`, params);
+                    if (App.GetDebug()) Logger.debug(`返回结果：`, ret.res);
+                    //Logger.warn(`返回结果：${JSON.stringify(ret.res)}`);
+
+                    App.gui.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.param?.open?.(finish)
+                            //param.callBack = (isOk: boolean) => resolve(isOk);
+                        });
+
+                        if (!userChoice) {
+                            if (App.GetDebug()) Logger.debug("用户取消请求");
+                            originalReject("取消了"); // 用户取消，调用原始 reject
+                            return;
+                        }
+                    }
+                    App.gui.OpenBlockEvents(LayerType.LayerBlockEventsNet, true);
+                    // 继续重试，但避免直接递归调用
+                    setTimeout(attemptRequest, 100); // 使用 setTimeout 避免栈溢出
+                }
+            };
+            // 开始第一次请求
+            attemptRequest();
+        });
+    }
+
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cc-component/cc-core",
-    "version": "1.8.2",
+    "version": "1.8.4",
     "engine": ">=3.8.6",
     "description": "系统组件添加常用扩展方法",
     "main": "index.ts",