@cc-component/cc-core 1.2.9 → 1.3.1

package/assets/core/lib/ecs/ECSModel.ts

@@ -0,0 +1,82 @@
+/*
+ * @Author: dgflash
+ * @Date: 2022-05-12 14:18:44
+ * @LastEditors: dgflash
+ * @LastEditTime: 2022-09-05 16:37:10
+ */
+import { ecs } from "./ECS";
+import { ECSEntity } from "./ECSEntity";
+import { ECSGroup } from "./ECSGroup";
+
+type CompAddOrRemove = (entity: ecs.Entity) => void;
+
+/** 组件类型 */
+export type CompType<T> = CompCtor<T> | number;
+
+/** 实体构造器接口 */
+export interface EntityCtor<T> {
+    new(): T;
+}
+
+/** 组件构造器接口 */
+export interface CompCtor<T> {
+    new(): T;
+    /** 组件编号 */
+    tid: number;
+    /** 组件名 */
+    compName: string;
+}
+
+/** ECS框架内部数据 */
+export class ECSModel {
+    /** 实体自增id */
+    static eid = 1;
+    /** 实体造函数 */
+    static entityCtors: Map<EntityCtor<any>, string> = new Map();
+    /** 实体对象缓存池 */
+    static entityPool: Map<string, ECSEntity[]> = new Map();
+    /** 通过实体id查找实体对象 */
+    static eid2Entity: Map<number, ECSEntity> = new Map();
+
+    /** 组件类型id */
+    static compTid = 0;
+    /** 组件缓存池 */
+    static compPools: Map<number, ecs.IComp[]> = new Map();
+    /** 组件构造函数，用于ecs.register注册时，记录不同类型的组件 */
+    static compCtors: (CompCtor<any> | number)[] = [];
+    /**
+     * 每个组件的添加和删除的动作都要派送到“关心”它们的group上。goup对当前拥有或者之前（删除前）拥有该组件的实体进行组件规则判断。判断该实体是否满足group
+     * 所期望的组件组合。
+     */
+    static compAddOrRemove: Map<number, CompAddOrRemove[]> = new Map();
+
+    /** 编号获取组件 */
+    static tid2comp: Map<number, ecs.IComp> = new Map();
+
+    /**
+     * 缓存的group
+     * 
+     * key是组件的筛选规则，一个筛选规则对应一个group
+     */
+    static groups: Map<number, ECSGroup> = new Map();
+
+    /**
+     * 创建group，每个group只关心对应组件的添加和删除
+     * @param matcher 实体筛选器
+     */
+    static createGroup<E extends ECSEntity = ECSEntity>(matcher: ecs.IMatcher): ECSGroup<E> {
+        let group = ECSModel.groups.get(matcher.mid);
+        if (!group) {
+            group = new ECSGroup(matcher);
+            ECSModel.groups.set(matcher.mid, group);
+            let careComponentTypeIds = matcher.indices;
+            for (let i = 0; i < careComponentTypeIds.length; i++) {
+                ECSModel.compAddOrRemove.get(careComponentTypeIds[i])!.push(group.onComponentAddOrRemove.bind(group));
+            }
+        }
+        return group as unknown as ECSGroup<E>;
+    }
+
+    /** 系统组件 */
+    static systems: Map<string, ecs.System> = new Map<string, ecs.System>();
+}

package/assets/core/lib/ecs/ECSModel.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "1d60e80c-eabf-46b5-ae0e-a7754005218c",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/lib/ecs/ECSSystem.ts

