@cjhd/cj-ecs 1.0.0

package/assets/lib/EcsObject.ts

@@ -0,0 +1,422 @@
+import { Node } from 'cc';
+import type { EcsDirtyMask, IEcsComponentDirtySink, IEcsObservedQuery } from '../ecs/EcsDirty';
+import { UuidMaker } from './EcsUtils';
+
+/**
+ * 过滤器
+ */
+export interface IFilter {
+    /**
+     * 有这些组件中的任何一个
+     */
+    any(...args: ITypeofComponent[]): this
+    /**
+     * 必须包含所有这些组件
+     * - 让数量最少的组件作为第一个参数，会获得更好的性能
+     */
+    all(...args: ITypeofComponent[]): this
+    /**
+     * 仅仅只有这些组件
+     * - 让数量最少的组件作为第一个参数，会获得更好的性能
+     */
+    only(...args: ITypeofComponent[]): this
+    /**
+     * 不能包含其中的任何一个组件
+     */
+    exclude(...args: ITypeofComponent[]): this
+}
+
+/**uuid生成器 */
+export const entityUuidMaker = new UuidMaker();
+export const componentUuidMaker = new UuidMaker();
+export const systemUuidMaker = new UuidMaker();
+export const singletonUuidMaker = new UuidMaker();
+
+export abstract class EcsBase {
+    /**类名 */
+    static ecsName = 'EcsBase';
+    /**类名 */
+    public get ecsName() {
+        return (this.constructor as typeof EcsBase).ecsName;
+    }
+}
+
+/**实体基类 */
+export abstract class EcsBaseEntity extends EcsBase {
+    static updateUUID(ins: EcsBaseEntity) {
+        ins._uuid = entityUuidMaker.create();
+    }
+
+    static init(entity: EcsBaseEntity, ecs: IECS, node: Node | null = null) {
+        return entity.innerInit(ecs, node);
+    }
+
+    static addComponent(entity: EcsBaseEntity, com: IComponent) {
+        return entity.innerAddComponent(com);
+    }
+
+    static removeComponent(entity: EcsBaseEntity, com: IComponent) {
+        return entity.innerRemoveComponent(com);
+    }
+
+    /**唯一ID */
+    private _uuid = entityUuidMaker.create();
+    public get uuid() {
+        return this._uuid;
+    }
+
+    /**允许回收复用(默认false) */
+    static allowRecycling = false;
+    /**允许回收复用(默认false) */
+    public get allowRecycling() {
+        return (this.constructor as typeof EcsBaseEntity).allowRecycling;
+    }
+
+    /**添加*/
+    protected abstract onAdd(): any;
+    /**生效*/
+    protected abstract onEnable(): any;
+    /**失效*/
+    protected abstract onDisable(): any;
+    /**移除*/
+    protected abstract onRemove(): any;
+
+    /**
+     * 内部初始化函数
+     */
+    protected abstract innerInit(ecs: IECS, node?: Node | null): void;
+
+    /**
+     * 添加组件(内部调用)
+     */
+    protected abstract innerAddComponent(com: IComponent): void;
+
+    /**
+     * 移除组件(内部调用)
+     */
+    protected abstract innerRemoveComponent(com: IComponent): void;
+}
+
+/**组件基类 */
+export abstract class EcsBaseComponent extends EcsBase {
+    /**内部函数 */
+    static updateUUID(ins: EcsBaseComponent) {
+        ins._uuid = componentUuidMaker.create();
+    }
+
+    /**唯一ID */
+    private _uuid = componentUuidMaker.create();
+    public get uuid() {
+        return this._uuid;
+    }
+
+    /**允许回收复用(默认false) */
+    static allowRecycling = false;
+    /**允许回收复用(默认false) */
+    public get allowRecycling() {
+        return (this.constructor as typeof EcsBaseComponent).allowRecycling;
+    }
+
+    /**允许在同一个实体中重复添加(默认false)  */
+    static allowMultiple = false;
+    /**允许在同一个实体中重复添加(默认false) */
+    public get allowMultiple() {
+        return (this.constructor as typeof EcsBaseComponent).allowMultiple;
+    }
+
+    /**添加*/
+    protected abstract onAdd(): any;
+    /**生效*/
+    protected abstract onEnable(): any;
+    /**失效*/
+    protected abstract onDisable(): any;
+    /**移除*/
+    protected abstract onRemove(): any;
+}
+
+/**系统基类 */
+export abstract class EcsBaseSystem extends EcsBase {
+    /**唯一ID */
+    private _uuid = systemUuidMaker.create();
+    public get uuid() {
+        return this._uuid;
+    }
+
+    static onAdd(system: EcsBaseSystem) {
+        system.onAdd();
+    }
+
+    static onRemove(system: EcsBaseSystem) {
+        system.onRemove();
+    }
+
+    static execute(system: EcsBaseSystem, dt: number, args: any[]) {
+        system.execute(dt, ...args);
+    }
+
+    static beforeExecute(system: EcsBaseSystem, dt: number, args: any[]) {
+        system.beforeExecute(dt, ...args);
+    }
+
+    static afterExecute(system: EcsBaseSystem, dt: number, args: any[]) {
+        system.afterExecute(dt, ...args);
+    }
+
+    static update(system: EcsBaseSystem, dt: number, args: any[]) {
+        system.update(dt, ...args);
+    }
+
+    static beforeUpdate(system: EcsBaseSystem, dt: number, args: any[]) {
+        system.beforeUpdate(dt, ...args);
+    }
+
+    static afterUpdate(system: EcsBaseSystem, dt: number, args: any[]) {
+        system.afterUpdate(dt, ...args);
+    }
+
+    /**添加*/
+    protected abstract onAdd(): any;
+    /**移除*/
+    protected abstract onRemove(): any;
+
+    protected abstract execute(dt?: number, ...args: any[]): any;
+    protected abstract beforeExecute(dt?: number, ...args: any[]): any;
+    protected abstract afterExecute(dt?: number, ...args: any[]): any;
+
+    // 由ecs.update驱动
+    protected abstract update(dt?: number, ...args: any[]): any;
+    protected abstract beforeUpdate(dt?: number, ...args: any[]): any;
+    protected abstract afterUpdate(dt?: number, ...args: any[]): any;
+}
+
+/**单例基类 */
+export abstract class EcsBaseSingleton extends EcsBase {
+    /**唯一ID */
+    private _uuid = singletonUuidMaker.create();
+    public get uuid() {
+        return this._uuid;
+    }
+}
+
+export type IEntityUUID = number;
+export type IComponentName = string;
+export type IComponentUUID = number;
+export type IFlag = number[];
+
+export type ITypeofEntity = { new(): IEntity, ecsName: string, allowRecycling: boolean };
+export type ITypeofComponent = { new(): IComponent, ecsName: string, allowRecycling: boolean, allowMultiple: boolean };
+export type ITypeofSystem = { new(ecs: IECS): ISystem, ecsName: string };
+export type ITypeofSingleton = { new(): ISingleton, ecsName: string };
+
+export interface IEntity extends EcsBaseEntity {
+    /**
+     * 是否有效
+    */
+    readonly isValid: boolean
+    /**
+     * 绑定的节点
+     */
+    node: Node | null
+    /**
+     * 标记是否生效(为false后将不会被查询到)
+     */
+    enabled: boolean
+    /**
+     * 销毁
+     * 会在触发onDisable和移除所有组件之后才会isValid设为false
+     */
+    destroy(): boolean
+    /**
+     * 检查是否仅包含全部
+     */
+    checkFlagAll(flag: IFlag): boolean
+    /**
+     * 检查是否包含任一
+     */
+    checkFlagAny(flag: IFlag): boolean
+    /**
+     * 检查是否仅包含全部
+     */
+    checkFlagOnly(flag: IFlag): boolean
+    /**
+     * 是否存在指定名字的启用组件
+     */
+    hasEnabledComponentName(componentName: IComponentName): boolean
+    /**
+     * 添加相应类型的组件
+     * @see 同add
+     * @param param 类型
+     */
+    addComponent<T extends ITypeofComponent>(Com: T): InstanceType<T> | null
+    /**
+     * 添加相应类型的组件
+     * @param param 类型
+     * @returns 
+     */
+    add<T extends ITypeofComponent>(Com: T): InstanceType<T> | null
+    /**
+     * 移除相应类型的第一个组件
+     * @see 同remove
+     * @param param 类型
+     */
+    removeComponent(Com: ITypeofComponent | IComponent): boolean
+    /**
+     * 移除相应类型的第一个组件
+     * @param param 类型
+     */
+    remove(Com: ITypeofComponent | IComponent): boolean
+    /**
+     * 移除相应组件的所有组件
+     * @see 同removeAll
+     * @param Com 类型
+     */
+    removeComponents(Com: ITypeofComponent): boolean;
+    /**
+     * 移除相应组件的所有组件
+     * @param Com 类型
+     * @returns 
+     */
+    removeAll(Com: ITypeofComponent): boolean;
+    /**
+     * 有没有相应类型的组件
+     * @see 同has
+     */
+    hasComponent(Com: ITypeofComponent): boolean
+    /**
+     * 有没有相应类型的组件
+     */
+    has(Com: ITypeofComponent): boolean
+    /**
+     * 获取相应类型的组件
+     * @see 同get
+     */
+    getComponent<T extends ITypeofComponent>(Com: T): InstanceType<T> | null
+    /**
+     * 获取相应类型的组件
+     */
+    get<T extends ITypeofComponent>(Com: T): InstanceType<T> | null
+    /**
+     * 获取相应类型的组件
+     * @see 同getAll
+     */
+    getComponents<T extends ITypeofComponent>(Com: T): InstanceType<T>[]
+    /**
+     * 获取相应类型的组件
+     */
+    getAll<T extends ITypeofComponent>(Com: T): InstanceType<T>[]
+}
+
+export interface IComponent<E extends IEntity = IEntity> extends EcsBaseComponent {
+    /**是否有效*/
+    readonly isValid: boolean
+
+    /**是否有效(如果当前正处于销毁流程中，也会返回false)*/
+    readonly isStrictValid: boolean
+
+    /**
+     * 标记是否生效(为false代表不会被查询到)
+     */
+    enabled: boolean
+    /**
+     * 表示该组件是否被启用并且所在的实体也处于启用状态(为false代表不会被查询到)
+     */
+    readonly enabledInHierarchy: boolean
+    /**当前组件所在的实体 */
+    readonly entity: E | null;
+    readonly dirty: boolean;
+    readonly dirtyMask: EcsDirtyMask;
+    readonly dirtyVersion: number;
+    hasDirty(mask: EcsDirtyMask): boolean;
+    markDirty(mask?: EcsDirtyMask): void;
+    clearDirty(mask?: EcsDirtyMask): void;
+    clearDirtySilent(): void;
+    /**销毁当前组件 */
+    destroy(): boolean;
+}
+
+export type ISystem = EcsBaseSystem;
+
+export type ISingleton = EcsBaseSingleton;
+
+export interface IECS {
+    /**
+     * 查询实体
+     */
+    query<T extends IEntity>(filter: IFilter): T[];
+    query<T extends IComponent>(filter: IFilter, Component: { new(): T }): T[];
+    query<T>(filter: IFilter, Component?: ITypeofComponent): T[];
+    /**
+     * 查询实体
+     */
+    find<T extends IEntity>(filter: IFilter): T;
+    find<T extends IComponent>(filter: IFilter, Component: { new(): T }): T;
+    find<T>(filter: IFilter, Component?: ITypeofComponent): T;
+    /**
+     * 查询实体是否存在
+     */
+    exist(filter: IFilter): boolean;
+    /**
+     * 根据uuid查询实体
+     */
+    findByUuid(uuid: IEntityUUID): IEntity | null;
+    /**
+     * 根据uuid查询实体是否存在
+     */
+    existByUuid(uuid: IEntityUUID): boolean;
+    /**
+     * 添加系统
+     */
+    addSystem<T extends ITypeofSystem>(System: T): void
+    /**
+     * 移除系统
+     */
+    removeSystem<T extends ITypeofSystem>(System: T): void
+    /**
+     * 添加单例组件
+     */
+    addSingleton<T extends ITypeofSingleton>(param: T): InstanceType<T>
+    /**
+     * 添加单例组件
+     */
+    addSingleton<T extends ISingleton>(param: T): T
+    /**
+     * 获取单例组件
+     */
+    getSingleton<T extends ITypeofSingleton>(param: T): InstanceType<T> | null
+    /**
+     * 移除单例组件
+     */
+    removeSingleton<T extends ITypeofSingleton>(param: T): InstanceType<T> | null
+    /**
+     * 创建一个实体
+     */
+    createEntity<T extends ITypeofEntity>(Entity: T, options?: Node | { node?: Node }): InstanceType<T>
+    /**
+     * 清理系统、实体、组件、单例组件(都不会触发生命周期)
+     */
+    clear(): any
+    /**
+     * 开始批量组件增删，延迟刷新系统 matcher
+     */
+    beginMutation(): void
+    /**
+     * 结束批量组件增删，并刷新受影响实体的系统 matcher
+     */
+    endMutation(): void
+    setDirtySink(sink: IEcsComponentDirtySink | null): void
+    getDirtySink(): IEcsComponentDirtySink | null
+    setObservedQuery(query: IEcsObservedQuery | null): void
+    getObservedQuery(): IEcsObservedQuery | null
+    /**
+     * 用于逻辑帧
+     * 执行顺序:
+     * [系统的beforeExecute] -> [系统的execute] ->[系统的afterExecute]
+     */
+    execute(dt: number, ...args: any[]): any
+    /**
+     * 用于渲染帧
+     * 执行顺序:
+     * [系统的beforeUpdate] -> [系统的update] -> [系统的afterUpdate]
+     */
+    update(dt: number, ...args: any[]): any
+}

