@cjhd/cj-ecs 1.0.0 → 1.0.1

package/assets/lib/EcsManager.ts

@@ -1,502 +0,0 @@
-import { DEV } from 'cc/env';
-import { EcsBase, EcsBaseComponent, EcsBaseSingleton, IComponent, IComponentName, IEntity, IEntityUUID, IFlag, ISystem, ITypeofSystem } from './EcsObject';
-import { CustomArray } from './EcsUtils';
-
-/**
- * 根据名获取类，用于通过组件名字获取组件类
- */
-export function getClassByName(name: IComponentName) {
-    return classManager.getClassByName(name);
-}
-
-/**
- * 类装饰器(组件与单例组件必须使用ecsclass)
- */
-export function ecsclass(className: string) {
-    return function fNOP(ctor: any) {
-        // ecsName需要先初始化
-        (<typeof EcsBase>ctor).ecsName = className;
-        classManager.add(ctor, className);
-        return ctor;
-    };
-}
-
-/**
- * flag位管理器
-*/
-class FlagManager {
-    private index: number = 0;
-    private cache: Map<string, IFlag> = new Map();
-    private cacheAll: Map<string, IFlag> = new Map();
-
-    /**
-     * 在source中添加flag
-     * @param source 
-     * @param flag 
-     */
-    addFlag(source: IFlag, flag: IFlag) {
-        for (let index = 0; index < flag.length; index++) {
-            source[index] |= flag[index];
-        }
-    }
-    /**
-     * 在source中移除flag
-     * @param source 
-     * @param flag 
-     */
-    removeFlag(source: IFlag, flag: IFlag) {
-        for (let index = 0; index < flag.length; index++) {
-            source[index] &= ~flag[index];
-        }
-    }
-
-    /**
-     * 检查是否完全包含
-     * @param source 源
-     * @param sub 子集
-     * @returns 是否完全包含子集
-     */
-    checkFlagAll(source: IFlag, sub: IFlag) {
-        for (let index = 0; index < sub.length; index++) {
-            if ((source[index] & sub[index]) !== sub[index]) return false;
-        }
-        return true;
-    }
-    /**
-     * 只包含其中一个即可
-     * @param source 源
-     * @param sub 子集
-     * @returns 是否包含其中一个
-     */
-    checkFlagAny(source: IFlag, sub: IFlag) {
-        for (let index = 0; index < sub.length; index++) {
-            if ((source[index] & sub[index]) != 0) return true;
-        }
-        return false;
-    }
-
-    /**
-     * 会融合父类的flag位
-     * @param name 组件类型名
-     * @returns 组件类型的flag位数组
-     */
-    getAllByName(name: string): IFlag {
-        const result = this.cacheAll.get(name);
-        if (result) return result;
-
-        const names = [name];
-        classManager.eachSuperName(name, (superName) => {
-            names.push(superName);
-        });
-
-        const flag = this.getByNames(names);
-        this.cacheAll.set(name, flag);
-
-        return flag;
-    }
-
-    /**
-     * 会融合父类的flag位
-     * @param names 组件类型名数组
-     * @param out 输出数组，用于存储融合后的flag位
-     * @returns 输出数组
-     */
-    getAllByNames(names: string[], out: number[]): IFlag {
-        // 设置初始值
-        let flag = this.getAllByName(names[0]);
-        for (let index = 0; index < out.length; index++) {
-            out[index] = flag[index];
-        }
-        // 叠加
-        for (let i = 1; i < names.length; i++) {
-            flag = this.getAllByName(names[i]);
-            for (let index = 0; index < out.length; index++) {
-                out[index] = out[index] | flag[index];
-            }
-        }
-        return out;
-    }
-
-    /**
-     * 只计算自身的flag位
-     * @param name 组件类型名
-     * @returns 组件类型的flag位数组
-     */
-    getByName(name: string): IFlag {
-        const result = this.cache.get(name);
-        if (result) return result;
-
-        const FlagBits = this.bits;
-
-        if (DEV && this.index >= FlagBits * 31) {
-            throw new Error(`当前Component的种类超过${FlagBits * 31}个`);
-        }
-
-        const flag: IFlag = new Array(FlagBits).fill(0);
-        flag[(this.index / 31) >>> 0] = (1 << (this.index % 31));
-        this.cache.set(name, flag);
-        this.index++;
-
-        return flag;
-    }
-
-    /**
-     * 只计算自身的flag位
-     * @param names 组件类型名数组
-     * @returns 组件类型的flag位数组
-     */
-    getByNames(names: string[]): IFlag {
-        const result = new Array(this.bits);
-        // 设置初始值
-        let flag = this.getByName(names[0]);
-        for (let index = 0; index < result.length; index++) {
-            result[index] = flag[index];
-        }
-        // 叠加
-        for (let i = 1; i < names.length; i++) {
-            flag = this.getByName(names[i]);
-            for (let index = 0; index < result.length; index++) {
-                result[index] = result[index] | flag[index];
-            }
-        }
-        return result;
-    }
-
-    /**
-     * 获取flag位数量
-     * @returns flag位数量
-     */
-    get bits() {
-        return Math.ceil(classManager.comSize / 31);
-    }
-}
-export const flagManager = new FlagManager();
-
-/**
- * 类管理器
- */
-class ClassManager {
-
-    /** 组件类数量 */
-    private comClassCount = 0;
-
-    /** 类名到父类名的映射 */
-    private nameToSuperName: Map<string, string> = new Map();
-
-    /** 类名到类的映射 */
-    private nameToClass: Map<string, typeof EcsBase> = new Map();
-
-    /**
-     * 获取父类
-     * @param type 类
-     * @returns 父类类型
-     */
-    private getSuper<T extends typeof EcsBase>(type: T): T {
-        if (!type || !type.prototype) return null;
-        const proto = type.prototype; // binded function do not have prototype
-        const dunderProto = proto && Object.getPrototypeOf(proto);
-        return dunderProto && dunderProto.constructor;
-    }
-
-    /**
-     * 添加一个类
-     * @param ctor 类构造函数
-     * @param className 类名
-     */
-    add(ctor: typeof EcsBase, className: string) {
-        if (DEV && this.nameToClass.has(className)) {
-            console.error(`[ecs] ${className}已存在`);
-        }
-        this.nameToClass.set(className, ctor);
-
-        // 存储类名继承对应关系
-        let superCls = this.getSuper(ctor);
-        while (superCls && superCls.ecsName !== EcsBase.ecsName) {
-            if (DEV && className === superCls.ecsName) {
-                console.error(`[ecs] 请使用ecsclass修饰\n @ecsclass('${ctor.name}')\n`, ctor);
-                return;
-            }
-            this.nameToSuperName.set(className, superCls.ecsName);
-            superCls = this.getSuper(ctor = superCls);
-            className = ctor.ecsName;
-        }
-
-        if (superCls === EcsBaseComponent) {
-            this.comClassCount++;
-        } else if (DEV && superCls !== EcsBaseSingleton) {
-            // console.warn('[ecs] 避免用ecsclass修饰系统或实体', className);
-        }
-    }
-
-    /**
-     * 遍历所有父类名，包括当前类
-     * @param subName 子类名
-     * @param callback 处理函数，用于对每个父类名进行操作
-     */
-    eachSuperName(subName: string, callback: (superName: string) => any) {
-        while (subName) {
-            const superName = this.getSuperName(subName);
-            if (!superName) break;
-            callback(subName = superName);
-        }
-    }
-
-    /**
-     * 通过类名判断一个是否是另一个的子类
-     * @param subName 子类名
-     * @param superName 父类名
-     * @returns 是否是子类
-     */
-    isChildByName(subName: string, superName: string) {
-        if (!subName) return false;
-        if (!superName) return false;
-
-        while (subName) {
-            const _superName = this.getSuperName(subName);
-            if (_superName === superName) return true;
-            subName = _superName;
-        }
-
-        return false;
-    }
-
-    /**
-     * 通过类名获取一个类
-     * @param name 类名
-     * @returns 类
-     */
-    getClassByName(name: string) {
-        return this.nameToClass.get(name);
-    }
-
-    /**
-     * 获取父类名字
-     * @param name 类名
-     * @returns 父类名
-     */
-    getSuperName(name: string) {
-        return this.nameToSuperName.get(name) || '';
-    }
-
-    /**
-     * 组件种类数量
-     */
-    get comSize() {
-        return this.comClassCount;
-    }
-}
-/**类管理器 */
-export const classManager = new ClassManager();
-
-/**
- * 组件管理器
- */
-export class ComponentManager {
-
-    /** 组件名到组件列表的映射 */
-    private components: Map<IComponentName, CustomArray<IComponent>> = new Map();
-
-    /**
-     * 获取或创建组件列表
-     * @param name 组件名
-     * @returns 组件列表
-     */
-    private getOrCreateComps(name: IComponentName) {
-        if (!this.components.has(name)) {
-            this.components.set(name, new CustomArray<IComponent>());
-        }
-        return this.components.get(name);
-    }
-
-    /**
-     * 添加一个组件名对应的实体
-     * @param comName 组件名
-     * @param comp 组件
-     */
-    addComponent(comName: IComponentName, comp: IComponent) {
-        if (!comName) return;
-
-        // 添加当前
-        this.getOrCreateComps(comName).add(comp);
-
-        // 添加基类
-        this.addComponent(classManager.getSuperName(comName), comp);
-    }
-
-    /**
-     * 移除一个组件名对应的实体
-     * @param comName 组件名
-     * @param comp 组件
-     */
-    removeComponent(comName: IComponentName, comp: IComponent) {
-        if (!comName) return;
-
-        // 删除当前
-        if (!this.components.has(comName)) return;
-        this.getOrCreateComps(comName).remove(comp);
-
-        // 删除基类
-        this.removeComponent(classManager.getSuperName(comName), comp);
-    }
-
-    /**
-     * 根据组件名获取实体列表，可能不存在
-     * @param comName 组件名
-     * @returns 组件列表
-     */
-    getComponents(comName: IComponentName) {
-        return this.components.get(comName) || null;
-    }
-
-    /**
-     * 清空所有组件
-     */
-    clear() {
-        this.components.forEach(value => value.clear());
-        this.components.clear();
-    }
-
-    /**
-     * @param callback 处理函数，用于对每个组件进行操作
-     * @returns 输出数组
-     */
-    eachUnique(callback: (component: IComponent) => void) {
-        const visited: Map<number, boolean> = new Map();
-        this.components.forEach((components) => {
-            components.forEach((component) => {
-                if (visited.has(component.uuid)) return;
-                visited.set(component.uuid, true);
-                callback(component);
-            });
-        });
-    }
-}
-
-/**
- * 实体管理器
- */
-export class EntityManager {
-
-    /** 实体UUID到实体的映射 */
-    private entities: Map<IEntityUUID, IEntity> = new Map();
-
-    /**
-     * 检查实体是否存在
-     * @param uuid 实体UUID
-     * @returns 是否存在
-     */
-    has(uuid: IEntityUUID) {
-        return this.entities.get(uuid) || null;
-    }
-
-    /**
-     * 添加一个实体
-     * @param entity 实体
-     */
-    add(entity: IEntity) {
-        this.entities.set(entity.uuid, entity);
-    }
-
-    /**
-     * 移除一个实体
-     * @param entity 实体
-     * @returns 是否成功移除
-     */
-    remove(entity: IEntity) {
-        return this.entities.delete(entity.uuid);
-    }
-
-    /**
-     * 根据UUID获取一个实体
-     * @param uuid 实体UUID
-     * @returns 实体
-     */
-    get(uuid: IEntityUUID) {
-        return this.entities.get(uuid) || null;
-    }
-
-    /**
-     * 获取所有实体
-     * @param out 输出数组，用于存储所有实体
-     * @returns 输出数组
-     */
-    getAll(out: IEntity[]) {
-        this.entities.forEach(entity => out.push(entity));
-        return out;
-    }
-
-    /**
-     * 遍历所有实体
-     * @param callback 处理函数，用于对每个实体进行操作
-     */
-    each(callback: (value: IEntity) => void) {
-        this.entities.forEach(callback);
-    }
-
-    /**
-     * 清空所有实体
-     */
-    clear() {
-        this.entities.clear();
-    }
-}
-
-/**
- * 系统管理器
- */
-export class SystemManager {
-    private systems: ISystem[] = [];
-
-    /**
-     * 添加一个系统
-     * @param system 系统
-     */
-    add(system: ISystem) {
-        this.systems.push(system);
-    }
-
-    /**
-     * 根据系统名获取一个系统
-     * @param System 系统类型
-     * @returns 系统
-     */
-    get(System: ITypeofSystem) {
-        const index = this.systems.findIndex(system => system.ecsName === System.ecsName);
-        return this.systems[index];
-    }
-
-    /**
-     * 移除一个系统
-     * @param System 系统类型
-     * @returns 是否成功移除
-     */
-    remove(System: ITypeofSystem) {
-        const index = this.systems.findIndex(system => system.ecsName === System.ecsName);
-        if (index >= 0) {
-            return this.systems.splice(index, 1)[0] || null;
-        }
-        return null;
-    }
-
-    /**
-     * 清空所有系统
-     */
-    clear() {
-        this.systems.length = 0;
-    }
-
-    /**
-     * 遍历所有系统
-     * @param callback 处理函数，用于对每个系统进行操作
-     */
-    each(callback: (value: ISystem) => void) {
-        this.systems.forEach(callback);
-    }
-
-    /**
-     * 系统数量
-     */
-    get size() {
-        return this.systems.length;
-    }
-}

package/assets/lib/EcsManager.ts.meta

@@ -1,9 +0,0 @@
-{
-  "ver": "4.0.24",
-  "importer": "typescript",
-  "imported": true,
-  "uuid": "809afa16-d8c6-47de-9b8b-34dbcce2f6b0",
-  "files": [],
-  "subMetas": {},
-  "userData": {}
-}

package/assets/lib/EcsObject.ts.meta

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