@@ -0,0 +1,221 @@
+import { ecs } from "./ECS";
+import { ECSEntity } from "./ECSEntity";
+import { ECSGroup } from "./ECSGroup";
+import { ECSModel } from "./ECSModel";
+
+/** 继承此类实现具体业务逻辑的系统 */
+export abstract class ECSComblockSystem<E extends ECSEntity = ECSEntity> {
+    static s: boolean = true;
+
+    protected group: ECSGroup<E>;
+    protected dt: number = 0;
+
+    private enteredEntities: Map<number, E> = null!;
+    private removedEntities: Map<number, E> = null!;
+
+    private hasEntityEnter: boolean = false;
+    private hasEntityRemove: boolean = false;
+    private hasUpdate: boolean = false;
+
+    private tmpExecute: ((dt: number) => void) | null = null;
+    private execute!: (dt: number) => void;
+
+    /** 构造函数 */
+    constructor() {
+        let hasOwnProperty = Object.hasOwnProperty;
+        let prototype = Object.getPrototypeOf(this);
+        let hasEntityEnter = hasOwnProperty.call(prototype, 'entityEnter');
+        let hasEntityRemove = hasOwnProperty.call(prototype, 'entityRemove');
+        let hasFirstUpdate = hasOwnProperty.call(prototype, 'firstUpdate');
+        let hasUpdate = hasOwnProperty.call(prototype, 'update');
+
+        this.hasEntityEnter = hasEntityEnter;
+        this.hasEntityRemove = hasEntityRemove;
+        this.hasUpdate = hasUpdate;
+
+        if (hasEntityEnter || hasEntityRemove) {
+            this.enteredEntities = new Map<number, E>();
+            this.removedEntities = new Map<number, E>();
+
+            this.execute = this.execute1;
+            this.group = ECSModel.createGroup(this.filter());
+            this.group.watchEntityEnterAndRemove(this.enteredEntities, this.removedEntities);
+        }
+        else {
+            this.execute = this.execute0;
+            this.group = ECSModel.createGroup(this.filter());
+        }
+
+        if (hasFirstUpdate) {
+            this.tmpExecute = this.execute;
+            this.execute = this.updateOnce;
+        }
+    }
+
+    /** 系统实始化 */
+    init(): void {
+
+    }
+
+    /** 系统释放事件 */
+    onDestroy(): void {
+
+    }
+
+    /** 是否存在实体 */
+    hasEntity(): boolean {
+        return this.group.count > 0;
+    }
+
+    /**
+     * 先执行entityEnter，最后执行firstUpdate
+     * @param dt 
+     * @returns 
+     */
+    private updateOnce(dt: number) {
+        if (this.group.count === 0) {
+            return;
+        }
+
+        this.dt = dt;
+
+        // 处理刚进来的实体
+        if (this.enteredEntities.size > 0) {
+            var entities = this.enteredEntities.values();
+            for (let entity of entities) {
+                (this as unknown as ecs.IEntityEnterSystem).entityEnter(entity);
+            }
+            this.enteredEntities.clear();
+        }
+
+        // 只执行firstUpdate
+        for (let entity of this.group.matchEntities) {
+            (this as unknown as ecs.ISystemFirstUpdate).firstUpdate(entity);
+        }
+
+        this.execute = this.tmpExecute!;
+        this.execute(dt);
+        this.tmpExecute = null;
+    }
+
+    /**
+     * 只执行update
+     * @param dt 
+     * @returns 
+     */
+    private execute0(dt: number): void {
+        if (this.group.count === 0) return;
+
+        this.dt = dt;
+
+        // 执行update
+        if (this.hasUpdate) {
+            for (let entity of this.group.matchEntities) {
+                (this as unknown as ecs.ISystemUpdate).update(entity);
+            }
+        }
+    }
+
+    /**
+     * 先执行entityRemove，再执行entityEnter，最后执行update
+     * @param dt 
+     * @returns 
+     */
+    private execute1(dt: number): void {
+        let entities;
+        if (this.removedEntities.size > 0) {
+            if (this.hasEntityRemove) {
+                entities = this.removedEntities.values();
+                for (let entity of entities) {
+                    (this as unknown as ecs.IEntityRemoveSystem).entityRemove(entity);
+                }
+            }
+            this.removedEntities.clear();
+        }
+
+        if (this.group.count === 0) return;
+
+        this.dt = dt;
+
+        // 处理刚进来的实体
+        if (this.enteredEntities!.size > 0) {
+            if (this.hasEntityEnter) {
+                entities = this.enteredEntities!.values();
+                for (let entity of entities) {
+                    (this as unknown as ecs.IEntityEnterSystem).entityEnter(entity);
+                }
+            }
+            this.enteredEntities!.clear();
+        }
+
+        // 执行update
+        if (this.hasUpdate) {
+            for (let entity of this.group.matchEntities) {
+                (this as unknown as ecs.ISystemUpdate).update(entity);
+            }
+        }
+    }
+
+    /**
+     * 实体过滤规则
+     * 
+     * 根据提供的组件过滤实体。
+     */
+    abstract filter(): ecs.IMatcher;
+}
+
+/** 根System，对游戏中的System遍历从这里开始，一个System组合中只能有一个RootSystem，可以有多个并行的RootSystem */
+export class ECSRootSystem {
+    private executeSystemFlows: ECSComblockSystem[] = [];
+    private systemCnt: number = 0;
+
+    add(system: ECSSystem | ECSComblockSystem) {
+        if (system instanceof ECSSystem) {
+            // 将嵌套的System都“摊平”，放在根System中进行遍历，减少execute的频繁进入退出。
+            Array.prototype.push.apply(this.executeSystemFlows, system.comblockSystems);
+        }
+        else {
+            this.executeSystemFlows.push(system as ECSComblockSystem);
+        }
+        this.systemCnt = this.executeSystemFlows.length;
+        return this;
+    }
+
+    init() {
+        // 自动注册系统组件
+        ECSModel.systems.forEach(sys => this.add(sys));
+
+        // 初始化组件
+        this.executeSystemFlows.forEach(sys => sys.init());
+    }
+
+    execute(dt: number) {
+        for (let i = 0; i < this.systemCnt; i++) {
+            // @ts-ignore
+            this.executeSystemFlows[i].execute(dt);
+        }
+    }
+
+    clear() {
+        this.executeSystemFlows.forEach(sys => sys.onDestroy());
+    }
+}
+
+/** 系统组合器，用于将多个相同功能模块的系统逻辑上放在一起，系统也可以嵌套系统 */
+export class ECSSystem {
+    private _comblockSystems: ECSComblockSystem[] = [];
+    get comblockSystems() {
+        return this._comblockSystems;
+    }
+
+    add(system: ECSSystem | ECSComblockSystem) {
+        if (system instanceof ECSSystem) {
+            Array.prototype.push.apply(this._comblockSystems, system._comblockSystems);
+            system._comblockSystems.length = 0;
+        }
+        else {
+            this._comblockSystems.push(system as ECSComblockSystem);
+        }
+        return this;
+    }
+}

