@safe-engine/cocos 2.3.10 → 2.4.0

package/dist/chipmunk/PhysicsComponent.d.ts

@@ -0,0 +1,49 @@
+import { BaseComponentProps } from '..';
+import { ComponentX } from '../core/decorator';
+import { Vec2 } from '../polyfills';
+import { PhysicsSprite } from './PhysicsSprite';
+interface RigidBodyProps {
+    type?: 0 | 1 | 2;
+    density?: Float;
+    restitution?: Float;
+    friction?: Float;
+    gravityScale?: Float;
+    isSensor?: boolean;
+    tag?: number;
+    onBeginContact?: (other: RigidBody) => void;
+    onEndContact?: (other: RigidBody) => void;
+    onPreSolve?: (other: RigidBody, impulse?: any) => void;
+    onPostSolve?: (other: RigidBody, oldManifold?: any) => void;
+}
+export declare class RigidBody extends ComponentX<RigidBodyProps> {
+    body: cp.Body;
+    physicSprite: PhysicsSprite;
+    set linearVelocity(vel: Vec2);
+    get linearVelocity(): Vec2;
+    applyForceTo(vel: Vec2, pos?: Vec2): void;
+    applyLinearImpulse(vel: Vec2, pos?: Vec2): void;
+    applyTorque(torque: Float): void;
+    set position(pos: Vec2);
+    get position(): Vec2;
+}
+interface BoxColliderPhysicsProps {
+    width: number;
+    height: number;
+    offset?: [number, number];
+}
+export declare class PhysicsBoxCollider extends ComponentX<BoxColliderPhysicsProps & BaseComponentProps<PhysicsBoxCollider>> {
+}
+interface CircleColliderPhysicsProps {
+    radius: number;
+    offset?: [number, number];
+}
+export declare class PhysicsCircleCollider extends ComponentX<CircleColliderPhysicsProps & BaseComponentProps<PhysicsCircleCollider>> {
+}
+interface PolygonColliderPhysicsProps {
+    points: Array<Vec2> | [number, number][];
+    offset?: [number, number];
+}
+export declare class PhysicsPolygonCollider extends ComponentX<PolygonColliderPhysicsProps & BaseComponentProps<PhysicsPolygonCollider>> {
+}
+export {};
+//# sourceMappingURL=PhysicsComponent.d.ts.map

package/dist/chipmunk/PhysicsComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsComponent.d.ts","sourceRoot":"","sources":["../../src/chipmunk/PhysicsComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,UAAU,cAAc;IACtB,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAChB,OAAO,CAAC,EAAE,KAAK,CAAA;IACf,WAAW,CAAC,EAAE,KAAK,CAAA;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAA;IAChB,YAAY,CAAC,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;IAC3C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;IACzC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,KAAA,KAAK,IAAI,CAAA;IACjD,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,KAAA,KAAK,IAAI,CAAA;CACvD;AAED,qBAAa,SAAU,SAAQ,UAAU,CAAC,cAAc,CAAC;IACvD,IAAI,EAAE,EAAE,CAAC,IAAI,CAAA;IACb,YAAY,EAAE,aAAa,CAAA;IAC3B,IAAI,cAAc,CAAC,GAAG,EAAE,IAAI,EAM3B;IAED,IAAI,cAAc,IARM,IAAI,CAc3B;IAED,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,IAAI;IAWlC,kBAAkB,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,IAAI;IAaxC,WAAW,CAAC,MAAM,EAAE,KAAK;IAOzB,IAAI,QAAQ,CAAC,GAAG,EAAE,IAAI,EASrB;IAED,IAAI,QAAQ,IAXM,IAAI,CAarB;CACF;AAED,UAAU,uBAAuB;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1B;AACD,qBAAa,kBAAmB,SAAQ,UAAU,CAAC,uBAAuB,GAAG,kBAAkB,CAAC,kBAAkB,CAAC,CAAC;CASnH;AACD,UAAU,0BAA0B;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1B;AACD,qBAAa,qBAAsB,SAAQ,UAAU,CAAC,0BAA0B,GAAG,kBAAkB,CAAC,qBAAqB,CAAC,CAAC;CAAG;AAChI,UAAU,2BAA2B;IACnC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IACxC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1B;AACD,qBAAa,sBAAuB,SAAQ,UAAU,CAAC,2BAA2B,GAAG,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;CAAG"}

package/dist/chipmunk/PhysicsComponent.js

