@cc-component/cc-core 1.5.0 → 1.5.1

package/assets/core/config/CommonEnum.ts

@@ -8,7 +8,9 @@ export enum SystemMessage {
     /**打开窗口 */
     OpenWindow = "OpenWindow",
     /**关闭窗口 */
-    CloseWindow = "OpenWindow"
+    CloseWindow = "OpenWindow",
+    /** 回收节点 */
+    Put = "EffectEvent_Put"
 }
 export interface IExtData {
     is_show_alert?: boolean

package/assets/core/home/BaseGameState.ts

@@ -1,129 +1,140 @@
 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("关闭游戏界面"); };
+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; // 新增：记录要跳转的目标状态名
 
-        protected onLoad(): void {
-            this.initStates()
-        }
+    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("关闭游戏界面"); };
 
-        /**初始化状态 */
-        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" },
-            ];
-        }
+    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() {
-            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++; // 正常顺序执行
-                    }
+    /**运行 */
+    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++; // 正常顺序执行
                 }
-                this.nextState = null;
-
+            } else {
+                index++; // 正常顺序执行
             }
-            this.statesLog("结束")
         }
+    }
 
-        statesLog(name: string) {
-            Logger.debug(`状态：${name}`);
-        }
+    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);
-                }
+    /**
+     * 在指定方法之后插入新的方法
+     * @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 {
-                console.error(`没有找到：${String(afterMethod)}`);
+                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" });
-        }
+    //#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);
-            });
+    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;
         }
+    }
 
-        /**下一个状态
-         * @param stateName 指定的状态方法名称
-         */
-        next(stateName?: string) {
-            if (this.nextState) {
-                this.nextState(stateName);
-                this.nextState = null;
-            }
+    next() {
+        if (this.nextState) {
+            this.nextState();
+            this.nextState = null;
         }
+    }
 
-        // BaseGameState.ts
+    // 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);
-                }
-            });
-        }
+    /**
+     * 创建一个状态 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);
+            }
+        });
     }
 }

package/assets/core/home/EffectSingleCase.ts

@@ -0,0 +1,267 @@
+/*
+ * @Author: dgflash
+ * @Date: 2021-10-12 14:00:43
+ * @LastEditors: dgflash
+ * @LastEditTime: 2023-03-06 14:40:34
+ */
+import { Animation, Node, NodePool, ParticleSystem, Prefab, sp, Vec3 } from 'cc';
+import { SystemMessage } from '../config/CommonEnum';
+import { Asset } from 'cc';
+import { instantiate } from 'cc';
+
+/** 特效参数 */
+export interface IEffectParams {
+    /**路径 */
+    path: string;
+    /**资源包名 */
+    bundle: string;
+    /**初始空间坐标 */
+    pos?: Vec3,
+    /**初始世界坐标 */
+    worldPos?: Vec3,
+    /** 是否播放完成后删除 */
+    isPlayFinishedRelease?: boolean,
+}
+
+/**
+ * 动画特效对象池管理器，加载动画后自动播放，播放完后自动回收到池中
+ * 1、支持Spine动画
+ * 2、支持Cocos Animation动画
+ * 3、支持Cocos ParticleSystem粒子动画
+ */
+export class EffectSingleCase {
+    private static _instance: EffectSingleCase;
+    static get instance(): EffectSingleCase {
+        if (this._instance == null) {
+            this._instance = new EffectSingleCase();
+        }
+        return this._instance;
+    }
+
+    private _speed: number = 1;
+    /** 全局动画播放速度 */
+    get speed(): number {
+        return this._speed;
+    }
+    set speed(value: number) {
+        this._speed = value;
+        this.effects_use.forEach((value: Boolean, key: Node) => {
+            this.setSpeed(key);
+        });
+    }
+
+    /** 对象池集合 */
+    private effects: Map<string, NodePool> = new Map();
+    /** 正在使用中的显示对象集合 */
+    private effects_use: Map<Node, boolean> = new Map();
+    /** 对象池中用到的资源 - 这里只管理本对象加载的资源，预加载资源由其它对象自己施放 */
+    private res: Map<string, string> = new Map();
+
+    constructor() {
+        // App.On(SystemMessage.Put, this.onPut, this);
+    }
+
+    // private onPut(node: Node) {
+    //     this.put(node);
+    // }
+
+    /**
+     * 获取指定资源池中对象数量
+     * @param path  预制资源路径
+     */
+    getCount(path: string): number {
+        var np = this.effects.get(path);
+        if (np) {
+            return np.size();
+        }
+        return 0;
+    }
+
+    /** 池中预加载显示对象 */
+    preload(count: number, params: IEffectParams): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            let np = this.effects.get(params.path);
+            if (np == null) {
+                np = new NodePool();
+                this.effects.set(params.path, np);
+            }
+
+            this.res.set(params.path, params.bundle);
+            await App.LoadAsset(params.bundle, params.path, Prefab);
+
+            for (let i = 0; i < count; i++) {
+                let node = instantiate(App.GetAsset(params.bundle, params.path))//ViewUtil.createPrefabNode(path, bundleName);
+                np.put(node);
+            }
+            resolve();
+        });
+    }
+
+    /**
+     * 加载资源并生成节点对象
+     * @param path    预制资源路径
+     * @param parent  父节点
+     * @param params  显示参数
+     */
+    loadAndShow(params?: IEffectParams, parent?: Node): Promise<Node> {
+        return new Promise(async (resolve, reject) => {
+            var np = this.effects.get(params.path);
+            if (np == undefined) {
+                if (params && params.bundle) {
+                    this.res.set(params.path, params.bundle);
+                    await App.LoadAsset(params.bundle, params.path, Prefab);
+                    //await resLoader.loadAsync(params.bundleName, path, Prefab);
+                }
+                // else {
+                //     this.res.set(path, resLoader.defaultBundleName);
+                //     await resLoader.loadAsync(path, Prefab);
+                // }
+                const node = this.show(params, parent);
+                resolve(node);
+            }
+            else {
+                const node = this.show(params, parent);
+                resolve(node);
+            }
+        });
+    }
+
+    /**
+     * 显示预制对象
+     * @param path    预制资源路径
+     * @param parent  父节点
+     * @param params  显示参数
+     */
+    show(params: IEffectParams, parent?: Node): Node {
+        var np = this.effects.get(params.path);
+        if (np == null) {
+            np = new NodePool();
+            this.effects.set(params.path, np);
+        }
+
+        var node: Node;
+        // 创建池中新显示对象
+        if (np.size() == 0) {
+            var bundleName = ''
+            if (params && params.bundle) bundleName = params.bundle;
+            node = instantiate(App.GetAsset(bundleName, params.path))//ViewUtil.createPrefabNode(path, bundleName);
+            // //@ts-ignore
+            // node.asset_path = path;
+            // if (params && params.isPlayFinishedRelease) {
+            //     node.addComponent(EffectFinishedRelease);
+            // }
+        }
+        // 池中获取没使用的显示对象
+        else {
+            node = np.get()!;
+        }
+
+        // 设置动画播放速度
+        this.setSpeed(node);
+
+        // 设置显示对象位置
+        if (params) {
+            if (params.pos) node.position = params.pos;
+            if (params.worldPos) node.worldPosition = params.worldPos;
+        }
+
+        // 显示到屏幕上
+        if (parent) node.parent = parent;
+
+        // 记录缓冲池中放出的节点
+        this.effects_use.set(node, true);
+
+        return node;
+    }
+
+    /**
+     * 回收对象
+     * @param name  预制对象名称
+     * @param node  节点
+     */
+    put(node: Node) {
+        //@ts-ignore
+        const name = node.asset_path.split(':').pop();
+        if (name) {
+            const np = this.effects.get(name);
+            if (np) {
+                // 回收使用的节点
+                this.effects_use.delete(node);
+
+                // 回到到池中
+                np.put(node);
+            }
+        }
+    }
+
+    /**
+     * 清除对象池数据
+     * @param path  参数为空时，清除所有对象池数据;指定名时，清楚指定数据
+     */
+    clear(path?: string) {
+        if (path) {
+            const np = this.effects.get(path);
+            if (np) np.clear();
+        }
+        else {
+            this.effects.forEach(np => {
+                np.clear();
+            });
+            this.effects.clear();
+        }
+    }
+
+    /**
+     * 释放对象池中显示对象的资源内存
+     * @param path 资源路径
+     */
+    release(path?: string) {
+        if (path) {
+            this.clear(path);
+            const bundleName = this.res.get(path);
+            App.ReleaseAssetPath(path, bundleName);
+            this.res.delete(path);
+        }
+        else {
+            // 施放池中对象内存
+            this.clear();
+
+            // 施放对象资源内存
+            this.res.forEach((bundleName: string, path: string) => {
+                App.ReleaseAssetPath(path, bundleName);
+            });
+            this.res.clear()
+        }
+    }
+
+    /** 设置动画速度 */
+    private setSpeed(node: Node) {
+        // SPINE动画
+        let spine = node.getComponent(sp.Skeleton);
+        if (spine) {
+            spine.timeScale = this.speed;
+        }
+        else {
+            // COCOS动画
+            const anims: Animation[] = node.getComponentsInChildren(Animation);
+            if (anims.length > 0) {
+                anims.forEach(animator => {
+                    let aniName = animator.defaultClip?.name;
+                    if (aniName) {
+                        let aniState = animator.getState(aniName);
+                        if (aniState) {
+                            aniState.speed = this.speed;
+                        }
+                    }
+                });
+            }
+            // 粒子动画
+            else if (ParticleSystem) {
+                const particles: ParticleSystem[] = node.getComponentsInChildren(ParticleSystem);
+                particles.forEach(particle => {
+                    particle.simulationSpeed = this.speed;
+                });
+            }
+        }
+    }
+}

