@safe-engine/pixi 8.3.6 → 8.4.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,35 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Publish NPM Package
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch: # Allows you to run this workflow manually
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm run build
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm run build
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/README.md

@@ -16,8 +16,8 @@ Safex is an open-source game engine written in TypeScript, combining the power o
 - Example `<SpriteRender node={{ x: 5, y: 9 }} />`
 - `$ref` bind component with current class property as string
 - `$push` push component to list
-- `Array(2).map(_, i)` iteration repeat component 2 times
-- `Loading.listItems.map(item, i)` iteration in static property
+- `Array(2).map(i)` iteration repeat component 2 times
+- `Loading.listItems.map(item, i = 1)` iteration in static property
 - `listItems.map(item, i)` iteration in const variable
 
 ## Benefits
@@ -32,10 +32,16 @@ Safex is an open-source game engine written in TypeScript, combining the power o
 npm install @safe-engine/pixi
 ```
 
+# Quick start
+
+```sh
+  git clone https://github.com/Safe-engine/pixi-safe-engine-demo
+```
+
 ## Basic Example
 
 ```tsx game.ts
-import { addGameCanvasTo, loadScene, startGameSystems } from '@safe-engine/pixi'
+import { addGameCanvasTo, loadScene, startGameSystems } from 'safex'
 async function start() {
   await addGameCanvasTo('canvasId')
   startGameSystems()
@@ -45,19 +51,35 @@ start()
 ```
 
 ```tsx GameScene.tsx
-import { SceneComponent, LabelComp, ButtonComp, SpriteRender } from '@safe-engine/pixi'
+import { SceneComponent, LabelComp, ButtonComp, SpriteRender, instantiate } from 'safex'
+import ColliderSprite from './ColliderSprite'
 
 export class GameScene extends ComponentX {
   sprite: SpriteRender
+  label: LabelComp
 
   onPress() {
     this.sprite.spriteFrame = 'other.sprite.png'
+    this.label.string = 'Pressed'
+  }
+
+  onTouchMove(event: FederatedPointerEvent) {
+    console.log('onTouchMove', event.global)
+    const sprite = instantiate(ColliderSprite)
+    sprite.node.x = event.global.x
+    sprite.node.y = event.global.y
+    this.node.addChild(sprite)
   }
 
   render() {
     return (
       <SceneComponent>
-        <LabelComp node={{ x: 106, y: 240 }} string="Hello safex" font={defaultFont} />
+        <TouchEventRegister
+          // onTouchStart={this.onTouchStart}
+          // onTouchEnd={this.onTouchEnd}
+          onTouchMove={this.onTouchMove}
+        />
+        <LabelComp $ref={this.label} node={{ x: 106, y: 240 }} string="Hello safex" font={defaultFont} />
         <SpriteRender $ref={this.sprite} node={{ x: 500, y: 600 }} spriteFrame={'path/to/sprite.png'}>
           <ButtonComp onPress={this.onPress} />
         </SpriteRender>
@@ -67,6 +89,49 @@ export class GameScene extends ComponentX {
 }
 ```
 
+## Collider Events
+
+```tsx
+import { BoxCollider, Collider, ComponentX, SpriteRender } from 'safex'
+import { sf_crash } from '../assets'
+
+export class ColliderSprite extends ComponentX {
+  onCollisionEnter(other: Collider) {
+    console.log(other.tag)
+  }
+
+  render() {
+    return (
+      <SpriteRender node={{ x: 640, y: 360 }} spriteFrame={sf_crash}>
+        <BoxCollider height={100} width={100}></BoxCollider>
+      </SpriteRender>
+    )
+  }
+}
+```
+
+## Physics Events
+
+```tsx
+import { PhysicsBoxCollider, PhysicsCollider, RigidBody, ComponentX, SpriteRender } from 'safex'
+import { sf_crash } from '../assets'
+
+export class PhysicsCollider extends ComponentX {
+  onCollisionEnter(col: PhysicsCollider) {
+    console.log('onCollisionEnter', col)
+  }
+
+  render() {
+    return (
+      <SpriteRender node={{ x: 640, y: 360 }} spriteFrame={sf_crash}>
+        <RigidBody type="static"></RigidBody>
+        <PhysicsBoxCollider height={100} width={100}></PhysicsBoxCollider>
+      </SpriteRender>
+    )
+  }
+}
+```
+
 ## Contributing
 
 We welcome all contributions! If you have ideas or want to improve the engine, feel free to create an issue or submit a pull request on GitHub.

package/dist/app.d.ts

@@ -1,9 +1,6 @@
 import { Application } from 'pixi.js';
-export declare const app: Application<import("pixi.js").Renderer>;
-export declare function addGameCanvasTo(id?: string): Promise<void>;
-export declare function setupResolution(designedResolution?: {
+export declare function startGame(defaultFont: any, designedResolution?: {
     width: number;
     height: number;
-}): void;
-export declare function startGameSystems(list?: any[]): void;
+}, id?: string): Promise<Application<import("pixi.js").Renderer>>;
 //# sourceMappingURL=app.d.ts.map

package/dist/app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AASrC,eAAO,MAAM,GAAG,yCAAoB,CAAA;AAEpC,wBAAsB,eAAe,CAAC,EAAE,SAAS,iBAoBhD;AAED,wBAAgB,eAAe,CAAC,kBAAkB;;;CAA+B,QAKhF;AAaD,wBAAgB,gBAAgB,CAAC,IAAI,QAAK,QAezC"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAQrC,wBAAsB,SAAS,CAAC,WAAW,KAAA,EAAE,kBAAkB;;;CAA+B,EAAE,EAAE,SAAS,oDA6B1G"}

package/dist/app.js

@@ -11,14 +11,12 @@ import { actionManager } from 'pixi-action-ease';
 import { Application } from 'pixi.js';
 import { GameWorld } from './base';
 import { CollideSystem } from './collider';
-import { DragonBonesSystem } from './dragonbones';
 import { GUISystem } from './gui/GUISystem';
 import { NoRenderSystem } from './norender/NoRenderSystem';
 import { RenderSystem } from './render/RenderSystem';
-import { SpineSystem } from './spine';
-export const app = new Application();
-export function addGameCanvasTo() {
-    return __awaiter(this, arguments, void 0, function* (id = 'game') {
+export function startGame(defaultFont_1) {
+    return __awaiter(this, arguments, void 0, function* (defaultFont, designedResolution = { width: 720, height: 1280 }, id = 'game') {
+        const app = new Application();
         yield app.init({
             antialias: true,
             resolution: window.devicePixelRatio,
@@ -38,37 +36,56 @@ export function addGameCanvasTo() {
             height: `${window.innerHeight}px`,
             overflow: 'visible',
         });
+        const { width, height } = designedResolution;
+        app.renderer.resize(width, height);
+        // app.stage.position.y = app.renderer.height / app.renderer.resolution
+        // app.stage.scale.y = -1
+        GameWorld.Instance.app = app;
+        initWorld(defaultFont);
+        startGameLoop(GameWorld.Instance);
+        return app;
     });
 }
-export function setupResolution(designedResolution = { width: 720, height: 1280 }) {
-    const { width, height } = designedResolution;
-    app.renderer.resize(width, height);
-    // app.stage.position.y = app.renderer.height / app.renderer.resolution
-    // app.stage.scale.y = -1
-}
 function startGameLoop(world) {
     // Listen for frame updates
-    app.ticker.add(() => {
-        const dt = app.ticker.deltaMS * 0.001;
+    world.app.ticker.add(() => {
+        const dt = world.app.ticker.deltaMS * 0.001;
         actionManager.update(dt);
         world.update(dt);
     });
     // app.ticker.speed = 0.5
 }
-const systemsList = [RenderSystem, GUISystem, SpineSystem, DragonBonesSystem, CollideSystem, NoRenderSystem];
-export function startGameSystems(list = []) {
+// const systemsList = [RenderSystem, GUISystem, SpineSystem, DragonBonesSystem, CollideSystem, NoRenderSystem]
+// export function startGameSystems(list = []) {
+//   const world = GameWorld.Instance
+//   systemsList.forEach(system => {
+//     world.systems.add(system)
+//     world.systems.configureOnce(system)
+//   })
+//   world.listUpdate.push(CollideSystem)
+//   // world.listUpdate.push(PhysicsSystem)
+//   list.forEach(system => {
+//     world.systems.add(system)
+//     world.systems.configureOnce(system)
+//     world.listUpdate.push(system)
+//   })
+//   startGameLoop(world)
+//   // console.log('startGameLoop', world.listUpdate)
+// }
+function initWorld(defaultFont) {
     const world = GameWorld.Instance;
-    systemsList.forEach(system => {
-        world.systems.add(system);
-        world.systems.configureOnce(system);
-    });
+    world.systems.add(RenderSystem);
+    world.systems.add(CollideSystem);
+    world.systems.add(GUISystem);
+    world.systems.add(NoRenderSystem);
     world.listUpdate.push(CollideSystem);
-    // world.listUpdate.push(PhysicsSystem)
-    list.forEach(system => {
-        world.systems.add(system);
-        world.systems.configureOnce(system);
-        world.listUpdate.push(system);
-    });
-    startGameLoop(world);
-    // console.log('startGameLoop', world.listUpdate)
+    world.systems.configureOnce(RenderSystem);
+    world.systems.configureOnce(CollideSystem);
+    world.systems.configureOnce(GUISystem);
+    world.systems.configureOnce(NoRenderSystem);
+    if (defaultFont) {
+        const guiSystem = world.systems.get(GUISystem);
+        guiSystem.defaultFont = defaultFont;
+    }
+    // startGameLoop(world, app)
 }

package/dist/base/gworld.d.ts

@@ -1,6 +1,8 @@
 import { Constructor, System, World } from 'entityx-ts';
+import { Application } from 'pixi.js';
 export declare class GameWorld extends World {
     listUpdate: (System | Constructor<System>)[];
+    app: Application;
     update(dt: number): void;
     private static _instance;
     static get Instance(): GameWorld;

package/dist/base/gworld.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gworld.d.ts","sourceRoot":"","sources":["../../src/base/gworld.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvD,qBAAa,SAAU,SAAQ,KAAK;IAClC,UAAU,EAAE,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,CAAK;IACjD,MAAM,CAAC,EAAE,EAAE,MAAM;IAMjB,OAAO,CAAC,MAAM,CAAC,SAAS,CAAW;IAEnC,WAAkB,QAAQ,cAGzB;CACF"}
+{"version":3,"file":"gworld.d.ts","sourceRoot":"","sources":["../../src/base/gworld.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAErC,qBAAa,SAAU,SAAQ,KAAK;IAClC,UAAU,EAAE,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,CAAK;IACjD,GAAG,EAAE,WAAW,CAAA;IAChB,MAAM,CAAC,EAAE,EAAE,MAAM;IAMjB,OAAO,CAAC,MAAM,CAAC,SAAS,CAAW;IAEnC,WAAkB,QAAQ,cAGzB;CACF"}

package/dist/box2d-wasm/ContactListener.d.ts

@@ -0,0 +1,12 @@
+import { NodeComp } from "..";
+type Meta = {
+    [key: number]: NodeComp;
+};
+export declare const makeContactListener: (world: Box2D.b2World, metadata: Meta, box2D: typeof Box2D) => Box2D.JSContactListener & {
+    BeginContact(contact: Box2D.b2Contact | number): void;
+    EndContact(contact: Box2D.b2Contact | number): void;
+    PreSolve(contact: Box2D.b2Contact | number, oldManifold: Box2D.b2Manifold | number): void;
+    PostSolve(contact: Box2D.b2Contact | number, impulse: Box2D.b2ContactImpulse | number): void;
+};
+export {};
+//# sourceMappingURL=ContactListener.d.ts.map

package/dist/box2d-wasm/ContactListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactListener.d.ts","sourceRoot":"","sources":["../../src/box2d-wasm/ContactListener.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAE9B,KAAK,IAAI,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAA;AACvC,eAAO,MAAM,mBAAmB,GAAI,OAAO,KAAK,CAAC,OAAO,EAAE,UAAU,IAAI,EAAE,OAAO,OAAO,KAAK;0BAWnE,KAAK,CAAC,SAAS,GAAG,MAAM,GAAG,IAAI;wBAwBjC,KAAK,CAAC,SAAS,GAAG,MAAM,GAAG,IAAI;sBAmBjC,KAAK,CAAC,SAAS,GAAG,MAAM,eAAe,KAAK,CAAC,UAAU,GAAG,MAAM,GAAG,IAAI;uBAGtE,KAAK,CAAC,SAAS,GAAG,MAAM,WAAW,KAAK,CAAC,gBAAgB,GAAG,MAAM,GAAG,IAAI;CAK/F,CAAA"}

package/dist/box2d-wasm/ContactListener.js

@@ -0,0 +1,64 @@
+import { ColliderPhysics } from "./PhysicsComponent";
+export const makeContactListener = (world, metadata, box2D) => {
+    const { JSContactListener, getPointer, NULL } = box2D;
+    function getContactById(contact) {
+        for (let contactList = world.GetContactList(); getPointer(contactList) !== getPointer(NULL); contactList = contactList.GetNext()) {
+            if (getPointer(contactList) === contact) {
+                console.log('contactBegin', contact, getPointer(contactList), getPointer(NULL));
+                return contactList;
+            }
+        }
+    }
+    const listener = Object.assign(new JSContactListener(), {
+        BeginContact(contact) {
+            if (typeof contact === 'number') {
+                contact = getContactById(contact);
+            }
+            const ett1 = metadata[getPointer(contact.GetFixtureA().GetBody())];
+            const ett2 = metadata[getPointer(contact.GetFixtureB().GetBody())];
+            // world.addPostStepCallback(() => {
+            //   // log('addPostStepCallback');
+            //   listRemoveShape.forEach((s) => world.removeShape(s))
+            //   listRemoveBody.forEach((b) => world.removeBody(b))
+            //   listRemoveBody = []
+            //   listRemoveShape = []
+            // })
+            const phys1 = ett1.getComponent(ColliderPhysics);
+            const phys2 = ett2.getComponent(ColliderPhysics);
+            if (phys1 && phys2) {
+                if (Object.prototype.hasOwnProperty.call(phys1, 'onCollisionEnter')) {
+                    phys1.props.onCollisionEnter(phys2);
+                }
+                if (Object.prototype.hasOwnProperty.call(phys2, 'onCollisionEnter')) {
+                    phys2.props.onCollisionEnter(phys1);
+                }
+            }
+        },
+        EndContact(contact) {
+            if (typeof contact === 'number') {
+                contact = getContactById(contact);
+            }
+            const ett1 = metadata[getPointer(contact.GetFixtureA().GetBody())];
+            const ett2 = metadata[getPointer(contact.GetFixtureB().GetBody())];
+            // const event1 = ett1.getComponent(NodeComp)
+            const phys1 = ett1.getComponent(ColliderPhysics);
+            const phys2 = ett2.getComponent(ColliderPhysics);
+            // const event2 = ett2.getComponent(NodeComp)
+            if (phys1 && phys2) {
+                if (Object.prototype.hasOwnProperty.call(phys1, 'onCollisionExit')) {
+                    phys1.props.onCollisionExit(phys2);
+                }
+                if (Object.prototype.hasOwnProperty.call(phys2, 'onCollisionExit')) {
+                    phys2.props.onCollisionExit(phys1);
+                }
+            }
+        },
+        PreSolve(contact, oldManifold) {
+            console.log('collisionSeparate');
+        },
+        PostSolve(contact, impulse) {
+            console.log('collisionPost');
+        }
+    });
+    return listener;
+};

package/dist/box2d-wasm/PhysicsComponent.d.ts

@@ -0,0 +1,50 @@
+import { BodyType, Vec2 } from 'planck';
+import { NoRenderComponentX } from '..';
+import { PhysicsSprite } from './PhysicsSprite';
+interface RigidBodyProps {
+    type?: BodyType;
+    density?: Float;
+    restitution?: Float;
+    friction?: Float;
+    gravityScale?: Float;
+}
+export declare class RigidBody extends NoRenderComponentX<RigidBodyProps> {
+    body: Box2D.b2Body;
+}
+interface PhysicsMaterialProps {
+    friction?: number;
+    restitution?: number;
+    density?: number;
+}
+export declare class PhysicsMaterial extends NoRenderComponentX<PhysicsMaterialProps> {
+}
+interface ColliderPhysicsProps {
+    tag?: number;
+    group?: number;
+    offset?: Vec2;
+    onCollisionEnter?: (other: ColliderPhysics) => void;
+    onCollisionExit?: (other: ColliderPhysics) => void;
+    onCollisionStay?: (other: ColliderPhysics) => void;
+}
+export declare class ColliderPhysics<T extends ColliderPhysicsProps = ColliderPhysicsProps> extends NoRenderComponentX<T, PhysicsSprite['node']> {
+    enabled: boolean;
+    instance: PhysicsSprite;
+}
+interface BoxColliderPhysicsProps extends ColliderPhysicsProps {
+    width: number;
+    height: number;
+}
+export declare class BoxColliderPhysics extends ColliderPhysics<BoxColliderPhysicsProps> {
+}
+interface CircleColliderPhysicsProps extends ColliderPhysicsProps {
+    radius: number;
+}
+export declare class CircleColliderPhysics extends ColliderPhysics<CircleColliderPhysicsProps> {
+}
+interface PolygonColliderPhysicsProps extends ColliderPhysicsProps {
+    points: Array<Vec2>;
+}
+export declare class PolygonColliderPhysics extends ColliderPhysics<PolygonColliderPhysicsProps> {
+}
+export {};
+//# sourceMappingURL=PhysicsComponent.d.ts.map

package/dist/box2d-wasm/PhysicsComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsComponent.d.ts","sourceRoot":"","sources":["../../src/box2d-wasm/PhysicsComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,UAAU,cAAc;IACtB,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,OAAO,CAAC,EAAE,KAAK,CAAA;IACf,WAAW,CAAC,EAAE,KAAK,CAAA;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAA;IAChB,YAAY,CAAC,EAAE,KAAK,CAAA;CACrB;AAED,qBAAa,SAAU,SAAQ,kBAAkB,CAAC,cAAc,CAAC;IAC/D,IAAI,EAAE,KAAK,CAAC,MAAM,CAAA;CAmBnB;AAED,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AACD,qBAAa,eAAgB,SAAQ,kBAAkB,CAAC,oBAAoB,CAAC;CAE5E;AAED,UAAU,oBAAoB;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,IAAI,CAAA;IACb,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IACnD,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IAClD,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;CACnD;AAED,qBAAa,eAAe,CAAC,CAAC,SAAS,oBAAoB,GAAG,oBAAoB,CAAE,SAAQ,kBAAkB,CAAC,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtI,OAAO,UAAO;IACd,QAAQ,EAAE,aAAa,CAAA;CACxB;AAED,UAAU,uBAAwB,SAAQ,oBAAoB;IAC5D,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AACD,qBAAa,kBAAmB,SAAQ,eAAe,CAAC,uBAAuB,CAAC;CAW/E;AACD,UAAU,0BAA2B,SAAQ,oBAAoB;IAC/D,MAAM,EAAE,MAAM,CAAA;CACf;AACD,qBAAa,qBAAsB,SAAQ,eAAe,CAAC,0BAA0B,CAAC;CACrF;AACD,UAAU,2BAA4B,SAAQ,oBAAoB;IAChE,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;CACpB;AACD,qBAAa,sBAAuB,SAAQ,eAAe,CAAC,2BAA2B,CAAC;CACvF"}

package/dist/box2d-wasm/PhysicsComponent.js

@@ -0,0 +1,17 @@
+import { NoRenderComponentX } from '..';
+export class RigidBody extends NoRenderComponentX {
+}
+export class PhysicsMaterial extends NoRenderComponentX {
+}
+export class ColliderPhysics extends NoRenderComponentX {
+    constructor() {
+        super(...arguments);
+        this.enabled = true;
+    }
+}
+export class BoxColliderPhysics extends ColliderPhysics {
+}
+export class CircleColliderPhysics extends ColliderPhysics {
+}
+export class PolygonColliderPhysics extends ColliderPhysics {
+}

package/dist/box2d-wasm/PhysicsSprite.d.ts

@@ -0,0 +1,11 @@
+import { Container } from 'pixi.js';
+export declare class PhysicsSprite {
+    node: Container;
+    physicsBody: Box2D.b2Body;
+    constructor(node: Container, body: Box2D.b2Body);
+    get x(): number;
+    get y(): number;
+    get angle(): number;
+    addChild(child: Container): void;
+}
+//# sourceMappingURL=PhysicsSprite.d.ts.map

package/dist/box2d-wasm/PhysicsSprite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSprite.d.ts","sourceRoot":"","sources":["../../src/box2d-wasm/PhysicsSprite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEnC,qBAAa,aAAa;IACxB,IAAI,EAAE,SAAS,CAAA;IACf,WAAW,EAAE,KAAK,CAAC,MAAM,CAAA;gBAEb,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,CAAC,MAAM;IAgB/C,IAAI,CAAC,WAEJ;IAED,IAAI,CAAC,WAEJ;IAMD,IAAI,KAAK,WAER;IAED,QAAQ,CAAC,KAAK,EAAE,SAAS;CAG1B"}

package/dist/box2d-wasm/PhysicsSprite.js

@@ -0,0 +1,30 @@
+export class PhysicsSprite {
+    constructor(node, body) {
+        this.node = node;
+        this.physicsBody = body;
+    }
+    // set position(val: Box2D.b2Vec2) {
+    //   this.physicsBody.setPosition(val)
+    // }
+    // set x(val) {
+    //   this.physicsBody.setPosition(Vec2(val, this.y))
+    // }
+    // set y(val) {
+    //   this.physicsBody.setPosition(Vec2(this.x, val))
+    // }
+    get x() {
+        return this.physicsBody.GetPosition().x;
+    }
+    get y() {
+        return this.physicsBody.GetPosition().x;
+    }
+    // set angle(val: number) {
+    //   this.physicsBody.setAngle(val)
+    // }
+    get angle() {
+        return this.physicsBody.GetAngle();
+    }
+    addChild(child) {
+        this.node.addChild(child);
+    }
+}

package/dist/box2d-wasm/PhysicsSystem.d.ts

@@ -0,0 +1,17 @@
+import { EntityManager, EventManager, System } from 'entityx-ts';
+import { Graphics, Vec2 } from '..';
+export declare let box2D: typeof Box2D;
+export declare function initBox2d(): Promise<void>;
+export declare function setColliderMatrix(colliderMatrix?: boolean[][]): void;
+export declare class PhysicsSystem implements System {
+    world: Box2D.b2World;
+    listRemoveBody: Body[];
+    listRemoveShape: Box2D.b2Shape[];
+    colliderMatrix: boolean[][];
+    graphics: Graphics;
+    addDebug(): void;
+    configure(event_manager: EventManager): void;
+    update(entities: EntityManager, events: EventManager, dt: number): void;
+    set gravity(val: Vec2);
+}
+//# sourceMappingURL=PhysicsSystem.d.ts.map

package/dist/box2d-wasm/PhysicsSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../src/box2d-wasm/PhysicsSystem.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACb,YAAY,EAEZ,MAAM,EACP,MAAM,YAAY,CAAC;AACpB,OAAO,EAAa,QAAQ,EAAyB,IAAI,EAAE,MAAM,IAAI,CAAC;AAoBtE,eAAO,IAAI,KAAK,EAAE,OAAO,KAAK,CAAA;AAC9B,wBAAsB,SAAS,kBAE9B;AAED,wBAAgB,iBAAiB,CAAC,cAAc,cAAW,QAG1D;AAOD,qBAAa,aAAc,YAAW,MAAM;IAC1C,KAAK,EAAE,KAAK,CAAC,OAAO,CAAA;IACpB,cAAc,EAAE,IAAI,EAAE,CAAK;IAC3B,eAAe,EAAE,KAAK,CAAC,OAAO,EAAE,CAAK;IACrC,cAAc,cAAW;IACzB,QAAQ,EAAE,QAAQ,CAAA;IAElB,QAAQ;IAKR,SAAS,CAAC,aAAa,EAAE,YAAY;IAyErC,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM;IAYhE,IAAI,OAAO,CAAC,GAAG,EAAE,IAAI,EAIpB;CACF"}

package/dist/box2d-wasm/PhysicsSystem.js

@@ -0,0 +1,145 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import Box2DFactory from 'box2d-wasm';
+import { EventTypes } from 'entityx-ts';
+import { GameWorld, Graphics, instantiate, NodeComp } from '..';
+import { makeContactListener } from './ContactListener';
+import { makeDebugDraw } from './debugDraw';
+import { BoxColliderPhysics, CircleColliderPhysics, ColliderPhysics, PhysicsMaterial, PolygonColliderPhysics, RigidBody, } from './PhysicsComponent';
+import { PhysicsSprite } from './PhysicsSprite';
+// Box2D.b2Fixture.prototype.shouldCollide = function (other) {
+//   const nodeThis: NodeComp = this.getBody().getUserData()
+//   const nodeOther = other.getBody().getUserData() as NodeComp
+//   const { colliderMatrix } = GameWorld.Instance.systems.get(PhysicsSystem)
+//   return colliderMatrix[nodeOther.group][nodeThis.group]
+// }
+export let box2D;
+export function initBox2d() {
+    return __awaiter(this, void 0, void 0, function* () {
+        box2D = yield Box2DFactory();
+    });
+}
+export function setColliderMatrix(colliderMatrix = [[true]]) {
+    const physicsSystem = GameWorld.Instance.systems.get(PhysicsSystem);
+    physicsSystem.colliderMatrix = colliderMatrix;
+}
+const maxTimeStep = 1 / 60;
+const velocityIterations = 1;
+const positionIterations = 1;
+const metadata = {};
+const pixelsPerMeter = 1;
+export class PhysicsSystem {
+    constructor() {
+        this.listRemoveBody = [];
+        this.listRemoveShape = [];
+        this.colliderMatrix = [[true]];
+    }
+    addDebug() {
+        const debugDraw = makeDebugDraw(this.graphics, pixelsPerMeter, box2D);
+        this.world.SetDebugDraw(debugDraw);
+    }
+    configure(event_manager) {
+        const { b2BodyDef, b2_dynamicBody, b2_staticBody, b2FixtureDef, b2PolygonShape, b2Vec2, b2World, getPointer, b2ContactListener } = box2D;
+        const gravity = new b2Vec2(0, 10);
+        this.world = new b2World(gravity);
+        console.log('configure world', event_manager.world.app);
+        // event_manager.world.physicsManager = this
+        const graphics = new Graphics();
+        this.graphics = graphics;
+        graphics.zIndex = 1000;
+        event_manager.world.app.stage.addChild(graphics);
+        // event_manager.subscribe(ComponentAddedEvent(RigidBody), this);
+        event_manager.subscribe(EventTypes.ComponentAdded, BoxColliderPhysics, ({ entity, component }) => {
+            console.log('ComponentAddedEvent BoxColliderPhysics', component);
+            let rigidBody = entity.getComponent(RigidBody);
+            if (!rigidBody) {
+                rigidBody = instantiate(RigidBody);
+                entity.assign(rigidBody);
+            }
+            const { type = 'static', gravityScale = 1, } = rigidBody.props;
+            const physicsMaterial = entity.getComponent(PhysicsMaterial);
+            const { density = 1, friction = 0.5, restitution = 0.3 } = (physicsMaterial === null || physicsMaterial === void 0 ? void 0 : physicsMaterial.props) || {};
+            const box = component;
+            const node = entity.getComponent(NodeComp);
+            const _a = box.props, { width, height } = _a, colliderProps = __rest(_a, ["width", "height"]);
+            // ett.assign(instantiate(ColliderPhysics, { tag, offset }))
+            const { x = 0, y = 0 } = colliderProps.offset || {};
+            const zero = new b2Vec2(0, 0);
+            const position = new b2Vec2(node.posX, node.posY);
+            const offset = new b2Vec2(x, y);
+            const bd = new b2BodyDef();
+            bd.set_type(type === 'dynamic' ? b2_dynamicBody : b2_staticBody);
+            bd.set_position(zero);
+            bd.set_gravityScale(gravityScale);
+            const body = this.world.CreateBody(bd);
+            rigidBody.body = body;
+            // console.log('body', type, b2_dynamicBody, b2_staticBody, getPointer(body));
+            // body.setMassData({ mass: 1 } as any)
+            const physicsNode = new PhysicsSprite(node.instance, body);
+            const square = new b2PolygonShape();
+            square.SetAsBox(width / 2, height / 2);
+            const fixtureDef = new b2FixtureDef();
+            fixtureDef.set_shape(square);
+            fixtureDef.set_density(density);
+            fixtureDef.set_friction(friction);
+            fixtureDef.set_restitution(restitution);
+            body.CreateFixture(fixtureDef);
+            body.SetTransform(position, 0);
+            body.SetLinearVelocity(zero);
+            body.SetAwake(true);
+            body.SetEnabled(true);
+            metadata[getPointer(body)] = node;
+            const physicsCollide = entity.assign(instantiate(ColliderPhysics, colliderProps));
+            physicsCollide.instance = physicsNode;
+            physicsCollide.node = node;
+            box.node = node;
+        });
+        event_manager.subscribe(EventTypes.ComponentAdded, (CircleColliderPhysics), () => { });
+        event_manager.subscribe(EventTypes.ComponentAdded, (PolygonColliderPhysics), () => { });
+        event_manager.subscribe(EventTypes.ComponentRemoved, (NodeComp), () => {
+            // log('ComponentRemovedEvent NodeComp', event);
+            // const node = event.entity.getComponent(NodeComp)
+            // if (node.instance instanceof Sprite) {
+            //   const body = node.instance.getBody()
+            //   this.listRemoveShape.push(...body.shapeList)
+            //   this.listRemoveBody.push(body)
+            // }
+        });
+        const listener = makeContactListener(this.world, metadata, box2D);
+        this.world.SetContactListener(listener);
+    }
+    update(entities, events, dt) {
+        if (this.world) {
+            const clampedDelta = Math.min(dt, maxTimeStep);
+            this.world.Step(clampedDelta, velocityIterations, positionIterations);
+            this.graphics.clear();
+            this.world.DebugDraw();
+            this.graphics.fill();
+            // this.graphics.stroke();
+            // console.log('GetBodyCount', this.world.GetBodyCount());
+        }
+    }
+    set gravity(val) {
+        this.world.SetGravity(new box2D.b2Vec2(val.x, val.y));
+        // this.world.iterations = 60
+        // this.world.collisionSlop = 0.5
+    }
+}