@@ -0,0 +1,69 @@
+import { ComponentX } from '../core/decorator';
+import { Vec2 } from '../polyfills';
+export class RigidBody extends ComponentX {
+    body;
+    physicSprite;
+    set linearVelocity(vel) {
+        // console.log('set linearVelocity(', vel)
+        if (!this.node) {
+            return;
+        }
+        this.body.setVel(new cp.Vect(vel.x, vel.y));
+    }
+    get linearVelocity() {
+        if (!this.node) {
+            return Vec2.ZERO;
+        }
+        const vel = this.body.getVel();
+        return Vec2(vel);
+    }
+    applyForceTo(vel, pos) {
+        if (!this.node) {
+            return;
+        }
+        if (pos) {
+            this.body.applyForce(new cp.Vect(vel.x, vel.y), new cp.Vect(pos.x, pos.y));
+        }
+        else {
+            this.body.applyForce(new cp.Vect(vel.x, vel.y), new cp.Vect(0, 0));
+        }
+    }
+    applyLinearImpulse(vel, pos) {
+        if (!this.node) {
+            return;
+        }
+        // console.log('applyLinearImpulse', vel, pos)
+        // this.body.activate()
+        if (pos) {
+            this.body.applyImpulse(new cp.Vect(vel.x, vel.y), new cp.Vect(pos.x, pos.y));
+        }
+        else {
+            this.body.applyImpulse(new cp.Vect(vel.x, vel.y), new cp.Vect(0, 0));
+        }
+    }
+    applyTorque(torque) {
+        if (!this.node) {
+            return;
+        }
+        this.body.setAngVel(torque);
+    }
+    set position(pos) {
+        this.physicSprite.node.setPosition(pos.x, pos.y);
+        const physicsPos = new cp.Vect(pos.x, pos.y);
+        // console.log('SetTransform', pos, physicsPos)
+        const body = this.body;
+        body.setVel(new cp.Vect(0, 0));
+        body.setAngVel(0);
+        // body.SetAwake(true)
+        body.setPos(physicsPos);
+    }
+    get position() {
+        return Vec2(this.physicSprite.getBody().getPos());
+    }
+}
+export class PhysicsBoxCollider extends ComponentX {
+}
+export class PhysicsCircleCollider extends ComponentX {
+}
+export class PhysicsPolygonCollider extends ComponentX {
+}

package/dist/chipmunk/PhysicsSprite.d.ts

@@ -0,0 +1,16 @@
+export declare class PhysicsSprite {
+    node: cc.Node;
+    physicsBody: cp.Body;
+    constructor(node: cc.Node, body: cp.Body);
+    update(dt: number): void;
+    getBody(): cp.Body;
+    set position(val: cp.Vect);
+    set x(val: number);
+    set y(val: number);
+    get x(): number;
+    get y(): number;
+    set rotation(val: number);
+    get rotation(): number;
+    addChild(child: cc.Node): void;
+}
+//# sourceMappingURL=PhysicsSprite.d.ts.map

package/dist/chipmunk/PhysicsSprite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSprite.d.ts","sourceRoot":"","sources":["../../src/chipmunk/PhysicsSprite.ts"],"names":[],"mappings":"AAEA,qBAAa,aAAa;IACxB,IAAI,EAAE,EAAE,CAAC,IAAI,CAAA;IACb,WAAW,EAAE,EAAE,CAAC,IAAI,CAAA;gBAER,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI;IAKxC,MAAM,CAAC,EAAE,EAAE,MAAM;IAcjB,OAAO;IAIP,IAAI,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,EAExB;IAED,IAAI,CAAC,CAAC,GAAG,QAAA,EAER;IACD,IAAI,CAAC,CAAC,GAAG,QAAA,EAER;IAED,IAAI,CAAC,WAEJ;IAED,IAAI,CAAC,WAEJ;IAED,IAAI,QAAQ,CAAC,GAAG,EAAE,MAAM,EAEvB;IAED,IAAI,QAAQ,IAJM,MAAM,CAMvB;IAED,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI;CAGxB"}

package/dist/chipmunk/PhysicsSprite.js

