@safe-engine/pixi 8.1.3 → 8.2.2

package/dist/collider/CollideComponent.js

@@ -0,0 +1,238 @@
+import chunk from 'lodash/chunk';
+import flatten from 'lodash/flatten';
+import max from 'lodash/max';
+import min from 'lodash/min';
+import { Rectangle } from 'pixi.js';
+import { app } from '../app';
+import { NoRenderComponentX } from '../components/BaseComponent';
+import { v2 } from '../helper/utils';
+import { circleCircle, polygonCircle, polygonPolygon } from './helper/Intersection';
+function getNodeToWorldTransformAR(node) {
+    const t = node.instance.worldTransform;
+    const x = node.instance.pivot.x * node.instance.width;
+    const y = node.instance.pivot.y * node.instance.height;
+    const transform = t.translate(x, y);
+    return transform;
+}
+function cloneRect(origin) {
+    return new Rectangle(origin.x, origin.y, origin.width, origin.height);
+}
+export class Collider extends NoRenderComponentX {
+    constructor() {
+        super(...arguments);
+        this.enabled = true;
+        this._worldPoints = [];
+        this._AABB = new Rectangle(0, 0, 0, 0);
+        this._preAabb = new Rectangle(0, 0, 0, 0);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    update(dt, draw) { }
+    getAABB() {
+        return this._AABB;
+    }
+    get world() {
+        return {
+            points: this._worldPoints,
+            preAabb: this._preAabb,
+        };
+    }
+    setOnCollisionEnter(cb) {
+        const collider = this.getComponent(Collider);
+        collider.onCollisionEnter = cb;
+    }
+    setOnCollisionExit(cb) {
+        const collider = this.getComponent(Collider);
+        collider.onCollisionExit = cb;
+    }
+    setOnCollisionStay(cb) {
+        const collider = this.getComponent(Collider);
+        collider.onCollisionStay = cb;
+    }
+}
+export class BoxCollider extends Collider {
+    constructor(props) {
+        super(props);
+    }
+    get size() {
+        return this;
+    }
+    set size(s) {
+        this.width = s.width;
+        this.height = s.height;
+    }
+    update(dt, draw) {
+        if (!this.node) {
+            return;
+        }
+        const { x, y } = this.offset || v2();
+        // const hw = this.width * 0.5
+        // const hh = this.height * 0.5
+        const transform = getNodeToWorldTransformAR(this.node);
+        // const dx = x - hw
+        // const dy = y - hh
+        const collider = this.getComponent(Collider);
+        collider._worldPoints = [
+            v2(x, y),
+            v2(x, y + this.height),
+            v2(x + this.width, y + this.height),
+            v2(x + this.width, y)
+        ].map(p => transform.apply(p));
+        // console.log("_worldPoints", collider._worldPoints, rectTrs)
+        // collider._worldPoints = collider._worldPoints.map(p => transform.apply(p))
+        const listX = collider._worldPoints.map(({ x }) => x);
+        const listY = collider._worldPoints.map(({ y }) => y);
+        collider._preAabb = cloneRect(collider._AABB);
+        collider._AABB.x = min(listX);
+        collider._AABB.y = min(listY);
+        collider._AABB.width = max(listX) - collider._AABB.x;
+        collider._AABB.height = max(listY) - collider._AABB.y;
+        if (draw) {
+            // console.log("drawing", JSON.stringify(collider._worldPoints))
+            const drawList = collider._worldPoints;
+            // draw.clear()
+            draw.poly(drawList);
+            // draw.fill({ color: '#fff', alpha: 0.3 })
+        }
+    }
+}
+export class CircleCollider extends Collider {
+    constructor(props) {
+        super(props);
+    }
+    update(dt, draw) {
+        if (!this.node) {
+            return;
+        }
+        const transform = getNodeToWorldTransformAR(this.node);
+        const collider = this.getComponent(Collider);
+        collider._worldRadius = this.radius * this.node.scaleX;
+        collider._worldPosition = transform.apply(this.offset);
+        if (draw) {
+            const { x } = collider._worldPosition;
+            const y = app.screen.height - collider._worldPosition.y;
+            draw.rect(x, y, 2, 2);
+            draw.circle(x, y, collider._worldRadius);
+        }
+        collider._preAabb = cloneRect(collider._AABB);
+        collider._AABB.x = collider._worldPosition.x - collider._worldRadius;
+        collider._AABB.y = collider._worldPosition.y - collider._worldRadius;
+        collider._AABB.width = collider._worldRadius * 2;
+        collider._AABB.height = collider._AABB.width;
+        // draw.drawRect(p(this._AABB.x, this._AABB.y),
+        //   p(this._worldPosition.x + this._worldRadius, this._worldPosition.y + this._worldRadius),
+        //   Color.WHITE, 3, Color.DEBUG_BORDER_COLOR);
+    }
+}
+export class PolygonCollider extends Collider {
+    constructor(props) {
+        super(props);
+        this._points = props.points || [];
+    }
+    get points() {
+        const { x, y } = this.offset;
+        const pointsList = chunk(this._points, 2).map(([px, py]) => v2(px + x, py + y));
+        return pointsList;
+    }
+    set points(points) {
+        this._points = flatten(points.map(({ x, y }) => [x, y]));
+    }
+    update(dt, draw) {
+        if (!this.node) {
+            return;
+        }
+        const transform = getNodeToWorldTransformAR(this.node);
+        const collider = this.getComponent(Collider);
+        collider._worldPoints = this.points.map((p) => transform.apply(p));
+        // log(polyPoints);
+        if (draw) {
+            const drawList = collider._worldPoints.map(({ x, y }) => v2(x, app.screen.height - y));
+            draw.poly(drawList);
+        }
+        const listX = collider._worldPoints.map(({ x }) => x);
+        const listY = collider._worldPoints.map(({ y }) => y);
+        collider._preAabb = cloneRect(collider._AABB);
+        collider._AABB.x = min(listX);
+        collider._AABB.y = min(listY);
+        collider._AABB.width = max(listX) - collider._AABB.x;
+        collider._AABB.height = max(listY) - collider._AABB.y;
+        // draw.drawRect(p(this._AABB.x, this._AABB.y), p(max(listX), max(listY)),
+        // Color.WHITE, 3, Color.DEBUG_BORDER_COLOR);
+    }
+}
+export var CollisionType;
+(function (CollisionType) {
+    CollisionType[CollisionType["NONE"] = 0] = "NONE";
+    CollisionType[CollisionType["ENTER"] = 1] = "ENTER";
+    CollisionType[CollisionType["STAY"] = 2] = "STAY";
+    CollisionType[CollisionType["EXIT"] = 3] = "EXIT";
+})(CollisionType || (CollisionType = {}));
+function isPolygonCollider(col) {
+    return col.getComponent(PolygonCollider) || col.getComponent(BoxCollider);
+}
+function isCircleCollider(col) {
+    return col.getComponent(CircleCollider);
+}
+export class Contract {
+    constructor(collider1, collider2) {
+        this._collider1 = collider1;
+        this._collider2 = collider2;
+        const isCollider1Polygon = isPolygonCollider(collider1);
+        const isCollider2Polygon = isPolygonCollider(collider2);
+        const isCollider1Circle = isCircleCollider(collider1);
+        const isCollider2Circle = isCircleCollider(collider2);
+        if (isCollider1Polygon && isCollider2Polygon) {
+            this._isPolygonPolygon = true;
+        }
+        else if (isCollider1Circle && isCollider2Circle) {
+            this._isCircleCircle = true;
+        }
+        else if (isCollider1Polygon && isCollider2Circle) {
+            this._isPolygonCircle = true;
+        }
+        else if (isCollider1Circle && isCollider2Polygon) {
+            this._isPolygonCircle = true;
+            this._collider1 = collider2;
+            this._collider2 = collider1;
+        }
+        // log(this._isPolygonPolygon);
+    }
+    updateState() {
+        const result = this.test();
+        let type = CollisionType.NONE;
+        if (result && !this._touching) {
+            this._touching = true;
+            type = CollisionType.ENTER;
+        }
+        else if (result && this._touching) {
+            type = CollisionType.STAY;
+        }
+        else if (!result && this._touching) {
+            this._touching = false;
+            type = CollisionType.EXIT;
+        }
+        // console.log('updateState', result, this._touching, type)
+        return type;
+    }
+    test() {
+        // if (!shouldCollider(this._collider1, this._collider2)) {
+        //   return false
+        // }
+        // log(this._collider1.getAABB(), this._collider2.getAABB());
+        if (!this._collider1.getAABB().intersects(this._collider2.getAABB())) {
+            return false;
+        }
+        if (this._isPolygonPolygon) {
+            return polygonPolygon(this._collider1._worldPoints, this._collider2._worldPoints);
+        }
+        if (this._isCircleCircle) {
+            const p1 = this._collider1;
+            const p2 = this._collider2;
+            return circleCircle(p1._worldPosition, p1._worldRadius, p2._worldPosition, p2._worldRadius);
+        }
+        if (this._isPolygonCircle) {
+            const p2 = this._collider2;
+            return polygonCircle(this._collider1._worldPoints, p2._worldPosition, p2._worldRadius);
+        }
+        return false;
+    }
+}

package/dist/collider/CollideSystem.d.ts

@@ -0,0 +1,26 @@
+import { EntityManager, EventManager, System } from 'entityx-ts';
+import { Graphics } from 'pixi.js';
+import { Collider, Contract } from './CollideComponent';
+export declare function enabledDebugDraw(enable?: boolean): void;
+export declare class CollideSystem implements System {
+    listColliders: Collider[];
+    _contracts: Contract[];
+    removeColliders: Collider[];
+    debugGraphics: Graphics;
+    enabledDebugDraw: boolean;
+    enabled: boolean;
+    colliderMatrix: boolean[][];
+    configure(event_manager: EventManager): void;
+    update(entities: EntityManager, events: EventManager, dt: number): void;
+    addCollider(colliderPhysics: Collider): void;
+    removeCollider(colliderPhysics: Collider): void;
+    onAddCollider({ entity, component }: {
+        entity: any;
+        component: any;
+    }): void;
+    onRemoveCollider({ entity, component }: {
+        entity: any;
+        component: any;
+    }): void;
+}
+//# sourceMappingURL=CollideSystem.d.ts.map

package/dist/collider/CollideSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollideSystem.d.ts","sourceRoot":"","sources":["../../src/collider/CollideSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAc,MAAM,EAAE,MAAM,YAAY,CAAA;AAC5E,OAAO,EAAS,QAAQ,EAAE,MAAM,SAAS,CAAA;AAKzC,OAAO,EAA+B,QAAQ,EAAiB,QAAQ,EAAmB,MAAM,oBAAoB,CAAA;AAEpH,wBAAgB,gBAAgB,CAAC,MAAM,UAAO,QAG7C;AAED,qBAAa,aAAc,YAAW,MAAM;IAC1C,aAAa,EAAE,QAAQ,EAAE,CAAK;IAC9B,UAAU,EAAE,QAAQ,EAAE,CAAK;IAC3B,eAAe,EAAE,QAAQ,EAAE,CAAK;IAChC,aAAa,EAAE,QAAQ,CAAA;IACvB,gBAAgB,UAAO;IACvB,OAAO,UAAO;IACd,cAAc,cAAW;IAEzB,SAAS,CAAC,aAAa,EAAE,YAAY;IAgBrC,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM;IAwGhE,WAAW,CAAC,eAAe,EAAE,QAAQ;IASrC,cAAc,CAAC,eAAe,EAAE,QAAQ;IAGxC,aAAa,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE;;;KAAA;IAOnC,gBAAgB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE;;;KAAA;CAKvC"}

package/dist/collider/CollideSystem.js

@@ -0,0 +1,159 @@
+import { EventTypes } from 'entityx-ts';
+import { Color, Graphics } from 'pixi.js';
+import { app } from '../app';
+import { GameWorld } from '../base';
+import { NodeComp } from '../components/NodeComp';
+import { BoxCollider, CircleCollider, Collider, CollisionType, Contract, PolygonCollider } from './CollideComponent';
+export function enabledDebugDraw(enable = true) {
+    const collideSystem = GameWorld.Instance.systems.get(CollideSystem);
+    collideSystem.enabledDebugDraw = enable;
+}
+export class CollideSystem {
+    constructor() {
+        this.listColliders = [];
+        this._contracts = [];
+        this.removeColliders = [];
+        this.enabledDebugDraw = true;
+        this.enabled = true;
+        this.colliderMatrix = [[true]];
+    }
+    configure(event_manager) {
+        event_manager.subscribe(EventTypes.ComponentAdded, BoxCollider, this.onAddCollider.bind(this));
+        event_manager.subscribe(EventTypes.ComponentAdded, CircleCollider, this.onAddCollider.bind(this));
+        event_manager.subscribe(EventTypes.ComponentAdded, PolygonCollider, this.onAddCollider.bind(this));
+        event_manager.subscribe(EventTypes.ComponentRemoved, BoxCollider, this.onRemoveCollider.bind(this));
+        event_manager.subscribe(EventTypes.ComponentRemoved, CircleCollider, this.onRemoveCollider.bind(this));
+        event_manager.subscribe(EventTypes.ComponentRemoved, PolygonCollider, this.onRemoveCollider.bind(this));
+        if (this.enabledDebugDraw) {
+            this.debugGraphics = new Graphics();
+            this.debugGraphics.setFillStyle({ color: new Color('white') });
+            this.debugGraphics.width = 4;
+            this.debugGraphics.zIndex = 40;
+        }
+        app.stage.addChild(this.debugGraphics);
+    }
+    update(entities, events, dt) {
+        if (!this.enabled) {
+            return;
+        }
+        this.listColliders.forEach((collider) => {
+            if (!collider.node.active) {
+                this.removeColliders.push(collider);
+            }
+        });
+        // this.removeColliders.forEach((comp) => {
+        //   this.listColliders = this.listColliders.filter((col) => !col.isEqual(comp) && col.node.active)
+        //   this._contracts = this._contracts.filter((contract) => {
+        //     const col1 = contract._collider1
+        //     const col2 = contract._collider2
+        //     if (col1.isEqual(comp) || !col1.node.active) {
+        //       if (contract._touching) {
+        //         // contract._touching = false
+        //         if (col2.onCollisionExit) {
+        //           col2.onCollisionExit(col1)
+        //         }
+        //       }
+        //       return false
+        //     }
+        //     if (col2.isEqual(comp) || !col2.node.active) {
+        //       if (contract._touching) {
+        //         // contract._touching = false
+        //         if (col1.onCollisionExit) col1.onCollisionExit(col2)
+        //       }
+        //       return false
+        //     }
+        //     return true
+        //   })
+        // })
+        this.removeColliders = [];
+        const draw = this.enabledDebugDraw ? this.debugGraphics : undefined;
+        if (this.enabledDebugDraw) {
+            draw.clear();
+        }
+        for (const entt of entities.entities_with_components(BoxCollider)) {
+            const comp = entt.getComponent(BoxCollider);
+            comp.update(dt, draw);
+        }
+        for (const entt of entities.entities_with_components(CircleCollider)) {
+            const comp = entt.getComponent(CircleCollider);
+            comp.update(dt, draw);
+        }
+        for (const entt of entities.entities_with_components(PolygonCollider)) {
+            const comp = entt.getComponent(PolygonCollider);
+            comp.update(dt, draw);
+        }
+        if (this.enabledDebugDraw) {
+            // draw.clear()
+            // draw.removeFromParent()
+            // app.stage.addChild(draw)
+            // console.log('enabledDebugDraw', this.debugGraphics)
+            // this.debugGraphics.width = 4
+            // this.debugGraphics.circle(500, 600, 450)
+            this.debugGraphics.fill({ color: new Color('white'), alpha: 0.3 });
+        }
+        // console.log(this._contracts.length)
+        this._contracts.forEach((contract) => {
+            const col1 = contract._collider1;
+            const col2 = contract._collider2;
+            if (!col1.node || !col2.node || !col1.node.active || !col2.node.active) {
+                return;
+            }
+            const type = contract.updateState();
+            if (!col1 || !col2) {
+                return;
+            }
+            switch (type) {
+                case CollisionType.ENTER: {
+                    if (col1.onCollisionEnter) {
+                        col1.onCollisionEnter(col2);
+                    }
+                    if (col2.onCollisionEnter) {
+                        col2.onCollisionEnter(col1);
+                    }
+                    break;
+                }
+                case CollisionType.STAY:
+                    if (col1.onCollisionStay) {
+                        col1.onCollisionStay(col2);
+                    }
+                    if (col2.onCollisionStay) {
+                        col2.onCollisionStay(col1);
+                    }
+                    break;
+                case CollisionType.EXIT:
+                    if (col1.onCollisionExit) {
+                        col1.onCollisionExit(col2);
+                    }
+                    if (col2.onCollisionExit) {
+                        col2.onCollisionExit(col1);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+    addCollider(colliderPhysics) {
+        this.listColliders.forEach((col) => {
+            // if (shouldCollider(col, colliderPhysics)) {
+            this._contracts.push(new Contract(col, colliderPhysics));
+            // }
+        });
+        this.listColliders.push(colliderPhysics);
+    }
+    removeCollider(colliderPhysics) {
+        this.removeColliders.push(colliderPhysics);
+    }
+    onAddCollider({ entity, component }) {
+        console.log('ComponentAddedEvent', component);
+        const collider = entity.assign(new Collider(component));
+        collider.node = entity.getComponent(NodeComp);
+        component.node = entity.getComponent(NodeComp);
+        this.addCollider(collider);
+    }
+    onRemoveCollider({ entity, component }) {
+        console.log('ComponentRemovedEvent', component);
+        const collider = entity.getComponent(Collider);
+        this.removeCollider(collider);
+    }
+}

package/dist/collider/helper/Intersection.d.ts

@@ -0,0 +1,7 @@
+import { Point } from 'pixi.js';
+export declare function pointInPolygon(pos: Point, polygon: Point[]): boolean;
+export declare function pointLineDistance(point: Point, start: Point, end: Point, isSegment: any): number;
+export declare function polygonPolygon(pts1: Point[], pts2: Point[]): boolean;
+export declare function circleCircle(p1: Point, r1: number, p2: Point, r2: number): boolean;
+export declare function polygonCircle(pts1: Point[], p2: Point, r2: number): boolean;
+//# sourceMappingURL=Intersection.d.ts.map

package/dist/collider/helper/Intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Intersection.d.ts","sourceRoot":"","sources":["../../../src/collider/helper/Intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAG/B,wBAAgB,cAAc,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,WAuB1D;AAmCD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,KAAA,UAwBlF;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,WA6B1D;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,WAGxE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,WAejE"}

package/dist/collider/helper/Intersection.js

@@ -0,0 +1,111 @@
+import { getDistance, v2 } from '../../helper/utils';
+export function pointInPolygon(pos, polygon) {
+    let inside = false;
+    const x = pos.x;
+    const y = pos.y;
+    // use some raycasting to test hits
+    // https://github.com/substack/point-in-polygon/blob/master/index.js
+    const length = polygon.length;
+    let intersect = false;
+    for (let i = 0, j = length - 1; i < length; j = i++) {
+        const xi = polygon[i].x, yi = polygon[i].y, xj = polygon[j].x, yj = polygon[j].y;
+        intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+function lineLine(a1, a2, b1, b2) {
+    // jshint camel case:false
+    const ua_t = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x);
+    const ub_t = (a2.x - a1.x) * (a1.y - b1.y) - (a2.y - a1.y) * (a1.x - b1.x);
+    const u_b = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y);
+    if (u_b !== 0) {
+        const ua = ua_t / u_b;
+        const ub = ub_t / u_b;
+        if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
+            return true;
+        }
+    }
+    return false;
+}
+function linePolygon(A, B, polygon) {
+    const length = polygon.length;
+    for (let i = 0; i < length; ++i) {
+        const C = polygon[i];
+        const D = polygon[(i + 1) % length];
+        if (lineLine(A, B, C, D)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function pointLineDistance(point, start, end, isSegment) {
+    let dx = end.x - start.x;
+    let dy = end.y - start.y;
+    const d = dx * dx + dy * dy;
+    const t = ((point.x - start.x) * dx + (point.y - start.y) * dy) / d;
+    let p;
+    if (!isSegment) {
+        p = v2(start.x + t * dx, start.y + t * dy);
+    }
+    else if (d) {
+        if (t < 0) {
+            p = start;
+        }
+        else if (t > 1) {
+            p = end;
+        }
+        else {
+            p = v2(start.x + t * dx, start.y + t * dy);
+        }
+    }
+    else {
+        p = start;
+    }
+    dx = point.x - p.x;
+    dy = point.y - p.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+export function polygonPolygon(pts1, pts2) {
+    let i = 0, l = 0;
+    // check if p1 pts1 intersects pts2
+    for (l = pts1.length; i < l; ++i) {
+        const a1 = pts1[i];
+        const a2 = pts1[(i + 1) % l];
+        if (linePolygon(a1, a2, pts2)) {
+            return true;
+        }
+    }
+    // check if pts1 contains pts2
+    for (i = 0, l = pts2.length; i < l; ++i) {
+        if (pointInPolygon(pts2[i], pts1)) {
+            return true;
+        }
+    }
+    // check if pts2 contains pts1
+    for (i = 0, l = pts1.length; i < l; ++i) {
+        if (pointInPolygon(pts1[i], pts2)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function circleCircle(p1, r1, p2, r2) {
+    const d = getDistance(p1, p2);
+    return d < r1 + r2;
+}
+export function polygonCircle(pts1, p2, r2) {
+    if (pointInPolygon(p2, pts1)) {
+        return true;
+    }
+    for (let i = 0, l = pts1.length; i < l; i++) {
+        const start = i === 0 ? pts1[l - 1] : pts1[i - 1];
+        const end = pts1[i];
+        if (pointLineDistance(p2, start, end, true) < r2) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/collider/helper/utils.d.ts

@@ -0,0 +1,3 @@
+import { Collider } from '../CollideComponent';
+export declare function shouldCollider(colA: Collider, colB: Collider): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/collider/helper/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/collider/helper/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAG9C,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,WAQ5D"}

package/dist/collider/helper/utils.js

@@ -0,0 +1,11 @@
+import { GameWorld } from '../../base';
+import { CollideSystem } from '../CollideSystem';
+export function shouldCollider(colA, colB) {
+    const groupA = colA.node.group;
+    const groupB = colB.node.group;
+    if (groupA === undefined || groupB === undefined) {
+        return true;
+    }
+    const { colliderMatrix } = GameWorld.Instance.systems.get(CollideSystem);
+    return colliderMatrix[groupA][groupB];
+}

package/dist/collider/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CollideComponent';
+export * from './CollideSystem';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collider/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA"}

package/dist/collider/index.js

@@ -0,0 +1,2 @@
+export * from './CollideComponent';
+export * from './CollideSystem';

package/dist/components/BaseComponent.d.ts

@@ -1,11 +1,12 @@
-import { EnhancedComponent } from '@safe-engine/core';
 import { Container } from 'pixi.js';
+import { EnhancedComponent } from '../base';
 import { NodeComp } from './NodeComp';
-export declare class NoRenderComponentX<C extends Container = Container> extends EnhancedComponent<NodeComp<C>> {
-    static create(data?: any): NoRenderComponentX<Container<import("pixi.js").ContainerChild>>;
+export declare class NoRenderComponentX<Props = Object, C extends Container = Container> extends EnhancedComponent<Props, NodeComp<C>> {
+    static create(data?: any): NoRenderComponentX<any, Container<import("pixi.js").ContainerChild>>;
 }
-export declare class ComponentX<C extends Container = Container> extends EnhancedComponent<NodeComp<C>> {
+export declare class ComponentX<Props = Object, C extends Container = Container> extends EnhancedComponent<Props, NodeComp<C>> {
     static hasRender: boolean;
-    static create(data?: any): ComponentX<Container<import("pixi.js").ContainerChild>>;
+    render?(data?: Props): any;
+    static create(data?: any): any;
 }
 //# sourceMappingURL=BaseComponent.d.ts.map

package/dist/components/BaseComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseComponent.d.ts","sourceRoot":"","sources":["../../src/components/BaseComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAa,MAAM,mBAAmB,CAAA;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEnC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAAa,kBAAkB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,CAAE,SAAQ,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACrG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG;CAGzB;AAED,qBAAa,UAAU,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,CAAE,SAAQ,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC7F,MAAM,CAAC,SAAS,UAAO;IACvB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG;CAMzB"}
+{"version":3,"file":"BaseComponent.d.ts","sourceRoot":"","sources":["../../src/components/BaseComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,EAAE,iBAAiB,EAAa,MAAM,SAAS,CAAA;AAEtD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAAa,kBAAkB,CAAC,KAAK,GAAG,MAAM,EAAE,CAAC,SAAS,SAAS,GAAG,SAAS,CAAE,SAAQ,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC5H,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG;CAGzB;AAED,qBAAa,UAAU,CAAC,KAAK,GAAG,MAAM,EAAE,CAAC,SAAS,SAAS,GAAG,SAAS,CAAE,SAAQ,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACpH,MAAM,CAAC,SAAS,UAAO;IACvB,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,GAAG,GAAG;IAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG;CAQzB"}

package/dist/components/BaseComponent.js

@@ -1,20 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComponentX = exports.NoRenderComponentX = void 0;
-const core_1 = require("@safe-engine/core");
-class NoRenderComponentX extends core_1.EnhancedComponent {
+import { EnhancedComponent, GameWorld } from '../base';
+export class NoRenderComponentX extends EnhancedComponent {
     static create(data) {
         return new this(data);
     }
 }
-exports.NoRenderComponentX = NoRenderComponentX;
-class ComponentX extends core_1.EnhancedComponent {
+export class ComponentX extends EnhancedComponent {
     static create(data) {
-        const world = core_1.GameWorld.Instance;
+        // console.log('create', this, this.prototype['render'])
+        if (this.prototype.render)
+            return this.prototype.render(data);
+        const world = GameWorld.Instance;
         const root = world.entities.create();
         const comp = root.assign(new this(data));
         return comp;
     }
 }
-exports.ComponentX = ComponentX;
 ComponentX.hasRender = true;