package/assets/core/home/EffectSingleCase.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "bf33867e-a18c-4851-b778-6cf444c3d51d",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/ResourceManager.ts

@@ -187,7 +187,7 @@ export class ResourceManager {
      * @param bundleName Bundle 名称
      * @returns 资源的唯一键
      */
-    private getAssetKey(path: string, bundleName: string): string {
+    public getAssetKey(path: string, bundleName: string): string {
         path = path.replace("/spriteFrame", "")
         return `${bundleName}:${path}`;
     }

package/assets/core/interface/App.ts

@@ -20,6 +20,7 @@ import { ELoggerLevel } from "../lib/logger/ELoggerLevel";
 import { SkeletonAnim } from "../home/BaseSkeleton";
 import { Tools } from "../home/Tools";
 import { ecs } from "../lib/ecs/ECS";
+import { EffectSingleCase } from "../home/EffectSingleCase";
 
 export class App {
     /**当前bundle */
@@ -42,6 +43,8 @@ export class App {
     static get sound(): AudioUtil { return this.instance._sound };
     /**声音 */
     static get tools(): Tools { return this.instance._tools };
+    /**对象池 */
+    static get pool(): EffectSingleCase { return this.instance._pool }
 
     _gui: LayerUI;
     _http: HttpManager;
@@ -52,6 +55,7 @@ export class App {
     _message: EventManager;
     _sound: AudioUtil;
     _tools: Tools;
+    _pool: EffectSingleCase;
     private static instance: App | null = null;
     public static get Ins(): App {
         if (!App.instance) { App.instance = new App(); }
@@ -83,6 +87,7 @@ export class App {
         self._message = new EventManager();
         self._sound = new AudioUtil();
         self._tools = new Tools();
+        self._pool = EffectSingleCase.instance;
 
         if (EDITOR) { return }//编辑器环境，不执行下面逻辑
         Logger.setLevel(ELoggerLevel.Error);

package/assets/core/interface/Interface.ts

@@ -13,6 +13,7 @@ import { MLogger } from "../lib/logger/MLogger";
 import { EventManager } from "../home/EventManager";
 import { AudioUtil } from "../home/AudioUtil";
 import { Tools } from "../home/Tools";
+import { EffectSingleCase } from "../home/EffectSingleCase";
 
 declare global {
   /** 日志打印类 */
@@ -38,6 +39,9 @@ declare global {
     const sound: AudioUtil;
     /**工具类 */
     const tools: Tools;
+    /**对象池 */
+    const pool: EffectSingleCase
+
     /**当前所在bundle名称 */
     const bundleName: string;
     /**=====================================⚠️⚠️⚠️ 初始化必须实现的监听======================= */

package/index.ts

@@ -11,6 +11,7 @@ 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/EffectSingleCase';
 
 //日志
 export * from './assets/core/lib/ecs/ECS';

package/package.json

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