@@ -0,0 +1,49 @@
+import { Vec2 } from '../polyfills';
+export class PhysicsSprite {
+    node;
+    physicsBody;
+    constructor(node, body) {
+        this.node = node;
+        this.physicsBody = body;
+    }
+    update(dt) {
+        if (!this.physicsBody) {
+            return;
+        }
+        const { x, y } = this.physicsBody.getPos();
+        // use cc.lerp to smooth the position update
+        // const pos = Vec2(cc.lerp(this.node.x, x, dt * 10), cc.lerp(this.node.y, y, dt * 10))
+        this.node.setPosition(x, y);
+        // lerp the rotation
+        // this.node.setRotation(cc.lerp(this.node.rotation, -cc.radiansToDegrees(this.physicsBody.a), dt * 10))
+        this.node.setRotation(-cc.radiansToDegrees(this.physicsBody.a));
+        // this.node.setScale(1 / this.physicsBody.GetFixtureList().GetShape().GetRadius())
+    }
+    getBody() {
+        return this.physicsBody;
+    }
+    set position(val) {
+        this.physicsBody.setPos(val);
+    }
+    set x(val) {
+        this.physicsBody.setPos(Vec2(val, this.y));
+    }
+    set y(val) {
+        this.physicsBody.setPos(Vec2(this.x, val));
+    }
+    get x() {
+        return this.physicsBody.getPos().x;
+    }
+    get y() {
+        return this.physicsBody.getPos().y;
+    }
+    set rotation(val) {
+        this.physicsBody.setAngle(-cc.degreesToRadians(val));
+    }
+    get rotation() {
+        return -cc.radiansToDegrees(this.physicsBody.a);
+    }
+    addChild(child) {
+        this.node.addChild(child);
+    }
+}

package/dist/chipmunk/PhysicsSystem.d.ts

@@ -0,0 +1,20 @@
+import { EntityManager, EventManager, System } from 'entityx-ts';
+export declare const DynamicBody = 2;
+export declare const KinematicBody = 1;
+export declare const StaticBody = 0;
+export declare function setColliderMatrix(colliderMatrix?: boolean[][]): void;
+export declare class PhysicsSystem implements System {
+    space: cp.Space;
+    _debugNode: cc.PhysicsDebugNode;
+    listRemoveBody: cp.Body[];
+    listRemoveShape: cp.Shape[];
+    colliderMatrix: boolean[][];
+    configure(event_manager: EventManager): void;
+    update(entities: EntityManager, events: EventManager, dt: number): void;
+    collisionBegin(arbiter: cp.Arbiter, space: cp.Space): boolean;
+    collisionPre(arbiter: cp.Arbiter, space: cp.Space): boolean;
+    collisionPost(arbiter: cp.Arbiter, space: cp.Space): boolean;
+    collisionSeparate(arbiter: cp.Arbiter, space: cp.Space): boolean;
+    addDebug(): void;
+}
+//# sourceMappingURL=PhysicsSystem.d.ts.map

package/dist/chipmunk/PhysicsSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../src/chipmunk/PhysicsSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAc,MAAM,EAAE,MAAM,YAAY,CAAA;AAO5E,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,eAAO,MAAM,aAAa,IAAI,CAAA;AAC9B,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B,wBAAgB,iBAAiB,CAAC,cAAc,cAAW,QAG1D;AAED,qBAAa,aAAc,YAAW,MAAM;IAC1C,KAAK,EAAE,EAAE,CAAC,KAAK,CAAA;IACf,UAAU,EAAE,EAAE,CAAC,gBAAgB,CAAA;IAC/B,cAAc,EAAE,EAAE,CAAC,IAAI,EAAE,CAAK;IAC9B,eAAe,EAAE,EAAE,CAAC,KAAK,EAAE,CAAK;IAChC,cAAc,cAAW;IAEzB,SAAS,CAAC,aAAa,EAAE,YAAY;IAiKrC,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM;IA2BhE,cAAc,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK;IA2BnD,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK;IAKjD,aAAa,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK;IAKlD,iBAAiB,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK;IAkBtD,QAAQ;CAMT"}

package/dist/chipmunk/PhysicsSystem.js

