@cjhd/cj-ecs 1.0.0 → 1.0.1

package/assets/ecs/EcsEntity.ts

@@ -1,430 +0,0 @@
-import { error, Node } from 'cc';
-import { DEV } from 'cc/env';
-import { ECS } from '../ecs';
-import { componentCache } from '../lib/EcsCache';
-import { classManager, flagManager } from '../lib/EcsManager';
-import { EcsBaseComponent, EcsBaseEntity, IComponent, IComponentName, IECS, IEntity, ITypeofComponent } from '../lib/EcsObject';
-import { ArrayMap } from '../lib/EcsUtils';
-import { EcsComponent } from './EcsComponent';
-
-export class EcsEntity extends EcsBaseEntity implements IEntity {
-    /**位运算 */
-    private flag: number[] = new Array(flagManager.bits).fill(0);
-
-    private instNames: string[] = [];
-
-    /**组件的名字 => 组件数组 */
-    private instNameToComps: ArrayMap<IComponentName, IComponent> = new ArrayMap();
-
-    /**组件父类的名字 => 组件数组 */
-    private superNameToComps: ArrayMap<IComponentName, IComponent> = new ArrayMap();
-
-    private _isValid = false;
-    /**是否有效 */
-    public get isValid() {
-        return this._isValid;
-    }
-    private set isValid(value) {
-        this._isValid = value;
-    }
-
-    private _enabled = true;
-    /**标记是否生效 */
-    public get enabled() {
-        return this._enabled;
-    }
-    public set enabled(value) {
-        if (this._enabled === value) return;
-        this._enabled = value;
-        if (value) {
-            this.onEnable();
-        } else {
-            this.onDisable();
-        }
-        // 更新组件状态
-        this.instNameToComps.forEach((comps) => {
-            for (let index = 0; index < comps.length; index++) {
-                EcsComponent.updateEnable(comps[index] as EcsComponent);
-            }
-        });
-    }
-
-    /**指定ecs */
-    private _ecs: ECS | null = null;
-    /**获取对应的ecs */
-    protected get ecs() {
-        return this._ecs as IECS;
-    }
-
-    /**节点 */
-    private _node: Node | null = null;
-    public get node() {
-        return this._node;
-    }
-    public set node(value: Node | null) {
-        this._node = value;
-    }
-
-    /**标记是否已经销毁 */
-    private _isDestroyed = true;
-
-    /**
-     * 内部初始化函数
-     */
-    protected innerInit(ecs: IECS, node: Node | null = null) {
-        this._ecs = ecs as ECS;
-        this._node = node;
-        this._isValid = true;
-        this._enabled = true;
-        this._isDestroyed = false;
-        this.onAdd();
-        this._enabled && this.onEnable();
-    }
-
-    /**
-     * 添加组件(内部调用)
-     */
-    protected innerAddComponent(com: EcsComponent) {
-        // 组件类名字
-        const componentName = com.ecsName;
-
-        // 添加父类名字到uuid的转换
-        classManager.eachSuperName(componentName, (superName) => {
-            this.superNameToComps.add(superName, com);
-        });
-
-        // 添加名字到uuid的转换
-        const len = this.instNameToComps.add(componentName, com);
-
-        if (len === 1) {
-            // 记录组件实例的名字
-            this.instNames.push(componentName);
-            // 更新标记位
-            flagManager.addFlag(this.flag, flagManager.getAllByName(componentName));
-        }
-
-        EcsComponent.onAdd(com, this);
-    }
-
-    /**
-     * 移除组件(内部调用)
-     */
-    protected innerRemoveComponent(com: EcsComponent) {
-        // 组件类名字
-        const componentName = com.ecsName;
-
-        // 删除父类名字到uuid的转换
-        classManager.eachSuperName(componentName, (superName) => {
-            this.superNameToComps.sub(superName, com);
-        });
-
-        // 删除名字到uuid的转换
-        const del = this.instNameToComps.subDel(componentName, com);
-
-        if (del) {
-            const index = this.instNames.indexOf(componentName);
-            this.instNames.splice(index, 1);
-            // 更新标记位
-            flagManager.getAllByNames(this.instNames, this.flag);
-        }
-
-        EcsComponent.onRemove(com);
-    }
-
-    /**
-     * 根据组件名字获取对应的组件数组(先查inst再查询super)
-     */
-    private getCompsByName(componentName: string): readonly IComponent<IEntity>[] | null {
-        const instComps = this.instNameToComps.get(componentName);
-        if (instComps && instComps.length) {
-            return instComps;
-        }
-
-        const superComps = this.superNameToComps.get(componentName);
-        if (superComps && superComps.length) {
-            return superComps;
-        }
-
-        return null;
-    }
-
-    /**
-     * 根据组件名字获取对应的组件数组(先查inst再查询super)
-     */
-    private getCompsByName2(componentName: string) {
-        const out: IComponent[] = [];
-        const instComps = this.instNameToComps.get(componentName);
-        if (instComps && instComps.length) {
-            Array.prototype.push.apply(out, instComps);
-        }
-
-        const superComps = this.superNameToComps.get(componentName);
-        if (superComps && superComps.length) {
-            Array.prototype.push.apply(out, superComps);
-        }
-
-        return out;
-    }
-
-    /**
-     * 移除当前所有组件
-     */
-    private clear() {
-        const keys = this.instNames;
-
-        for (let index = keys.length - 1; index >= 0; index--) {
-            const comps = this.instNameToComps.get(keys[index]);
-            if (!comps) continue;// 如果在某个组件的onRemove中主动移除其它组件，这个会是null
-            for (let index = comps.length - 1; index >= 0; index--) {
-                this.removeComponent(comps[index]);
-            }
-        }
-
-        this.flag.fill(0);
-        this.instNames.length = 0;
-        this.instNameToComps.clear();
-        this.superNameToComps.clear();
-    }
-
-    /**
-     * 销毁
-     */
-    public destroy() {
-        if (this._isDestroyed) return false;
-        this._isDestroyed = true;
-
-        this.enabled && this.onDisable();
-        this.onRemove();
-        this.clear();
-        this._node = null;
-        this._isValid = false;
-        this._ecs!.removeEntity(this);
-        this._ecs = null;
-        return true;
-    }
-
-    /**添加*/
-    protected onAdd() { }
-    /**生效*/
-    protected onEnable() { }
-    /**失效*/
-    protected onDisable() { }
-    /**移除*/
-    protected onRemove() { }
-
-    /**
-     * 检查是否包含全部
-     */
-    checkFlagAll(flag: number[]) {
-        return flagManager.checkFlagAll(this.flag, flag);
-
-    }
-    /**
-     * 检查是否包含任一
-     */
-    checkFlagAny(flag: number[]) {
-        return flagManager.checkFlagAny(this.flag, flag);
-    }
-
-    /**
-     * 检查是否仅包含全部
-     */
-    checkFlagOnly(flag: number[]) {
-        const componentNames = this.instNames;
-        for (let index = 0; index < componentNames.length; index++) {
-            const componentName = componentNames[index];
-            const comFlag = flagManager.getAllByName(componentName);
-            const success = flagManager.checkFlagAny(comFlag, flag);
-            if (!success) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * 根据组件名字检查是否存在启用且有效的组件
-     */
-    hasEnabledComponentName(componentName: string): boolean {
-        const comps = this.getCompsByName(componentName);
-        if (!comps || comps.length === 0) return false;
-        for (let index = 0; index < comps.length; index++) {
-            const comp = comps[index];
-            if (comp.enabledInHierarchy && comp.isStrictValid) return true;
-        }
-        return false;
-    }
-
-    /**
-     * 添加相应类型的组件
-     * @see 同add
-     * @param param 类型
-     */
-    addComponent<T extends ITypeofComponent>(param: T | IComponent): InstanceType<T> | null {
-        return this.add(param);
-    }
-
-    /**
-     * 添加相应类型的组件
-     * @param param 类型
-     */
-    add<T extends ITypeofComponent>(param: T | IComponent): InstanceType<T> | null {
-        if (DEV && param.ecsName === EcsComponent.ecsName) {
-            console.error('请使用ecsclass修饰Component', param);
-            return null;
-        }
-
-        // 是实例
-        if (param instanceof EcsBaseComponent) {
-            if (param.entity === this) {
-                error(`不允许重复添加同一个组件实例\nuuid:    ${param.uuid}\n组件名:   ${param.ecsName}`);
-                return null;
-            } else if (param.entity) {
-                error(`不允许添加其它实体的组件实例\nuuid:    ${param.uuid}\n组件名:   ${param.ecsName}`);
-                return null;
-            } else if (!param.allowMultiple) {
-                const comps = this.instNameToComps.get(param.ecsName);
-                if (comps && comps.length) {
-                    error(`此类型的组件不允许重复添加\nuuid:    ${param.uuid}\n组件名:   ${param.ecsName}`);
-                    return null;
-                }
-            }
-            this._ecs!.addComponent(this, param);
-            return param as InstanceType<T>;
-        } else {
-            // 如果不允许重复添加
-            if (!param.allowMultiple) {
-                const comps = this.instNameToComps.get(param.ecsName);
-                if (comps && comps.length) {
-                    error(`此类型的组件不允许重复添加\n组件名:   ${param.ecsName}`);
-                    return null;
-                }
-            }
-            const com = componentCache.get(param.ecsName) || new param();
-            this._ecs!.addComponent(this, com);
-            return com as InstanceType<T>;
-        }
-    }
-
-    /**
-     * 移除相应类型的第一个组件
-     * @see 同remove
-     * @param param 类型或实例(当组件开启allowMultiple后，需要传入实例)
-     */
-    removeComponent(param: ITypeofComponent | IComponent): boolean {
-        return this.remove(param);
-    }
-
-    /**
-     * 移除相应类型的第一个组件
-     * @param param 类型或实例(当组件开启allowMultiple后，需要传入实例)
-     */
-    remove(param: ITypeofComponent | IComponent): boolean {
-        if (!param) return false;
-
-        if (param instanceof EcsBaseComponent) {
-            if (param.entity !== this) {
-                error(`移除的组件不属于当前实体\n组件名:   ${param.ecsName}`);
-                return false;
-            }
-            this._ecs!.removeComponent(param);
-            if (param.allowRecycling) {
-                EcsBaseComponent.updateUUID(param);
-                componentCache.put(param.ecsName, param);
-            }
-            return true;
-        } else {
-            if (param.allowMultiple) {
-                error(`开启allowMultiple的组件只能通过实例进行移除\n组件名:   ${param.ecsName}`);
-                return false;
-            }
-            const com = this.get(param);
-            if (!com) return false;
-            this._ecs!.removeComponent(com);
-            if (param.allowRecycling) {
-                EcsBaseComponent.updateUUID(com);
-                componentCache.put(param.ecsName, com);
-            }
-            return true;
-        }
-    }
-
-    /**
-     * 移除相应组件的所有组件
-     * @see 同removeAll
-     * @param Com 类型
-     */
-    removeComponents(Com: ITypeofComponent): boolean {
-        return this.removeAll(Com);
-    }
-
-    /**
-     * 移除相应组件的所有组件
-     * @param Com 类型
-     */
-    removeAll(Com: ITypeofComponent): boolean {
-        const comps = this.getAll(Com);
-        if (!comps.length) return false;
-
-        let success = true;
-        for (let index = 0; index < comps.length; index++) {
-            success = this.remove(comps[index]) && success;
-        }
-        return success;
-    }
-
-    /**
-     * 有没有相应类型的组件
-     * @see 同has
-     * @param Com 类型
-     */
-    hasComponent(Com: ITypeofComponent): boolean {
-        return this.has(Com);
-    }
-
-    /**
-     * 有没有相应类型的组件
-     * @param Com 类型
-     */
-    has(Com: ITypeofComponent): boolean {
-        const comps = this.getCompsByName(Com.ecsName);
-        if (!comps || comps.length === 0) return false;
-        return true;
-    }
-
-    /**
-     * 获取相应类型的组件
-     * @see 同get
-     * @param Com 类型
-     */
-    getComponent<T extends ITypeofComponent>(Com: T): InstanceType<T> | null {
-        return this.get(Com);
-    }
-
-    /**
-     * 获取相应类型的组件
-     * @param Com 类型
-     */
-    get<T extends ITypeofComponent>(Com: T): InstanceType<T> | null {
-        const comps = this.getCompsByName(Com.ecsName);
-        if (!comps || comps.length === 0) return null;
-        return comps[0] as InstanceType<T>;
-    }
-
-    /**
-     * 获取相应类型的组件
-     * @see 同getAll
-     * @param Com 类型
-     */
-    getComponents<T extends ITypeofComponent>(Com: T): InstanceType<T>[] {
-        return this.getAll(Com);
-    }
-
-    /**
-     * 获取相应类型的组件
-     * @param Com 类型
-     */
-    getAll<T extends ITypeofComponent>(Com: T): InstanceType<T>[] {
-        return this.getCompsByName2(Com.ecsName) as InstanceType<T>[];
-    }
-}

package/assets/ecs/EcsEntity.ts.meta

@@ -1,9 +0,0 @@
-{
-  "ver": "4.0.24",
-  "importer": "typescript",
-  "imported": true,
-  "uuid": "3cb5697e-06df-4707-b30d-e99115ba656b",
-  "files": [],
-  "subMetas": {},
-  "userData": {}
-}

package/assets/ecs/EcsSingleton.ts

@@ -1,6 +0,0 @@
-import { ecsclass } from '../lib/EcsManager';
-import { EcsBaseSingleton, ISingleton } from '../lib/EcsObject';
-
-@ecsclass('EcsSingleton')
-export class EcsSingleton extends EcsBaseSingleton implements ISingleton {
-}

package/assets/ecs/EcsSingleton.ts.meta

@@ -1,9 +0,0 @@
-{
-  "ver": "4.0.24",
-  "importer": "typescript",
-  "imported": true,
-  "uuid": "b51e6cff-6340-4e4a-84ea-29f3795eed70",
-  "files": [],
-  "subMetas": {},
-  "userData": {}
-}

package/assets/ecs/EcsSystem.ts

@@ -1,191 +0,0 @@
-import { Node } from 'cc';
-import { Filter } from '../lib/EcsFilter';
-import { EcsBaseSystem, IComponent, IECS, IEntity, IEntityUUID, IFilter, ISystem, ITypeofComponent, ITypeofEntity, ITypeofSingleton } from '../lib/EcsObject';
-import { TimerManager } from '../lib/EcsTimer';
-import { TweenManager } from '../lib/EcsTween';
-import type { IEcsObservedQuery } from './EcsDirty';
-
-export class EcsSystem extends EcsBaseSystem implements ISystem {
-    static matchEntity(system: EcsSystem, entity: IEntity) {
-        system.matchEntity(entity);
-    }
-
-    private _ecs: IECS | null = null;
-    /**获取对应的ecs */
-    protected get ecs() {
-        return this._ecs as IECS;
-    }
-    /** observed runtime 查询入口。未安装 cj-ecs-observed 时为 null，系统需要自行兜底。 */
-    protected get observed(): IEcsObservedQuery | null {
-        return this.ecs.getObservedQuery();
-    }
-    private set ecs(v) {
-        this._ecs = v;
-    }
-
-    /**
-     * Timer管理器
-     * @example
-     * // 创建timer
-     * const timer = new Timer(() => { consoe.log('timer'); });
-     * timer.delay(1);
-     * timer.repeat(10);
-     * // 添加管理
-     * this.timer.add(timer);
-     * // 迭代一次
-     * this.timer.step(dt);
-     */
-    protected timer = new TimerManager();
-
-    /**
-     * Tween管理器
-     * @example
-     * // 创建tween
-     * const tween = new Tween(ECS组件实例);
-     * tween.to(1, ...);
-     * tween.delay(1);
-     * tween.by(1, ...);
-     * // 添加管理
-     * this.tween.add(tween);
-     * // 迭代一次
-     * this.tween.step(dt);
-     */
-    protected tween = new TweenManager();
-
-    /**
-     * 指定ecs
-     */
-    constructor(ecs: IECS) {
-        super();
-        this.ecs = ecs;
-    }
-
-    /**添加 */
-    protected onAdd() { }
-
-    /**移除 */
-    protected onRemove() { }
-
-    /**查询实体 */
-    protected query<T extends IEntity>(filter: IFilter): T[];
-    protected query<T extends IComponent>(filter: IFilter, Component: { new(): T }): T[];
-    protected query<T>(filter: IFilter, Component?: any): T[] {
-        if (this.matcher === filter) {
-            if (Component) {
-                return Array.from(this.matchEntities.values()).map((entity) => entity.getComponent(Component as ITypeofComponent)) as T[];
-            }
-            return Array.from(this.matchEntities.values()) as T[];
-        }
-        return this.ecs.query(filter, Component as ITypeofComponent) as T[];
-    }
-
-    /**查询实体 */
-    protected find<T extends IEntity>(filter: IFilter): T | null;
-    protected find<T extends IComponent>(filter: IFilter, Component: { new(): T }): T | null;
-    protected find<T>(filter: IFilter, Component?: any): T | null {
-        if (this.matcher === filter) {
-            if (Component) {
-                return this.matchEntities.values().next().value?.getComponent(Component as ITypeofComponent) as T || null;
-            }
-            return this.matchEntities.values().next().value as T || null;
-        }
-        return this.ecs.find(filter, Component as ITypeofComponent) as T || null;
-    }
-
-    /**是否存在实体 */
-    protected exist(filter: IFilter): boolean {
-        if (this.matcher === filter) {
-            return this.matchEntities.size > 0;
-        }
-        return this.ecs.exist(filter);
-    }
-
-    /**遍历当前系统 matcher 命中的实体，避免 query(this.matcher) 每帧分配数组 */
-    protected forEachMatchedEntity<T extends IEntity = IEntity>(handle: (entity: T) => void) {
-        this.matchEntities.forEach((entity) => {
-            handle(entity as T);
-        });
-    }
-
-    /**当前系统 matcher 命中的实体数量 */
-    protected get matchedEntityCount() {
-        return this.matchEntities.size;
-    }
-
-    /**创建实体 */
-    protected createEntity<T extends ITypeofEntity>(Entity: T, options?: Node | { node?: Node }) {
-        return this.ecs.createEntity(Entity, options);
-    }
-
-    /**查询实体 */
-    protected findByUuid(uuid: IEntityUUID) {
-        return this.ecs.findByUuid(uuid);
-    }
-
-    /**是否存在实体 */
-    protected existByUuid(uuid: IEntityUUID) {
-        return this.ecs.existByUuid(uuid);
-    }
-
-    /**获取单例组件 */
-    protected getSingleton<T extends ITypeofSingleton>(param: T) {
-        return this.ecs.getSingleton(param);
-    }
-
-    /**
-     * 过滤实体
-     * - 配置后才能响应onEntityEnter、onEntityLeave
-     * - 如果query、find、exist方法中的值与matcher中的值相同，则会直接从缓存中获取实体
-     */
-    protected matcher: IFilter | null = null;
-
-    /**实体进入系统，会在execute流程最开始调用*/
-    protected onEntityEnter(entity: IEntity) { entity; }
-
-    /**实体离开系统，会在execute流程最开始调用*/
-    protected onEntityLeave(entity: IEntity) { entity; }
-
-    private matchEntities: Map<IEntityUUID, IEntity> = new Map();
-    private matchEntity(entity: IEntity) {
-        if (this.matcher) {
-            const isInMatch = this.matchEntities.has(entity.uuid);
-            const isMatch = Filter.check(entity, this.matcher as Filter);
-            if (isMatch) {
-                if (!isInMatch) {
-                    this.matchEntities.set(entity.uuid, entity);
-                    this.onEntityEnter(entity);
-                }
-            } else {
-                if (isInMatch) {
-                    this.matchEntities.delete(entity.uuid);
-                    this.onEntityLeave(entity);
-                }
-            }
-        } else if (this.matchEntities.size > 0) {
-            this.matchEntities.forEach((entity) => {
-                this.onEntityLeave(entity);
-            });
-            this.matchEntities.clear();
-        }
-    }
-
-    // 由ecs.execute驱动
-    protected execute(dt?: number, ...args: any[]) { dt; args; }
-    protected beforeExecute(dt?: number, ...args: any[]) { dt; args; }
-    protected afterExecute(dt?: number, ...args: any[]) { dt; args; }
-
-    // 由ecs.update驱动
-    protected update(dt?: number, ...args: any[]) { dt; args; }
-    protected beforeUpdate(dt?: number, ...args: any[]) { dt; args; }
-    protected afterUpdate(dt?: number, ...args: any[]) { dt; args; }
-
-    protected log(...args: any[]) {
-        console.log(`[${this.ecsName}] [log]`, ...args);
-    }
-    protected warn(...args: any[]) {
-        console.warn(`[${this.ecsName}] [warn]`, ...args);
-    }
-    protected error(...args: any[]) {
-        console.error(`[${this.ecsName}] [error]`, ...args);
-    }
-}

package/assets/ecs/EcsSystem.ts.meta

@@ -1,9 +0,0 @@
-{
-  "ver": "4.0.24",
-  "importer": "typescript",
-  "imported": true,
-  "uuid": "0937d0e1-37d9-408b-940f-7e46779f90c7",
-  "files": [],
-  "subMetas": {},
-  "userData": {}
-}

package/assets/ecs.meta

@@ -1,12 +0,0 @@
-{
-  "ver": "1.2.0",
-  "importer": "directory",
-  "imported": true,
-  "uuid": "b27fed30-3c52-4d46-92cf-072148f885fe",
-  "files": [],
-  "subMetas": {},
-  "userData": {
-    "compressionType": {},
-    "isRemoteBundle": {}
-  }
-}