@cc-component/cc-core 1.2.9 → 1.3.1

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

@@ -0,0 +1,302 @@
+import { ecs } from "./ECS";
+import { ECSMask } from "./ECSMask";
+import { CompCtor, CompType, ECSModel } from "./ECSModel";
+
+//#region 辅助方法
+
+/**
+ * 实体身上组件有增删操作，广播通知对应的观察者
+ * @param entity 实体对象
+ * @param componentTypeId 组件类型id
+ */
+function broadcastCompAddOrRemove(entity: ECSEntity, componentTypeId: number) {
+    let events = ECSModel.compAddOrRemove.get(componentTypeId);
+    for (let i = events!.length - 1; i >= 0; i--) {
+        events![i](entity);
+    }
+    // 判断是不是删了单例组件
+    if (ECSModel.tid2comp.has(componentTypeId)) {
+        ECSModel.tid2comp.delete(componentTypeId);
+    }
+}
+
+/**
+ * 创建组件对象
+ * @param ctor
+ */
+function createComp<T extends ecs.IComp>(ctor: CompCtor<T>): T {
+    const cct = ECSModel.compCtors[ctor.tid];
+    if (!cct) {
+        throw Error(`没有找到该组件的构造函数，检查${ctor.compName}是否为不可构造的组件`);
+    }
+    let comps = ECSModel.compPools.get(ctor.tid)!;
+    let component = comps.pop() || new (cct as CompCtor<T>);
+    return component as T;
+}
+
+/**
+ * 销毁实体
+ * 
+ * 缓存销毁的实体，下次新建实体时会优先从缓存中拿
+ * @param entity 
+ */
+function destroyEntity(entity: ECSEntity) {
+    if (ECSModel.eid2Entity.has(entity.eid)) {
+        let entitys = ECSModel.entityPool.get(entity.name);
+        if (entitys == null) {
+            entitys = [];
+            ECSModel.entityPool.set(entity.name, entitys);
+        }
+        entitys.push(entity);
+        ECSModel.eid2Entity.delete(entity.eid);
+    }
+    else {
+        console.warn('试图销毁不存在的实体');
+    }
+}
+
+//#endregion
+
+/** ECS实体对象 */
+export class ECSEntity {
+    /** 实体唯一标识，不要手动修改 */
+    eid: number = -1;
+    /** 实体对象名 */
+    name: string = "";
+    /** 实体是否有效 */
+    isValid: boolean = true;
+    /** 组件过滤数据 */
+    private mask = new ECSMask();
+    /** 当前实体身上附加的组件构造函数 */
+    private compTid2Ctor: Map<number, CompType<ecs.IComp>> = new Map();
+    /** 配合 entity.remove(Comp, false)， 记录组件实例上的缓存数据，在添加时恢复原数据 */
+    private compTid2Obj: Map<number, ecs.IComp> = new Map();
+
+    private _parent: ECSEntity | null = null;
+    /** 父实体 */
+    get parent(): ECSEntity | null {
+        return this._parent;
+    }
+    set parent(value: ECSEntity | null) {
+        this._parent = value;
+    }
+
+    /** 子实体 */
+    private childs: Map<number, ECSEntity> = null!;
+
+    /** 获取子实体 */
+    getChild<T>(eid: number) {
+        return this.childs.get(eid) as T;
+    }
+
+    /**
+     * 添加子实体
+     * @param entity 被添加的实体对象
+     * @returns      子实体的唯一编号, -1表示添加失败
+     */
+    addChild(entity: ECSEntity): number {
+        if (this.childs == null) this.childs = new Map<number, ECSEntity>();
+
+        if (this.childs.has(entity.eid)) {
+            console.warn(`子实体${entity.name}已存在`);
+            return -1;
+        }
+
+        entity._parent = this;
+        this.childs.set(entity.eid, entity);
+        return entity.eid;
+    }
+
+    /**
+     * 移除子实体
+     * @param entity    被移除的实体对象
+     * @param isDestroy 被移除的实体是否释放，默认为释放
+     * @returns 
+     */
+    removeChild(entity: ECSEntity, isDestroy = true) {
+        if (this.childs == null) return;
+
+        entity.parent = null;
+        this.childs.delete(entity.eid);
+        if (isDestroy) entity.destroy();
+    }
+
+    /**
+     * 根据组件类动态创建组件，并通知关心的系统。如果实体存在了这个组件，那么会先删除之前的组件然后添加新的
+     * 
+     * 注意：不要直接new Component，new来的Component不会从Component的缓存池拿缓存的数据
+     * @param componentTypeId   组件类
+     * @param isReAdd           true-表示用户指定这个实体可能已经存在了该组件，那么再次add组件的时候会先移除该组件然后再添加一遍。false-表示不重复添加组件
+     */
+    add<T extends ecs.IComp>(obj: T): ECSEntity;
+    add<T extends ecs.IComp>(ctor: CompType<T>, isReAdd?: boolean): T;
+    add<T extends ecs.IComp>(ctor: CompType<T> | T, isReAdd: boolean = false): T | ECSEntity {
+        if (typeof ctor === 'function') {
+            let compTid = ctor.tid;
+            if (ctor.tid === -1) {
+                throw Error(`【${this.name}】实体【${ctor.compName}】组件未注册`);
+            }
+            if (this.compTid2Ctor.has(compTid)) {                               // 判断是否有该组件，如果有则先移除
+                if (isReAdd) {
+                    this.remove(ctor);
+                }
+                else {
+                    console.log(`【${this.name}】实体【${ctor.compName}】组件已存在`);
+                    // @ts-ignore
+                    return this[ctor.compName] as T;
+                }
+            }
+            this.mask.set(compTid);
+
+            let comp: T;
+            if (this.compTid2Obj.has(compTid)) {
+                comp = this.compTid2Obj.get(compTid) as T;
+                this.compTid2Obj.delete(compTid);
+            }
+            else {
+                // 创建组件对象
+                comp = createComp(ctor) as T;
+            }
+
+            // 将组件对象直接附加到实体对象身上，方便直接获取
+            // @ts-ignore
+            this[ctor.compName] = comp;
+            this.compTid2Ctor.set(compTid, ctor);
+            comp.tid = compTid;
+            comp.ent = this;
+            // 广播实体添加组件的消息
+            broadcastCompAddOrRemove(this, compTid);
+
+            return comp;
+        }
+        else {
+            let tmpCtor = (ctor.constructor as CompCtor<T>);
+            let compTid = tmpCtor.tid;
+            // console.assert(compTid !== -1 || !compTid, '组件未注册！');
+            // console.assert(this.compTid2Ctor.has(compTid), '已存在该组件！');
+            if (compTid === -1 || compTid == null) throw Error(`【${this.name}】实体【${tmpCtor.name}】组件未注册`);
+            if (this.compTid2Ctor.has(compTid)) throw Error(`【${this.name}】实体【${tmpCtor.name}】组件已经存在`);
+
+            this.mask.set(compTid);
+            //@ts-ignore
+            this[tmpCtor.compName] = ctor;
+            this.compTid2Ctor.set(compTid, tmpCtor);
+            //@ts-ignore
+            ctor.tid = compTid;
+            //@ts-ignore
+            ctor.canRecycle = false;
+            //@ts-ignore
+            ctor.ent = this;
+            broadcastCompAddOrRemove(this, compTid);
+
+            return this;
+        }
+    }
+
+    /**
+     * 批量添加组件
+     * @param ctors 组件类
+     * @returns 
+     */
+    addComponents<T extends ecs.IComp>(...ctors: CompType<T>[]) {
+        for (let ctor of ctors) {
+            this.add(ctor);
+        }
+        return this;
+    }
+
+    /**
+     * 获取一个组件实例
+     * @param ctor 组件类
+     */
+    get(ctor: number): number;
+    get<T extends ecs.IComp>(ctor: CompCtor<T>): T;
+    get<T extends ecs.IComp>(ctor: CompCtor<T> | number): T {
+        // @ts-ignore
+        return this[ctor.compName];
+    }
+
+    /**
+     * 组件是否在实体存在内
+     * @param ctor 组件类
+     */
+    has(ctor: CompType<ecs.IComp>): boolean {
+        if (typeof ctor == "number") {
+            return this.mask.has(ctor);
+        }
+        else {
+            return this.compTid2Ctor.has(ctor.tid);
+        }
+    }
+
+    /**
+     * 从实体上删除指定组件
+     * @param ctor      组件构造函数或者组件Tag
+     * @param isRecycle 是否回收该组件对象。对于有些组件上有大量数据，当要描述移除组件但是不想清除组件上的数据是可以
+     * 设置该参数为false，这样该组件对象会缓存在实体身上，下次重新添加组件时会将该组件对象添加回来，不会重新从组件缓存
+     * 池中拿一个组件来用。
+     */
+    remove(ctor: CompType<ecs.IComp>, isRecycle: boolean = true) {
+        let hasComp = false;
+        //@ts-ignore
+        let componentTypeId = ctor.tid;
+        //@ts-ignore
+        let compName = ctor.compName;
+        if (this.mask.has(componentTypeId)) {
+            hasComp = true;
+            //@ts-ignore
+            let comp = this[ctor.compName];
+            //@ts-ignore
+            comp.ent = null;
+            if (isRecycle) {
+                comp.reset();
+
+                // 回收组件到指定缓存池中
+                if (comp.canRecycle) {
+                    const compPoolsType = ECSModel.compPools.get(componentTypeId)!;
+                    compPoolsType.push(comp);
+                }
+            }
+            else {
+                this.compTid2Obj.set(componentTypeId, comp);        // 用于缓存显示对象组件
+            }
+        }
+
+        // 删除实体上的组件逻辑
+        if (hasComp) {
+            //@ts-ignore
+            this[compName] = null;
+            this.mask.delete(componentTypeId);
+            this.compTid2Ctor.delete(componentTypeId);
+            broadcastCompAddOrRemove(this, componentTypeId);
+        }
+    }
+
+    /** 销毁实体，实体会被回收到实体缓存池中 */
+    destroy() {
+        this.isValid = false;
+
+        // 如果有父模块，则移除父模块上记录的子模块
+        if (this._parent) {
+            this._parent.removeChild(this, false);
+            this._parent = null;
+        }
+
+        // 移除模块上所有子模块
+        if (this.childs) {
+            this.childs.forEach(e => {
+                this.removeChild(e);
+            });
+            this.childs = null!;
+        }
+
+        // 移除实体上所有组件
+        this.compTid2Ctor.forEach(this._remove, this);
+        destroyEntity(this);
+        this.compTid2Obj.clear();
+    }
+
+    private _remove(comp: CompType<ecs.IComp>) {
+        this.remove(comp, true);
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "1fb62582-dcf6-4fbc-b863-a1941fad1109",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

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

@@ -0,0 +1,83 @@
+/*
+ * @Author: dgflash
+ * @Date: 2022-09-01 18:00:28
+ * @LastEditors: dgflash
+ * @LastEditTime: 2022-09-05 14:21:54
+ */
+import { ecs } from "./ECS";
+import { ECSEntity } from "./ECSEntity";
+
+export class ECSGroup<E extends ECSEntity = ECSEntity> {
+    /** 实体筛选规则 */
+    private matcher: ecs.IMatcher;
+
+    private _matchEntities: Map<number, E> = new Map();
+
+    private _entitiesCache: E[] | null = null;
+
+    /**
+     * 符合规则的实体
+     */
+    get matchEntities() {
+        if (this._entitiesCache === null) {
+            this._entitiesCache = Array.from(this._matchEntities.values());
+        }
+        return this._entitiesCache;
+    }
+
+    /**
+     * 当前group中实体的数量
+     * 
+     * 注：不要手动修改这个属性值。
+     * 注：其实可以通过this._matchEntities.size获得实体数量，但是需要封装get方法。为了减少一次方法的调用所以才直接创建一个count属性
+     */
+    count = 0;
+
+    /** 获取matchEntities中第一个实体 */
+    get entity(): E {
+        return this.matchEntities[0];
+    }
+
+    private _enteredEntities: Map<number, E> | null = null;
+    private _removedEntities: Map<number, E> | null = null;
+
+    constructor(matcher: ecs.IMatcher) {
+        this.matcher = matcher;
+    }
+
+    onComponentAddOrRemove(entity: E) {
+        if (this.matcher.isMatch(entity)) {                         // Group只关心指定组件在实体身上的添加和删除动作。
+            this._matchEntities.set(entity.eid, entity);
+            this._entitiesCache = null;
+            this.count++;
+
+            if (this._enteredEntities) {
+                this._enteredEntities.set(entity.eid, entity);
+                this._removedEntities!.delete(entity.eid);
+            }
+        }
+        else if (this._matchEntities.has(entity.eid)) {             // 如果Group中有这个实体，但是这个实体已经不满足匹配规则，则从Group中移除该实体
+            this._matchEntities.delete(entity.eid);
+            this._entitiesCache = null;
+            this.count--;
+
+            if (this._enteredEntities) {
+                this._enteredEntities.delete(entity.eid);
+                this._removedEntities!.set(entity.eid, entity);
+            }
+        }
+    }
+
+    watchEntityEnterAndRemove(enteredEntities: Map<number, E>, removedEntities: Map<number, E>) {
+        this._enteredEntities = enteredEntities;
+        this._removedEntities = removedEntities;
+    }
+
+    clear() {
+        this._matchEntities.clear();
+        this._entitiesCache = null;
+        this.count = 0;
+        this._enteredEntities?.clear();
+        this._removedEntities?.clear();
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "c21a2de8-f4fe-4534-96a6-70c9a86167ec",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

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

@@ -0,0 +1,57 @@
+/*
+ * @Author: dgflash
+ * @Date: 2022-05-12 14:18:44
+ * @LastEditors: dgflash
+ * @LastEditTime: 2022-05-24 11:09:49
+ */
+import { ECSModel } from "./ECSModel";
+
+export class ECSMask {
+    private mask: Uint32Array;
+    private size: number = 0;
+
+    constructor() {
+        let length = Math.ceil(ECSModel.compTid / 31);
+        this.mask = new Uint32Array(length);
+        this.size = length;
+    }
+
+    set(num: number) {
+        // https://stackoverflow.com/questions/34896909/is-it-correct-to-set-bit-31-in-javascript
+        // this.mask[((num / 32) >>> 0)] |= ((1 << (num % 32)) >>> 0);
+        this.mask[((num / 31) >>> 0)] |= (1 << (num % 31));
+    }
+
+    delete(num: number) {
+        this.mask[((num / 31) >>> 0)] &= ~(1 << (num % 31));
+    }
+
+    has(num: number) {
+        return !!(this.mask[((num / 31) >>> 0)] & (1 << (num % 31)));
+    }
+
+    or(other: ECSMask) {
+        for (let i = 0; i < this.size; i++) {
+            // &操作符最大也只能对2^30进行操作，如果对2^31&2^31会得到负数。当然可以(2^31&2^31) >>> 0，这样多了一步右移操作。
+            if (this.mask[i] & other.mask[i]) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    and(other: ECSMask) {
+        for (let i = 0; i < this.size; i++) {
+            if ((this.mask[i] & other.mask[i]) != this.mask[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    clear() {
+        for (let i = 0; i < this.size; i++) {
+            this.mask[i] = 0;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "d1869e0f-3dbb-46b3-9229-828fef689057",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

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

@@ -0,0 +1,215 @@
+import { ecs } from "./ECS";
+import { ECSEntity } from "./ECSEntity";
+import { ECSMask } from "./ECSMask";
+import { CompCtor, CompType, ECSModel } from "./ECSModel";
+
+let macherId: number = 1;
+
+/**
+ * 筛选规则间是“与”的关系
+ * 比如：ecs.Macher.allOf(...).excludeOf(...)表达的是allOf && excludeOf，即实体有“这些组件” 并且 “没有这些组件”
+ */
+export class ECSMatcher implements ecs.IMatcher {
+    protected rules: BaseOf[] = [];
+    protected _indices: number[] | null = null;
+    public isMatch!: (entity: ECSEntity) => boolean;
+    public mid: number = -1;
+
+    private _key: string | null = null;
+    public get key(): string {
+        if (!this._key) {
+            let s = '';
+            for (let i = 0; i < this.rules.length; i++) {
+                s += this.rules[i].getKey()
+                if (i < this.rules.length - 1) {
+                    s += ' && '
+                }
+            }
+            this._key = s;
+        }
+        return this._key;
+    }
+
+    constructor() {
+        this.mid = macherId++;
+    }
+
+    /**
+     * 匹配器关注的组件索引。在创建Group时，Context根据组件id去给Group关联组件的添加和移除事件。
+     */
+    get indices() {
+        if (this._indices === null) {
+            this._indices = [];
+            this.rules.forEach((rule) => {
+                Array.prototype.push.apply(this._indices, rule.indices);
+            });
+        }
+        return this._indices;
+    }
+
+    /**
+     * 组件间是或的关系，表示关注拥有任意一个这些组件的实体。
+     * @param args 组件索引
+     */
+    anyOf(...args: CompType<ecs.IComp>[]): ECSMatcher {
+        this.rules.push(new AnyOf(...args));
+        this.bindMatchMethod();
+        return this;
+    }
+
+    /**
+     * 组件间是与的关系，表示关注拥有所有这些组件的实体。
+     * @param args 组件索引
+     */
+    allOf(...args: CompType<ecs.IComp>[]): ECSMatcher {
+        this.rules.push(new AllOf(...args));
+        this.bindMatchMethod();
+        return this;
+    }
+
+    /**
+     * 表示关注只拥有这些组件的实体
+     * 
+     * 注意：
+     *  不是特殊情况不建议使用onlyOf。因为onlyOf会监听所有组件的添加和删除事件。
+     * @param args 组件索引
+     */
+    onlyOf(...args: CompType<ecs.IComp>[]): ECSMatcher {
+        this.rules.push(new AllOf(...args));
+        let otherTids: CompType<ecs.IComp>[] = [];
+        for (let ctor of ECSModel.compCtors) {
+            if (args.indexOf(ctor) < 0) {
+                otherTids.push(ctor);
+            }
+        }
+        this.rules.push(new ExcludeOf(...otherTids));
+        this.bindMatchMethod();
+        return this;
+    }
+
+    /**
+     * 不包含指定的任意一个组件
+     * @param args 
+     */
+    excludeOf(...args: CompType<ecs.IComp>[]) {
+        this.rules.push(new ExcludeOf(...args));
+        this.bindMatchMethod();
+        return this;
+    }
+
+    private bindMatchMethod() {
+        if (this.rules.length === 1) {
+            this.isMatch = this.isMatch1;
+        }
+        else if (this.rules.length === 2) {
+            this.isMatch = this.isMatch2;
+        }
+        else {
+            this.isMatch = this.isMatchMore;
+        }
+    }
+
+    private isMatch1(entity: ECSEntity): boolean {
+        return this.rules[0].isMatch(entity);
+    }
+
+    private isMatch2(entity: ECSEntity): boolean {
+        return this.rules[0].isMatch(entity) && this.rules[1].isMatch(entity);
+    }
+
+    private isMatchMore(entity: ECSEntity): boolean {
+        for (let rule of this.rules) {
+            if (!rule.isMatch(entity)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    clone(): ECSMatcher {
+        let newMatcher = new ECSMatcher();
+        newMatcher.mid = macherId++;
+        this.rules.forEach(rule => newMatcher.rules.push(rule));
+        return newMatcher;
+    }
+}
+
+abstract class BaseOf {
+    indices: number[] = [];
+
+    protected mask = new ECSMask();
+
+    constructor(...args: CompType<ecs.IComp>[]) {
+        let componentTypeId = -1;
+        let len = args.length;
+        for (let i = 0; i < len; i++) {
+            if (typeof (args[i]) === "number") {
+                componentTypeId = args[i] as number;
+            }
+            else {
+                componentTypeId = (args[i] as CompCtor<ecs.IComp>).tid;
+            }
+            if (componentTypeId == -1) {
+                throw Error('存在没有注册的组件！');
+            }
+            this.mask.set(componentTypeId);
+
+            if (this.indices.indexOf(componentTypeId) < 0) { // 去重
+                this.indices.push(componentTypeId);
+            }
+        }
+        if (len > 1) {
+            this.indices.sort((a, b) => { return a - b; }); // 对组件类型id进行排序，这样关注相同组件的系统就能共用同一个group
+        }
+    }
+
+    toString(): string {
+        return this.indices.join('-'); // 生成group的key
+    }
+
+    abstract getKey(): string;
+
+    abstract isMatch(entity: ECSEntity): boolean;
+}
+
+/**
+ * 用于描述包含任意一个这些组件的实体
+ */
+class AnyOf extends BaseOf {
+    public isMatch(entity: ECSEntity): boolean {
+        // @ts-ignore
+        return this.mask.or(entity.mask);
+    }
+
+    getKey(): string {
+        return 'anyOf:' + this.toString();
+    }
+}
+
+/**
+ * 用于描述包含了“这些”组件的实体，这个实体除了包含这些组件还可以包含其他组件
+ */
+class AllOf extends BaseOf {
+    public isMatch(entity: ECSEntity): boolean {
+        // @ts-ignore
+        return this.mask.and(entity.mask);
+    }
+
+    getKey(): string {
+        return 'allOf:' + this.toString();
+    }
+}
+
+/**
+ * 不包含指定的任意一个组件
+ */
+class ExcludeOf extends BaseOf {
+    public getKey(): string {
+        return 'excludeOf:' + this.toString();
+    }
+
+    public isMatch(entity: ECSEntity): boolean {
+        // @ts-ignore
+        return !this.mask.or(entity.mask);
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "37e8aae5-a8f9-4ded-a999-6321c5bc1229",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}