@@ -0,0 +1,253 @@
+import { EventTypes } from 'entityx-ts';
+import { NodeComp } from '../core/NodeComp';
+import { GameWorld } from '../gworld';
+import { instantiate } from '../helper';
+import { PhysicsBoxCollider, PhysicsCircleCollider, PhysicsPolygonCollider, RigidBody } from './PhysicsComponent';
+import { PhysicsSprite } from './PhysicsSprite';
+export const DynamicBody = 2;
+export const KinematicBody = 1;
+export const StaticBody = 0;
+export function setColliderMatrix(colliderMatrix = [[true]]) {
+    const physicsSystem = GameWorld.Instance.systems.get(PhysicsSystem);
+    physicsSystem.colliderMatrix = colliderMatrix;
+}
+export class PhysicsSystem {
+    space;
+    _debugNode;
+    listRemoveBody = [];
+    listRemoveShape = [];
+    colliderMatrix = [[true]];
+    configure(event_manager) {
+        this.space = new cp.Space();
+        this.space.gravity = cp.v(0, -98);
+        this.space.iterations = 60;
+        this.space.collisionSlop = 0.5;
+        this.space.setDefaultCollisionHandler(this.collisionBegin.bind(this), this.collisionPre.bind(this), this.collisionPost.bind(this), this.collisionSeparate.bind(this));
+        event_manager.subscribe(EventTypes.ComponentAdded, PhysicsBoxCollider, ({ entity, component: box }) => {
+            // console.log('ComponentAddedEvent PhysicsBoxCollider', box)
+            let rigidBody = entity.getComponent(RigidBody);
+            if (!rigidBody) {
+                rigidBody = instantiate(RigidBody);
+                entity.assign(rigidBody);
+            }
+            const { type = StaticBody, gravityScale = 1, density = 1, friction = 0.5, restitution = 0.3, isSensor, tag = 0 } = rigidBody.props;
+            const { width, height, offset = [] } = box.props;
+            const [x = 0, y = 0] = offset;
+            const node = entity.getComponent(NodeComp);
+            const hw = width * 0.5;
+            const hh = height * 0.5;
+            let shape;
+            let body;
+            if (type === DynamicBody) {
+                body = new cp.Body(density * gravityScale, cp.momentForBox(density, width, height));
+                shape = new cp.BoxShape2(body, new cp.BB(-hw + x, -hh + y, hw + x, hh + y));
+                this.space.addShape(shape);
+                this.space.addBody(body);
+            }
+            else {
+                body = new cp.Body(Infinity, Infinity);
+                body.nodeIdleTime = Infinity;
+                shape = new cp.BoxShape2(body, new cp.BB(-hw + x, -hh + y, hw + x, hh + y));
+                this.space.addStaticShape(shape);
+            }
+            shape.setElasticity(restitution);
+            shape.setFriction(friction);
+            shape.setSensor(isSensor);
+            const physicsNode = new PhysicsSprite(node.instance, body);
+            rigidBody.physicSprite = physicsNode;
+            rigidBody.node = node;
+            rigidBody.body = body;
+            body.data = node;
+            shape.group = tag;
+            box.node = node;
+            body.setPos(node.position);
+        });
+        event_manager.subscribe(EventTypes.ComponentAdded, PhysicsCircleCollider, ({ entity, component }) => {
+            // console.log('ComponentAddedEvent PhysicsCircleCollider', component)
+            let rigidBody = entity.getComponent(RigidBody);
+            if (!rigidBody) {
+                rigidBody = instantiate(RigidBody);
+                entity.assign(rigidBody);
+            }
+            const { type = StaticBody, gravityScale = 1, density = 1, friction = 0.5, restitution = 0.3, isSensor = false, tag = 0, } = rigidBody.props;
+            const node = entity.getComponent(NodeComp);
+            const { radius, offset = [] } = component.props;
+            const [x = 0, y = 0] = offset;
+            const { width, height } = node.contentSize;
+            const { scaleX, scaleY, anchorX, anchorY } = node;
+            const offVect = new cp.Vect(x - width * anchorX * scaleX, y - height * scaleY * anchorY);
+            let shape;
+            let body;
+            if (type === DynamicBody) {
+                body = new cp.Body(density * gravityScale, cp.momentForCircle(density, radius, radius, offVect));
+                shape = new cp.CircleShape(body, radius, offVect);
+                this.space.addShape(shape);
+                this.space.addBody(body);
+            }
+            else {
+                body = new cp.Body(Infinity, Infinity);
+                body.nodeIdleTime = Infinity;
+                shape = new cp.CircleShape(body, radius, offVect);
+                this.space.addStaticShape(shape);
+            }
+            shape.setElasticity(restitution);
+            shape.setFriction(friction);
+            shape.setSensor(isSensor);
+            const physicsNode = new PhysicsSprite(node.instance, body);
+            // console.log(position instanceof b2Vec2, zero instanceof b2Vec2)
+            rigidBody.physicSprite = physicsNode;
+            rigidBody.node = node;
+            rigidBody.body = body;
+            body.data = node;
+            shape.group = tag;
+            component.node = node;
+            body.setPos(node.position);
+        });
+        event_manager.subscribe(EventTypes.ComponentAdded, PhysicsPolygonCollider, ({ entity, component }) => {
+            // console.log('ComponentAddedEvent PhysicsPolygonCollider', component)
+            let rigidBody = entity.getComponent(RigidBody);
+            if (!rigidBody) {
+                rigidBody = instantiate(RigidBody);
+                entity.assign(rigidBody);
+            }
+            const { type = StaticBody, gravityScale = 1, density = 1, friction = 0.5, restitution = 0.3, isSensor, tag = 0 } = rigidBody.props;
+            const node = entity.getComponent(NodeComp);
+            const { points, offset = [] } = component.props;
+            const [x = 0, y = 0] = offset;
+            const { width, height } = node.contentSize;
+            const { scaleX, scaleY, anchorX, anchorY } = node;
+            const offVect = new cp.Vect(x - width * anchorX * scaleX, y - height * scaleY * anchorY);
+            const fixedPoints = [];
+            points.forEach((p) => {
+                const px = p.x || p[0];
+                const py = p.y || p[1];
+                fixedPoints.push(px);
+                fixedPoints.push(py);
+            });
+            let shape;
+            let body;
+            if (type === DynamicBody) {
+                body = new cp.Body(density * gravityScale, cp.momentForPoly(density, fixedPoints, offVect));
+                shape = new cp.PolyShape(body, fixedPoints, offVect);
+                this.space.addShape(shape);
+                this.space.addBody(body);
+            }
+            else {
+                body = new cp.Body(Infinity, Infinity);
+                body.nodeIdleTime = Infinity;
+                shape = new cp.PolyShape(body, fixedPoints, offVect);
+                this.space.addStaticShape(shape);
+            }
+            shape.setElasticity(restitution);
+            shape.setFriction(friction);
+            shape.setSensor(isSensor);
+            const physicsNode = new PhysicsSprite(node.instance, body);
+            rigidBody.physicSprite = physicsNode;
+            rigidBody.node = node;
+            rigidBody.body = body;
+            body.data = node;
+            shape.group = tag;
+            component.node = node;
+            body.setPos(node.position);
+        });
+        event_manager.subscribe(EventTypes.ComponentRemoved, RigidBody, ({ component }) => {
+            // console.log('ComponentRemovedEvent RigidBody', component)
+            if (component.enabled && component.physicSprite instanceof PhysicsSprite) {
+                const body = component.physicSprite.getBody();
+                if (body && this.space.containsBody(body)) {
+                    body.shapeList.forEach((shape) => {
+                        if (shape && this.space.containsShape(shape)) {
+                            if (!this.listRemoveShape.includes(shape)) {
+                                this.listRemoveShape.push(shape);
+                            }
+                        }
+                    });
+                    this.listRemoveBody.push(body);
+                }
+            }
+        });
+    }
+    update(entities, events, dt) {
+        if (this.space) {
+            this.space.step(dt);
+        }
+        // this.space.addPostStepCallback(() => {
+        // cc.log('addPostStepCallback');
+        this.listRemoveShape.forEach((shape) => {
+            if (shape && this.space.containsShape(shape)) {
+                this.space.removeShape(shape);
+            }
+        });
+        this.listRemoveBody.forEach((body) => {
+            if (body && this.space.containsBody(body)) {
+                this.space.removeBody(body);
+            }
+        });
+        this.listRemoveBody = [];
+        this.listRemoveShape = [];
+        // })
+        for (const entt of entities.entities_with_components(RigidBody)) {
+            const comp = entt.getComponent(RigidBody);
+            if (comp.node && comp.node.active && comp.enabled) {
+                comp.physicSprite.update(dt);
+            }
+        }
+    }
+    collisionBegin(arbiter, space) {
+        const shapes = arbiter.getShapes();
+        // cc.log(arbiter);
+        const node1 = arbiter.body_a.data;
+        const node2 = arbiter.body_b.data;
+        const groupA = shapes[0].group;
+        const groupB = shapes[1].group;
+        // cc.log(groupA, groupB, this.colliderMatrix[groupA][groupB])
+        if (!this.colliderMatrix[groupA][groupB]) {
+            return false;
+        }
+        const phys1 = node1.getComponent(RigidBody);
+        const phys2 = node2.getComponent(RigidBody);
+        if (node1 && node1.active) {
+            if (phys1 && phys2 && phys1.props.onBeginContact) {
+                phys1.props.onBeginContact(phys2);
+            }
+        }
+        if (node2 && node2.active) {
+            if (phys1 && phys2 && phys2.props.onBeginContact) {
+                phys2.props.onBeginContact(phys1);
+            }
+        }
+        return true;
+    }
+    collisionPre(arbiter, space) {
+        // cc.log('collisionPre');
+        return true;
+    }
+    collisionPost(arbiter, space) {
+        // cc.log('collisionPost');
+        return true;
+    }
+    collisionSeparate(arbiter, space) {
+        // cc.log('collisionSeparate');
+        const node1 = arbiter.body_a.data;
+        const node2 = arbiter.body_b.data;
+        const phys1 = node1.getComponent(RigidBody);
+        const phys2 = node2.getComponent(RigidBody);
+        if (node1 && node1.active) {
+            if (phys1 && phys2 && phys1.props.onEndContact) {
+                phys1.props.onEndContact(phys2);
+            }
+        }
+        if (node2 && node2.active) {
+            if (phys1 && phys2 && phys2.props.onEndContact) {
+                phys2.props.onEndContact(phys1);
+            }
+        }
+        return true;
+    }
+    addDebug() {
+        const currentScene = cc.director.getRunningScene();
+        this._debugNode = new cc.PhysicsDebugNode(this.space);
+        this._debugNode.visible = true;
+        currentScene.addChild(this._debugNode, 100);
+    }
+}

