@cc-component/cc-core 1.5.4 → 1.5.6

package/assets/core/home/EffectSingleCase.ts

@@ -10,17 +10,18 @@ import { Asset } from 'cc';
 import { instantiate } from 'cc';
 
 /** 特效参数 */
-export interface IEffectParams {
+export interface IPoolParams {
     /**路径 */
     path: string;
     /**资源包名 */
-    bundle: string;
+    bundle?: string;
     /**初始空间坐标 */
     pos?: Vec3,
     /**初始世界坐标 */
     worldPos?: Vec3,
-    /** 是否播放完成后删除 */
-    isPlayFinishedRelease?: boolean,
+    // /** 是否播放完成后删除 */
+    // isPlayFinishedRelease?: boolean,
+    parent?: Node
 }
 
 /**
@@ -78,7 +79,7 @@ export class EffectSingleCase {
     }
 
     /** 池中预加载显示对象 */
-    preload(count: number, params: IEffectParams): Promise<void> {
+    preload(count: number, params: IPoolParams): Promise<void> {
         return new Promise(async (resolve, reject) => {
             let np = this.effects.get(params.path);
             if (np == null) {
@@ -103,7 +104,7 @@ export class EffectSingleCase {
      * @param parent  父节点
      * @param params  显示参数
      */
-    loadAndShow(params?: IEffectParams, parent?: Node): Promise<Node> {
+    loadAndShow(params?: IPoolParams, parent?: Node): Promise<Node> {
         return new Promise(async (resolve, reject) => {
             var np = this.effects.get(params.path);
             if (np == undefined) {
@@ -132,7 +133,7 @@ export class EffectSingleCase {
      * @param parent  父节点
      * @param params  显示参数
      */
-    show(params: IEffectParams, parent?: Node): Node {
+    show(params: IPoolParams, parent?: Node): Node {
         var np = this.effects.get(params.path);
         if (np == null) {
             np = new NodePool();
@@ -264,4 +265,40 @@ export class EffectSingleCase {
             }
         }
     }
+
+    /**获取节点 */
+    getNode(params: IPoolParams): Node {
+        var np = this.effects.get(params.path);
+        const node = np?.get() ?? null
+        this.updateNode(node, params)
+        return node
+    }
+
+    /** 加载节点对象 */
+    load(params: IPoolParams): Promise<Node> {
+        return new Promise(async (resolve, reject) => {
+            if (!params.bundle) {
+                Logger.error('请指定bundleName');
+                resolve(null)
+                return;
+            }
+            var np = this.effects.get(params.path);
+            if (np == null || np === undefined) {
+                np = new NodePool();
+                this.effects.set(params.path, np);
+            }
+            this.res.set(params.path, params.bundle);
+            const prefab = await App.LoadAsset(params.bundle, params.path, Prefab);
+            const node = instantiate(prefab)
+
+            this.updateNode(node, params)
+            resolve(node);
+        });
+    }
+
+    updateNode(node: Node, params: IPoolParams) {
+        if (node && node.isValid && params.pos) node.position = params.pos;
+        if (node && node.isValid && params.worldPos) node.worldPosition = params.worldPos;
+        if (node && node.isValid && params.parent) { params.parent.addChild(node); }
+    }
 }

package/assets/core/home/GameState.ts

@@ -0,0 +1,129 @@
+import { Component } from "cc";
+/**状态机 */
+export function GameState<T extends new (...args: any[]) => Component>(Base: T) {
+    return class extends Base {
+        private states: { action: (value?: string) => Promise<string>; name: string; state: string }[] = [];
+        private nextState: ((value?: string | PromiseLike<string>) => void) | null = null;
+        StartGame(): Promise<string> { return Promise.resolve("开始游戏"); };
+        GameOver(): Promise<string> { return Promise.resolve("游戏结束"); };
+        GameWin(): Promise<string> { return Promise.resolve("游戏胜利"); };
+        GameFail(): Promise<string> { return Promise.resolve("游戏失败"); };
+        GameClose(): Promise<string> { return Promise.resolve("关闭游戏界面"); };
+
+        protected onLoad(): void {
+            this.initStates()
+        }
+
+        /**初始化状态 */
+        public initStates() {
+            this.states = this.registerStates()
+            this.addCommonState();
+        }
+
+        /**注册状态-可重写 */
+        registerStates() {
+            return [
+                { action: this.StartGame, name: "开始游戏", state: "StartGame" },
+                { action: this.GameOver, name: "游戏结束", state: "GameOver" },
+                { action: this.GameWin, name: "游戏胜利", state: "GameWin" },
+                { action: this.GameFail, name: "游戏失败", state: "GameFail" },
+                { action: this.GameClose, name: "关闭游戏界面", state: "GameClose" },
+            ];
+        }
+
+        /**运行 */
+        public async run() {
+            this.statesLog("开始")
+            let index = 0;
+            const self = this;
+            while (index < self.states.length) {
+                const currentState = self.states[index];
+                this.statesLog(currentState.name)
+                // 执行当前状态
+                const jumpTarget = await currentState.action.call(self);
+                if (jumpTarget) {
+                    const targetIndex = this.states.findIndex(s => s.state === jumpTarget);
+                    if (targetIndex !== -1) {
+                        Logger.debug(`[状态机] 跳转到: ${jumpTarget}`);
+                        index = targetIndex; // 跳转到目标索引
+                    } else {
+                        index++; // 正常顺序执行
+                    }
+                } else {
+                    index++; // 正常顺序执行
+                }
+                this.nextState = null;
+
+            }
+            this.statesLog("结束")
+        }
+
+        statesLog(name: string) {
+            Logger.debug(`状态：${name}`);
+        }
+
+
+        /**
+         * 在指定方法之后插入新的方法
+         * @param afterMethod
+         * @param newState
+         */
+        public insertState(afterMethod: () => Promise<string>, model: { action: () => Promise<string>; name: string; state: string }, isDown: boolean = true) {
+            const index = this.states.findIndex((s) => s.action === afterMethod);
+            if (index !== -1) {
+                if (isDown) {
+                    this.states.splice(index + 1, 0, model);
+                } else {
+                    this.states.splice(index, 0, model);
+                }
+            } else {
+                console.error(`没有找到：${String(afterMethod)}`);
+            }
+        }
+
+        //#region  添加通用状态
+        private addCommonState() {
+            //插入this.openEndWindow状态后
+            //this.insertState(this.openEndWindow, { action: this.activeState, name: "活动", state: "activeState" });
+        }
+
+        activeState() {
+            return new Promise<void>((res) => {
+                res();
+                // setTimeout(() => {
+                //   res();
+                // }, 2000);
+            });
+        }
+
+        /**下一个状态
+         * @param stateName 指定的状态方法名称
+         */
+        next(stateName?: string) {
+            if (this.nextState) {
+                this.nextState(stateName);
+                this.nextState = null;
+            }
+        }
+
+        // BaseGameState.ts
+
+        /**
+         * 创建一个状态 Promise，并自动绑定 this.nextState
+         * 子类只需提供具体的执行逻辑（可选延迟）
+         */
+        public promise(
+            executor: (next: (value?: string | PromiseLike<string>) => void) => void,
+            delay: number = 0
+        ): Promise<string> {
+            return new Promise<string>((res) => {
+                this.nextState = res; // 自动绑定
+                if (delay > 0) {
+                    this.scheduleOnce(() => { executor(res); }, delay);
+                } else {
+                    executor(res);
+                }
+            });
+        }
+    }
+}

package/index.ts

@@ -10,7 +10,7 @@ export * from './assets/core/home/BaseLaunchComponent';
 export * from './assets/core/home/BaseLoading';
 export * from './assets/core/home/ProgessWindow';
 export * from './assets/core/home/BaseModuleConfig';
-export * from './assets/core/home/BaseGameState';
+export * from './assets/core/home/GameState';
 export * from './assets/core/home/EffectSingleCase';
 
 //日志

package/package.json

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

package/assets/core/home/BaseGameState.ts

@@ -1,140 +0,0 @@
-import { Component } from "cc";
-
-/**状态机 */
-export class BaseGameState extends Component {
-    private states: { action: (value?: string) => Promise<string>; name: string; state: string }[] = [];
-    nextState: ((value?: string | PromiseLike<string>) => void) | null = null;
-    private jumpTarget: string | null = null; // 新增：记录要跳转的目标状态名
-
-    StartGame(): Promise<string> { return Promise.resolve("开始游戏"); };
-    GameOver(): Promise<string> { return Promise.resolve("游戏结束"); };
-    GameWin(): Promise<string> { return Promise.resolve("游戏胜利"); };
-    GameFail(): Promise<string> { return Promise.resolve("游戏失败"); };
-    GameClose(): Promise<string> { return Promise.resolve("关闭游戏界面"); };
-
-
-    protected onLoad(): void {
-        this.states = this.registerStates()
-        this.onInit()
-
-    }
-    /**注册状态-可重写 */
-    registerStates() {
-        return [
-            { action: this.StartGame, name: "开始游戏", state: "StartGame" },
-            { action: this.GameOver, name: "游戏结束", state: "GameOver" },
-            { action: this.GameWin, name: "游戏胜利", state: "GameWin" },
-            { action: this.GameFail, name: "游戏失败", state: "GameFail" },
-            { action: this.GameClose, name: "关闭游戏界面", state: "GameClose" },
-        ];
-    }
-    onInit() {
-        this.addCommonState();
-    }
-
-    /**运行 */
-    public async run() {
-        let index = 0;
-        const self = this;
-        while (index < self.states.length) {
-            const currentState = self.states[index];
-            this.statesLog(currentState.name)
-            // 执行当前状态
-            const jumpTarget = await currentState.action.call(self);
-            if (jumpTarget) {
-                const targetIndex = this.states.findIndex(s => s.state === jumpTarget);
-                if (targetIndex !== -1) {
-                    console.log(`[状态机] 跳转到: ${jumpTarget}`);
-                    index = targetIndex; // 跳转到目标索引
-                } else {
-                    index++; // 正常顺序执行
-                }
-            } else {
-                index++; // 正常顺序执行
-            }
-        }
-    }
-
-    statesLog(name: string) {
-        console.log(`状态：${name}`);
-    }
-
-
-    /**
-     * 在指定方法之后插入新的方法
-     * @param afterMethod
-     * @param newState
-     */
-    public insertState(afterMethod: () => Promise<string>, model: { action: () => Promise<string>; name: string; state: string }, isDown: boolean = true) {
-        const index = this.states.findIndex((s) => s.action === afterMethod);
-        if (index !== -1) {
-            if (isDown) {
-                this.states.splice(index + 1, 0, model);
-            } else {
-                this.states.splice(index, 0, model);
-            }
-        } else {
-            console.error(`没有找到：${String(afterMethod)}`);
-        }
-    }
-
-    //#region  添加通用状态
-    private addCommonState() {
-        //插入this.openEndWindow状态后
-        //this.insertState(this.openEndWindow, { action: this.activeState, name: "活动", state: "activeState" });
-    }
-
-    activeState() {
-        return new Promise<void>((res) => {
-            res();
-            // setTimeout(() => {
-            //   res();
-            // }, 2000);
-        });
-    }
-
-    /**
-     * 跳转到指定状态（在下一个状态循环时生效）
-     * @param stateName 目标状态的 state 字段值（如 "GameClose"）
-     */
-    public jumpToState(stateName: string): void {
-        const target = this.states.find(s => s.state === stateName);
-        if (!target) {
-            console.error(`[状态机] 未找到状态: ${stateName}`);
-            return;
-        }
-        this.jumpTarget = stateName;
-        // 如果当前有 nextState，立即 resolve 以退出当前状态
-        if (this.nextState) {
-            this.nextState();
-            this.nextState = null;
-        }
-    }
-
-    next() {
-        if (this.nextState) {
-            this.nextState();
-            this.nextState = null;
-        }
-    }
-
-    // BaseGameState.ts
-
-    /**
-     * 创建一个状态 Promise，并自动绑定 this.nextState
-     * 子类只需提供具体的执行逻辑（可选延迟）
-     */
-    protected promise(
-        executor: (next: (value?: string | PromiseLike<string>) => void) => void,
-        delay: number = 0
-    ): Promise<string> {
-        return new Promise<string>((res) => {
-            this.nextState = res; // 自动绑定
-            if (delay > 0) {
-                this.scheduleOnce(() => { executor(res); }, delay);
-            } else {
-                executor(res);
-            }
-        });
-    }
-}