@cjhd/cj-ecs 1.0.0

package/.cj-ecs.md

@@ -0,0 +1,12 @@
+# ECS模块
+
+## 前置条件
+[游戏引擎](https://www.cocos.com/en/creator-download)
+[开发框架](https://github.com/a1076559139/cocos-creator-frame-3d)
+
+## 使用案例
+```TS
+import {} from 'db://pkg/@cjhd/cj-ecs';
+
+...
+```

package/assets/common/component/MoveComponent.ts

@@ -0,0 +1,292 @@
+import { math, Vec2 } from 'cc';
+import { EcsComponent } from '../../ecs/EcsComponent';
+import { ecsclass } from '../../lib/EcsManager';
+import { IEntity } from '../../lib/EcsObject';
+import { NodeComponent } from './NodeComponent';
+
+interface IOptions {
+    /**
+     * 允许旋转
+     * - 当rotate为true时，angle属性才会同步到NodeComponent
+     * @description 默认值: false
+     */
+    rotate: boolean;
+    /**
+     * 最小速度
+     * @description 单位: 像素/秒
+     * @description 默认值: -Infinity
+     * @description 取值范围: (-oo, +oo)
+     */
+    minSpeed: number;
+    /**
+     * 最大速度
+     * @description 单位: 像素/秒
+     * @description 默认值: Infinity
+     * @description 取值范围: (-oo, +oo)
+     */
+    maxSpeed: number;
+    /**
+     * 加速度
+     * @description 单位: 像素/秒
+     * @description 默认值: 0
+     * @description 取值范围: (-oo, +oo)
+     */
+    acceleratedVelocity: number;
+    /**
+     * 角速度(0表示无穷大)
+     * @description 单位: 度/秒
+     * @description 默认值: 0
+     * @description 取值范围: [0, +oo)
+     */
+    angleVelocity: number;
+}
+
+export interface IMoveComponent {
+    /**
+     * 选项参数
+     */
+    options: IOptions;
+    /**
+     * 最终的目标
+     * - taget与toward二选一, 且必须设置一个
+     * @description 默认值: null
+     */
+    target: NodeComponent;
+    /**
+     * 最终的角度
+     * - taget与toward二选一, 且必须设置一个
+     * @description 单位: 度
+     * @description 默认值: 0
+     * @description 取值范围: (-180, 180]
+     */
+    toward: number;
+    /**
+     * 当前速度
+     * @description 单位: 像素/秒
+     * @description 默认值: 0
+     * @description 取值范围: (-oo, +oo)
+     */
+    speed: number;
+    /**
+     * 当前角度
+     * @description 单位: 度
+     * @description 默认值: 0
+     * @description 取值范围: (-180, 180]
+     */
+    angle: number;
+    /**
+     * 总移动距离
+     * @description 单位: 像素
+     * @description 默认值: 0
+     * @description 取值范围: [0, +oo)
+     */
+    distance: number;
+}
+
+/**
+ * 移动方向(只给出了常用的方向)
+ * @description 单位: 度
+ * @description 取值范围: (-180, 180]
+ */
+export enum MoveTowardType {
+    Right = 0,
+    RightUp = 45,
+    Up = 90,
+    LeftUp = 135,
+    Left = 180,
+    LeftDown = -135,
+    Down = -90,
+    RightDown = -45
+}
+
+@ecsclass('EcsMoveComponent')
+export class MoveComponent<T extends IEntity = IEntity> extends EcsComponent<T> implements IMoveComponent {
+    static allowRecycling: boolean = true;
+
+    protected onRemove() {
+        this.reset();
+    }
+
+    public reset() {
+        this._target = null;
+        this._toward = null;
+        this._targetUUID = null;
+        this._angle = null;
+        this._speed = 0;
+        this._distance = 0;
+        this._options.rotate = false;
+        this._options.minSpeed = -Infinity;
+        this._options.maxSpeed = Infinity;
+        this._options.acceleratedVelocity = 0;
+        this._options.angleVelocity = 0;
+    }
+
+    private _options: IOptions = {
+        rotate: false,
+        minSpeed: -Infinity,
+        maxSpeed: Infinity,
+        acceleratedVelocity: 0,
+        angleVelocity: 0,
+    };
+    public get options(): IOptions {
+        return this._options;
+    }
+    public set options(value: IOptions) {
+        this._options = value;
+    }
+
+    // 总移动距离
+    private _distance = 0;
+    public get distance() {
+        return this._distance;
+    }
+    private set distance(value) {
+        this._distance = value;
+    }
+
+    // 最终目标
+    private _targetUUID: number = null;
+    private _target: NodeComponent = null;
+    public get target(): NodeComponent {
+        if (this._target && this._target.uuid !== this._targetUUID) {
+            this._target = null;
+        }
+        return this._target;
+    }
+    public set target(value: NodeComponent) {
+        this._target = (value && value.isValid) ? value : null;
+        if (this._target) {
+            this._targetUUID = this._target.uuid;
+        } else {
+            this._targetUUID = null;
+        }
+    }
+
+    // 最终朝向
+    private _toward: number = null;
+    public get toward(): number {
+        return this._toward;
+    }
+    public set toward(value: number) {
+        this._toward = MoveComponent.getAngleFromNeg180to180(value);
+    }
+
+    // 当前角度
+    private _angle: number = 0;
+    public get angle() {
+        return this._angle;
+    }
+    public set angle(value) {
+        this._angle = MoveComponent.getAngleFromNeg180to180(value);
+    }
+
+    // 当前速度
+    private _speed: number = 0;
+    public get speed(): number {
+        if (this._speed < this.options.minSpeed) {
+            this._speed = this.options.minSpeed;
+        } else if (this._speed > this.options.maxSpeed) {
+            this._speed = this.options.maxSpeed;
+        }
+        return this._speed;
+    }
+    public set speed(value: number) {
+        if (value < this.options.minSpeed) {
+            value = this.options.minSpeed;
+        } else if (value > this.options.maxSpeed) {
+            value = this.options.maxSpeed;
+        }
+        this._speed = value;
+    }
+
+    /**
+     * 获取self朝向other的角度
+     */
+    static getTowardAngle(self: NodeComponent, other: NodeComponent) {
+        if (!self) return 0;
+        if (!other) return 0;
+        return math.toDegree(Math.atan2(other.y - self.y,
+            other.x - self.x));
+    }
+
+    /**
+     * 修正到(-180, 180]
+     */
+    static getAngleFromNeg180to180(angle: number) {
+        if (angle >= 360 || angle <= -360) {
+            angle = angle % 360;
+        }
+        if (angle > 180) {
+            angle -= 360;
+        } else if (angle <= -180) {
+            angle += 360;
+        }
+        return angle;
+    }
+
+    /**
+     * 修正到[0, 360)
+     */
+    static getAngleFrom0To360(angle: number) {
+        if (angle >= 360 || angle <= -360) {
+            angle = angle % 360;
+        }
+        if (angle < 0) {
+            angle += 360;
+        }
+        return angle;
+    }
+
+    /**
+     * 修正到(-360, 0]
+     */
+    static getAngleFromNeg360To0(angle: number) {
+        if (angle >= 360 || angle <= -360) {
+            angle = angle % 360;
+        }
+        if (angle > 0) {
+            angle -= 360;
+        }
+        return angle;
+    }
+
+    /**
+     * 根据速度二维分量获取toward值
+     */
+    static getTowardByVelocity(velocity: Vec2) {
+        // y速度为0
+        if (velocity.y === 0) {
+            if (velocity.x >= 0) {
+                return MoveTowardType.Right;
+            } else {
+                return MoveTowardType.Left;
+            }
+        }
+        // x速度为0
+        if (velocity.x === 0) {
+            if (velocity.y >= 0) {
+                return MoveTowardType.Up;
+            } else {
+                return MoveTowardType.Down;
+            }
+        }
+        // x、y速度相等
+        if (velocity.x === velocity.y) {
+            if (velocity.x >= 0) {
+                return MoveTowardType.RightDown;
+            } else {
+                return MoveTowardType.LeftDown;
+            }
+        }
+        // x、y速度相反
+        if (velocity.x === -velocity.y) {
+            if (velocity.x >= 0) {
+                return MoveTowardType.RightUp;
+            } else {
+                return MoveTowardType.LeftUp;
+            }
+        }
+
+        return Vec2.UNIT_X.signAngle(velocity);
+    }
+}

package/assets/common/component/MoveComponent.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "df103063-9ec8-44d2-b8f4-2a6071f700ba",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/common/component/NodeComponent.ts

@@ -0,0 +1,315 @@
+import { Mat4, Quat, Rect, size, Size, UITransform, v2, v3, Vec2, Vec3 } from 'cc';
+import { EcsComponent } from '../../ecs/EcsComponent';
+import { ecsclass } from '../../lib/EcsManager';
+import { IEntity } from '../../lib/EcsObject';
+
+// export interface INodeReadonly {
+//     readonly uuid: number
+//     readonly isValid: boolean
+//     readonly isStrictValid: boolean
+//     readonly ecsName: string
+//     readonly allowMultiple: boolean
+//     readonly allowRecycling: boolean
+
+//     readonly boundingBox: Readonly<Rect>
+//     readonly minX: number
+//     readonly minY: number
+//     readonly maxX: number
+//     readonly maxY: number
+// }
+
+interface ILikeSize {
+    readonly width: number,
+    readonly height: number
+}
+
+interface ILikeV2 {
+    readonly x: number,
+    readonly y: number
+}
+
+interface ILikeV3 {
+    readonly x: number,
+    readonly y: number,
+    readonly z: number
+}
+const _matrix = new Mat4();
+
+@ecsclass('EcsNodeComponent')
+/**
+ * 负责位置、尺寸、缩放、锚点、旋转
+ */
+export class NodeComponent<T extends IEntity = IEntity> extends EcsComponent<T> {
+    static allowRecycling: boolean = true;
+
+    protected onRemove() {
+        this.reset();
+    }
+
+    public reset() {
+        this.$position.set(0, 0, 0);
+        this.$scale.set(1, 1, 1);
+        this.$anchorPoint.set(0.5, 0.5);
+        this.$contentSize.set(0, 0);
+        this.$lrot = new Quat();
+        this.$euler.set(0, 0, 0);
+    }
+
+    /**是否需要更新BoundingBox */
+    protected isBoundingBoxDirty = true;
+
+    // 坐标
+    protected $position: Vec3 = v3();
+    /**坐标 */
+    public get position(): Readonly<ILikeV3> {
+        return this.$position;
+    }
+    /**x坐标 */
+    public get x(): number {
+        return this.$position.x;
+    }
+    public set x(value: number) {
+        this.$position.x = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setPosition(this.$position);
+    }
+    /**y坐标 */
+    public get y(): number {
+        return this.$position.y;
+    }
+    public set y(value: number) {
+        this.$position.y = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setPosition(this.$position);
+    }
+    /**z坐标 */
+    public get z(): number {
+        return this.$position.z;
+    }
+    public set z(value: number) {
+        this.$position.z = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setPosition(this.$position);
+    }
+
+    // 缩放
+    protected $scale: Vec3 = v3(1, 1, 1);
+    /**缩放 */
+    public get scale(): Readonly<ILikeV3> {
+        return this.$scale;
+    }
+    /**缩放x */
+    public get scaleX(): number {
+        return this.$scale.x;
+    }
+    public set scaleX(value: number) {
+        this.$scale.x = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setScale(this.$scale);
+    }
+    /**缩放y */
+    public get scaleY(): number {
+        return this.$scale.y;
+    }
+    public set scaleY(value: number) {
+        this.$scale.y = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setScale(this.$scale);
+    }
+    /**缩放z */
+    public get scaleZ(): number {
+        return this.$scale.z;
+    }
+    public set scaleZ(value: number) {
+        this.$scale.z = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setScale(this.$scale);
+    }
+
+    // 锚点
+    protected $anchorPoint: Vec2 = v2(0.5, 0.5);
+    /**锚点 */
+    public get anchorPoint(): Readonly<ILikeV2> {
+        return this.$anchorPoint;
+    }
+    /**锚点x */
+    public get anchorX(): number {
+        return this.$anchorPoint.x;
+    }
+    public set anchorX(value: number) {
+        this.$anchorPoint.x = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.getComponent(UITransform)?.setAnchorPoint(this.$anchorPoint);
+    }
+    /**锚点y */
+    public get anchorY(): number {
+        return this.$anchorPoint.y;
+    }
+    public set anchorY(value: number) {
+        this.$anchorPoint.y = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.getComponent(UITransform)?.setAnchorPoint(this.$anchorPoint);
+    }
+
+    // 尺寸
+    protected $contentSize: Size = size();
+    /**尺寸 */
+    public get contentSize(): Readonly<ILikeSize> {
+        return this.$contentSize;
+    }
+    /**宽 */
+    public get width(): number {
+        return this.$contentSize.width;
+    }
+    public set width(value: number) {
+        this.$contentSize.width = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.getComponent(UITransform)?.setContentSize(this.$contentSize);
+    }
+    /**高 */
+    public get height(): number {
+        return this.$contentSize.height;
+    }
+    public set height(value: number) {
+        this.$contentSize.height = value;
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.getComponent(UITransform)?.setContentSize(this.$contentSize);
+    }
+
+    // 旋转四元数
+    protected $lrot = new Quat();
+    /**本地坐标系下的旋转，用四元数表示 */
+    public get rotation(): Readonly<Quat> {
+        return this.$lrot;
+    }
+    public set rotation(val) {
+        Quat.copy(this.$lrot, val);
+        Quat.toEuler(this.$euler, this.$lrot);
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setRotation(this.$lrot);
+    }
+
+    // 旋转欧拉角
+    protected $euler: Vec3 = v3();
+    /**本地坐标系下的旋转，用欧拉角表示 */
+    public get eulerAngles(): Readonly<Vec3> {
+        return this.$euler;
+    }
+    public set eulerAngles(val) {
+        Vec3.copy(this.$euler, val);
+        Quat.fromEuler(this.$lrot, val.x, val.y, val.z);
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setRotation(this.$lrot);
+    }
+
+    /**本地坐标系下的旋转，用欧拉角表示，但是限定在 z 轴上 */
+    public get angle(): number {
+        return this.$euler.z;
+    }
+    public set angle(value: number) {
+        this.$euler.z = value;
+        Quat.fromAngleZ(this.$lrot, value);
+        this.isBoundingBoxDirty = true;
+        this.entity?.node?.setRotation(this.$lrot);
+    }
+
+    private _boundingBox = new Rect();
+    private _boundingBoxOut = new Rect();
+    /**轴对称包围盒 */
+    get boundingBox(): Rect {
+        this._updateBoundingBox();
+        return this._boundingBoxOut.set(this._boundingBox);
+    }
+
+    protected _updateBoundingBox() {
+        if (!this.isBoundingBoxDirty) return;
+        this.isBoundingBoxDirty = false;
+
+        // selfBoundingBox
+        this._boundingBox.set(
+            -this.anchorPoint.x * this.width,
+            -this.anchorPoint.y * this.height,
+            this.width,
+            this.height,
+        );
+        // 矩阵变换
+        if (Mat4['fromSRT']) { // since 3.8.0
+            Mat4['fromSRT'](_matrix, this.rotation, this.position, this.scale);
+        } else {
+            Mat4.fromRTS(_matrix, this.rotation, this.position, this.scale);
+        }
+
+        this._boundingBox.transformMat4(_matrix);
+    }
+
+    /**最小x坐标 */
+    get minX() {
+        this._updateBoundingBox();
+        return this._boundingBox.xMin;
+    }
+    /**最小y坐标 */
+    get minY() {
+        this._updateBoundingBox();
+        return this._boundingBox.yMin;
+    }
+    /**最大x坐标 */
+    get maxX() {
+        this._updateBoundingBox();
+        return this._boundingBox.xMax;
+    }
+    /**最大y坐标 */
+    get maxY() {
+        this._updateBoundingBox();
+        return this._boundingBox.yMax;
+    }
+
+    public setPosition(x: number, y: number, z: number = this.z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+
+    public addPosition(x: number, y: number, z: number = 0) {
+        this.x += x;
+        this.y += y;
+        this.z += z;
+        return this;
+    }
+
+    public setScale(x: number, y: number, z: number = this.scaleZ) {
+        this.scaleX = x;
+        this.scaleY = y;
+        this.scaleZ = z;
+        return this;
+    }
+
+    public addScale(x: number, y: number, z: number = 0) {
+        this.scaleX += x;
+        this.scaleY += y;
+        this.scaleZ += z;
+        return this;
+    }
+
+    public setAngle(angle: number) {
+        this.angle = angle;
+        return this;
+    }
+
+    public addAngle(angle: number) {
+        this.angle += angle;
+        return this;
+    }
+
+    public setContentSize(width: number, height: number) {
+        this.width = width;
+        this.height = height;
+        return this;
+    }
+
+    public setAnchorPoints(x: number, y: number) {
+        this.anchorX = x;
+        this.anchorY = y;
+        return this;
+    }
+}

package/assets/common/component/NodeComponent.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "6b13f976-03a7-4ed1-8976-c35d2a8bba38",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/common/component.meta

@@ -0,0 +1,12 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "acc24fdc-cdd3-4072-a9e2-fb2155e9656f",
+  "files": [],
+  "subMetas": {},
+  "userData": {
+    "compressionType": {},
+    "isRemoteBundle": {}
+  }
+}