package/dist/chipmunk/index.d.ts

@@ -0,0 +1,24 @@
+import { GameWorld, Vec2 } from '..';
+export * from './PhysicsComponent';
+export * from './PhysicsSprite';
+export * from './PhysicsSystem';
+export declare function setupPhysics(world?: GameWorld, isDebugDraw?: boolean, gravity?: {
+    x: number;
+    y: number;
+    equals(other: /*elided*/ any): boolean;
+    add(value: cc.Point | Vec2): /*elided*/ any;
+    addSelf(value: cc.Point | Vec2): /*elided*/ any;
+    sub(value: cc.Point | Vec2): /*elided*/ any;
+    mul(multiply: number): /*elided*/ any;
+    mulSelf(multiply: number): /*elided*/ any;
+    mag(): number;
+    normalizeSelf(): /*elided*/ any;
+    normalize(): /*elided*/ any;
+    cross(other: Vec2): number;
+    signAngle(other: Vec2): number;
+    lengthSqr(): number;
+    dot(other: Vec2): number;
+    angle(other: Vec2): number;
+    distance(other: /*elided*/ any): number;
+}): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/chipmunk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/chipmunk/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,IAAI,CAAA;AAGpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAE/B,wBAAgB,YAAY,CAAC,KAAK,YAAqB,EAAE,WAAW,UAAQ,EAAE,OAAO;;;;;;;;;;;;;;;;;;CAAe,QAMnG"}