package/assets/lib/EcsObject.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "b4f0d986-c6b7-480c-8dc1-c0286b01d114",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/lib/EcsTimer.ts

@@ -0,0 +1,239 @@
+import { EcsBase } from './EcsObject';
+
+interface ICallback {
+    (...args: any[]): any
+}
+
+let tid = 0;
+
+/**
+ * 定时器
+ */
+export class Timer {
+    static step(timer: Timer, dt: number) {
+        timer.time += dt;
+
+        if (timer.first) {
+            if (timer.time < timer._delay) return true;
+            timer.first = false;
+            timer.time = 0;
+        } else if (timer.time < timer._interval) {
+            return true;
+        } else {
+            timer.time = 0;
+        }
+
+        timer.callback.call(timer.target);
+
+        // 执行次数达到上限，则移除
+        if (timer._repeat >= 0 && --timer._repeat < 0) {
+            return false;
+        }
+
+        return true;
+    }
+
+    private _id = ++tid;
+    public get id() {
+        return this._id;
+    }
+
+    /**是否执行过 */
+    private first = true;
+    /**执行计时 */
+    private time = 0;
+
+    /**回调函数 */
+    private callback!: ICallback;
+    private _target: EcsBase | null = null;
+    public get target(): EcsBase | null {
+        return this._target;
+    }
+
+    /**首次执行的延迟时间 */
+    private _delay = 0;
+
+    /**重复执行的间隔时间 */
+    private _interval = 0;
+
+    /**重复执行次数(<0为无限次) */
+    private _repeat = -1;
+
+    constructor(callback: ICallback, target: EcsBase | null = null) {
+        this._target = target;
+        this.callback = callback;
+    }
+
+    /**
+     * 首次执行延迟时间
+     * @param value 
+     * @returns 
+     */
+    delay(value: number) {
+        this._delay = Math.max(0, value);
+        return this;
+    }
+
+    /**
+     * 重复执行间隔时间
+     * @param value 
+     * @returns 
+     */
+    interval(value: number) {
+        this._interval = Math.max(0, value);
+        return this;
+    }
+
+    /**
+     * 重复执行次数(<0为无限次)
+     * - 初始值为-1
+     * - 实际执行次数为repeat + 1
+     * @param value 
+     * @returns 
+     */
+    repeat(value: number) {
+        this._repeat = value;
+        return this;
+    }
+}
+
+/**
+ * 创建一个定时器
+ */
+export function timer(callback: ICallback, target: EcsBase | null = null) {
+    return new Timer(callback, target);
+}
+
+/**
+ * 定时器管理器
+ */
+export class TimerManager {
+    private map = new Map<number, Timer>();
+    private pausing = new Map<number, true>();
+
+    /**
+     * 添加定时器
+     * @param timer 
+     * @returns id 永远大于0
+     */
+    add(timer: Timer) {
+        this.map.set(timer.id, timer);
+        return timer.id;
+    }
+
+    /**
+     * 移除指定的定时器
+     * @param id 
+     */
+    remove(id: number): void;
+    /**
+     * 移除指定的定时器
+     * @param timer 
+     */
+    remove(timer: Timer): void;
+    /**
+     * 移除指定的定时器
+     * @param target 
+     */
+    remove(target: EcsBase): void;
+    remove(param: number | Timer | EcsBase) {
+        if (typeof param === 'number') {
+            this.map.delete(param);
+            this.pausing.delete(param);
+        } else if (param instanceof Timer) {
+            this.map.delete(param.id);
+            this.pausing.delete(param.id);
+        } else {
+            this.map.forEach((tween, tid) => {
+                if (tween.target === param) {
+                    this.map.delete(tid);
+                    this.pausing.delete(tid);
+                }
+            });
+        }
+    }
+
+    /**
+     * 暂停指定的定时器
+     * @param id 
+     */
+    pause(id: number): void;
+    /**
+     * 暂停指定的定时器
+     * @param timer 
+     */
+    pause(timer: Timer): void;
+    /**
+     * 暂停指定的定时器
+     * @param target 
+     */
+    pause(target: EcsBase): void;
+    pause(param: number | Timer | EcsBase) {
+        if (typeof param === 'number') {
+            this.pausing.set(param, true);
+        } else if (param instanceof Timer) {
+            this.pausing.set(param.id, true);
+        } else {
+            this.map.forEach((tween, tid) => {
+                if (tween.target === param) {
+                    this.pausing.set(tid, true);
+                }
+            });
+        }
+    }
+
+    /**
+     * 恢复指定的定时器
+     * @param id 
+     */
+    resume(id: number): void;
+    /**
+     * 恢复指定的定时器
+     * @param timer 
+     */
+    resume(timer: Timer): void;
+    /**
+     * 恢复指定的定时器
+     * @param target 
+     */
+    resume(target: EcsBase): void;
+    resume(param: number | Timer | EcsBase) {
+        if (typeof param === 'number') {
+            this.pausing.delete(param);
+        } else if (param instanceof Timer) {
+            this.pausing.delete(param.id);
+        } else {
+            this.map.forEach((tween, tid) => {
+                if (tween.target === param) {
+                    this.pausing.delete(tid);
+                }
+            });
+        }
+    }
+
+    /**
+     * 迭代一次
+     */
+    step(dt: number) {
+        this.map.forEach((timer, tid) => {
+            // 暂停中，则跳过
+            if (this.pausing.has(tid)) return;
+            // 执行次数达到上限，则移除
+            if (Timer.step(timer, dt) === false) {
+                this.map.delete(tid);
+            }
+        });
+    }
+
+    get size() {
+        return this.map.size;
+    }
+
+    /**
+     * 清空
+     */
+    clear() {
+        this.map.clear();
+        this.pausing.clear();
+    }
+}

package/assets/lib/EcsTimer.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "43fe9bc7-581e-48e6-8d45-b2584ae5cbd7",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}