package/assets/core/lib/ecs/ECSSystem.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "9261f456-8364-4163-9931-6c526c635402",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/lib/ecs/IECS.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.23",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "70bdbf80-64ba-465d-baca-d19506dee907",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/lib/ecs.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "becc7741-24ad-4102-b41f-b4e76ec62918",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/package.json

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

package/assets/core/home/BaseBoxView.ts

@@ -1,57 +0,0 @@
-import { _decorator, Component, Node, Size, UITransform, v2, Vec2 } from 'cc';
-const { ccclass, property } = _decorator;
-
-
-@ccclass('BaseBoxView')
-export class BaseBoxView extends Component {
-    box_size: any = { width: 100, height: 100 };//获取碰撞盒大小
-    box_node: Node;
-    box_center: Node;
-    box_node_ut: UITransform;
-
-    ut: UITransform;
-
-    protected onLoad(): void {
-        this.ut = this.node.getComponent(UITransform);
-        if (this.box_node) {
-            this.box_node_ut = this.box_node.getComponent(UITransform);
-            this.node.BoxView = this;
-        }
-    }
-
-
-    UpdateBox(target: Node) {
-        // const data = CommonModule.Get_MapCenter().map_view.GetMapModel(0, 0)
-        // target = data.node;
-        // if (this.box_node) {
-        //     this.box_node.scale = target.scale;
-        //     const targetUT = target.getComponent(UITransform);
-        //     this.box_node_ut.anchorPoint = v2(0.5, 0);
-        //     this.box_node_ut.contentSize = new Size(targetUT.contentSize.width, targetUT.contentSize.height);
-        //     this.box_size.width = this.box_node_ut.width;
-        //     this.box_size.height = this.box_node_ut.height;
-        // }
-    }
-    // Collision(target_enemy: BoxView) {
-    //     const box1 = this.GetBox(this);
-    //     const box2 = this.GetBox(this.target_enemy);
-
-    //     const ok = App.Collision(box1, box2);
-    //     //  Logger.debug("碰撞了吗？", ok, this.node.name)
-    //     return ok
-    // }
-
-    public GetBox() {
-        const player = this;
-        const node = this.box_node;
-        const width = this.box_size.width;
-        const height = this.box_size.height;
-        const x = node.worldPosition.x - width * 0.5;
-        const y = node.worldPosition.y - height * 0.5;
-        return {
-            x1: x, y1: y,
-            x2: x + player.box_size.width, y2: y + player.box_size.height
-        };
-    }
-}
-

package/assets/core/home/DouYinShow.ts

@@ -1,27 +0,0 @@
-import { _decorator, CCBoolean, Component, Node } from 'cc';
-import { BYTEDANCE } from 'cc/env';
-const { ccclass, property } = _decorator;
-
-@ccclass('DouYinShow')
-export class DouYinShow extends Component {
-
-    @property({})
-    isTip = false;
-    protected onLoad(): void {
-        if (BYTEDANCE) {
-            if (!App.IsDouYin() && !this.isTip) {
-                this.node.active = false;
-            } else {
-            }
-        }
-
-    }
-    start() {
-
-    }
-
-    update(deltaTime: number) {
-
-    }
-}
-