package/dist/chipmunk/index.js

@@ -0,0 +1,12 @@
+import { GameWorld, Vec2 } from '..';
+import { PhysicsSystem } from './PhysicsSystem';
+export * from './PhysicsComponent';
+export * from './PhysicsSprite';
+export * from './PhysicsSystem';
+export function setupPhysics(world = GameWorld.Instance, isDebugDraw = false, gravity = Vec2(0, -98)) {
+    const physicsSystem = world.addSystemAndUpdate(PhysicsSystem);
+    if (isDebugDraw) {
+        physicsSystem.addDebug();
+    }
+    physicsSystem.space.gravity = gravity;
+}

package/dist/norender/NoRenderSystem.js

@@ -15,7 +15,7 @@ export class NoRenderSystem {
             swallowTouches: true,
             onTouchBegan: function (touch) {
                 const { onTouchStart } = touchComp.props;
-                if (!nodeComp.active)
+                if (!nodeComp.active || !touchComp.enabled)
                     return false;
                 // console.log('onTouchBegan', onTouchStart)
                 if (!nodeComp.parent) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safe-engine/cocos",
-  "version": "2.3.10",
+  "version": "2.4.0",
   "description": "safe-engine with cocos renderer support",
   "type": "module",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
     "@cocos/dragonbones-js": "^1.0.2",
     "@esotericsoftware/spine-core": "^4.2.93",
     "box2d-wasm": "^7.0.0",
-    "cocos-html5-ts": "^2.0.3",
+    "cocos-html5-ts": "^2.1.1",
     "entityx-ts": "^2.3.1"
   },
   "author": "",