@safe-engine/pixi 8.4.7 → 8.5.4

package/src/app.ts

@@ -1,91 +0,0 @@
-import { actionManager } from 'pixi-action-ease'
-import { Application, AssetsClass, Renderer } from 'pixi.js'
-
-import { GameWorld } from './base'
-import { CollideSystem } from './collider'
-import { GUISystem } from './gui/GUISystem'
-import { NoRenderSystem } from './norender/NoRenderSystem'
-import { RenderSystem } from './render/RenderSystem'
-
-export async function startGame(
-  defaultFont,
-  designedResolution = { width: 720, height: 1280 },
-  assetManager: AssetsClass,
-  id = 'gameCanvas',
-): Promise<Application<Renderer>> {
-  const app = new Application()
-  await app.init({
-    antialias: true,
-    resolution: window.devicePixelRatio,
-    resizeTo: window,
-    eventFeatures: {
-      move: true,
-      /** disables the global move events which can be very expensive in large scenes */
-      globalMove: false,
-      click: true,
-      wheel: false,
-    },
-    canvas: document.getElementById(id) as HTMLCanvasElement,
-  })
-  // GameWorld.Instance.setup(NodeComp, app.stage)
-  Object.assign(app.canvas.style, {
-    width: `${window.innerWidth}px`,
-    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
-  GameWorld.Instance.assetManager = assetManager
-  initWorld(defaultFont)
-  startGameLoop(GameWorld.Instance)
-  return app
-}
-
-function startGameLoop(world: GameWorld) {
-  // Listen for frame updates
-  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 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?: string) {
-  const world = GameWorld.Instance
-  world.systems.add(RenderSystem)
-  world.systems.add(CollideSystem)
-  world.systems.add(GUISystem)
-  world.systems.add(NoRenderSystem)
-  world.listUpdate.push(CollideSystem)
-  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/src/base/EnhancedComponent.ts

@@ -1,38 +0,0 @@
-import { Constructor } from 'entityx-ts'
-import { BaseComponentProps } from '..'
-import { NodeComp } from '../components/NodeComp'
-
-export class EnhancedComponent<Props = {}, N extends NodeComp<any> = NodeComp<any>> {
-  props: Props = {} as any
-  enabled = true
-  constructor(data?: BaseComponentProps<EnhancedComponent> & Props) {
-    this.init(data)
-  }
-  init(data?: Props) {
-    if (data) {
-      // console.log('constructor', this.constructor.name, data)
-      Object.keys(data).forEach((key) => {
-        this.props[key] = data[key]
-      })
-    }
-  }
-  node: N
-
-  addComponent<T extends EnhancedComponent>(instance): T {
-    return this.node.addComponent(instance)
-  }
-  getComponent<T extends ComponentType>(component: Constructor<T>): T {
-    return this.node.getComponent(component)
-  }
-  getComponentsInChildren<T extends ComponentType>(component: Constructor<T>): T[] {
-    return this.node.getComponentsInChildren(component)
-  }
-  getComponentInChildren<T extends ComponentType>(component: Constructor<T>): T {
-    return this.node.getComponentInChildren(component)
-  }
-  isEqual(other: EnhancedComponent) {
-    return this.node.entity.id === other.node.entity.id
-  }
-}
-
-export type ComponentType = EnhancedComponent | NodeComp

package/src/base/gworld.ts

@@ -1,20 +0,0 @@
-import { Constructor, System, World } from 'entityx-ts'
-import { Application, AssetsClass } from 'pixi.js'
-
-export class GameWorld extends World {
-  listUpdate: (System | Constructor<System>)[] = []
-  app: Application
-  assetManager: AssetsClass
-  update(dt: number) {
-    this.listUpdate.forEach((system: any) => {
-      this.systems.update(system, dt)
-    })
-  }
-
-  private static _instance: GameWorld
-
-  public static get Instance() {
-    // Do you need arguments? Make it a regular static method instead.
-    return this._instance || (this._instance = new this())
-  }
-}

package/src/base/index.ts

@@ -1,14 +0,0 @@
-import { NodeComp } from '../components/NodeComp'
-
-export * from './EnhancedComponent'
-export * from './gworld'
-export * from './utils'
-
-export interface BaseComponentProps<T> {
-  $ref?: T
-  $push?: T[]
-  $refNode?: NodeComp
-  $pushNode?: NodeComp[]
-  node?: Partial<NodeComp>
-  // [$key: `$${string}`]: string
-}

package/src/base/utils.ts

@@ -1,23 +0,0 @@
-import { Constructor } from 'entityx-ts'
-
-import { GameWorld } from '..'
-import { ComponentX, NoRenderComponentX } from '../components/BaseComponent'
-
-export type GetProps<T> = T extends ComponentX<infer P> ? P : T extends NoRenderComponentX<infer Q> ? Q : never
-
-export function instantiate<T extends ComponentX>(ComponentType: Constructor<T>, data?: GetProps<T>): T {
-  const instance = new ComponentType()
-  instance.init(data)
-  // console.log(ComponentType.name, data, instance)
-  if (!instance.render) {
-    return instance
-  }
-  return instance.render()
-}
-
-export function loadScene<T extends ComponentX>(ComponentType: Constructor<T>) {
-  const world = GameWorld.Instance
-  world.entities.reset()
-  const instance = new ComponentType()
-  instance.render()
-}

package/src/box2d-wasm/ContactListener.ts

@@ -1,66 +0,0 @@
-import { NodeComp } from "..";
-import { ColliderPhysics } from "./PhysicsComponent";
-type Meta = { [key: number]: NodeComp }
-export const makeContactListener = (world: Box2D.b2World, metadata: Meta, box2D: typeof Box2D) => {
-  const { JSContactListener, getPointer, NULL } = box2D
-  function getContactById(contact: number) {
-    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: Box2D.b2Contact | number): void {
-      if (typeof contact === 'number') {
-        contact = getContactById(contact)
-      }
-      const ett1: NodeComp = metadata[getPointer(contact.GetFixtureA().GetBody())]
-      const ett2: NodeComp = 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: Box2D.b2Contact | number): void {
-      if (typeof contact === 'number') {
-        contact = getContactById(contact)
-      }
-      const ett1: NodeComp = metadata[getPointer(contact.GetFixtureA().GetBody())]
-      const ett2: NodeComp = 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: Box2D.b2Contact | number, oldManifold: Box2D.b2Manifold | number): void {
-      console.log('collisionSeparate');
-    },
-    PostSolve(contact: Box2D.b2Contact | number, impulse: Box2D.b2ContactImpulse | number): void {
-      console.log('collisionPost');
-    }
-  });
-  return listener
-}

package/src/box2d-wasm/PhysicsComponent.ts

@@ -1,83 +0,0 @@
-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 class RigidBody extends NoRenderComponentX<RigidBodyProps> {
-  body: Box2D.b2Body
-  // set linearVelocity(vel: Vec2) {
-  //   if (!this.node) {
-  //     return
-  //   }
-  //   const physics = this.node.instance
-  //   if (physics instanceof Sprite) {
-  //     physics.getBody().setVel(vel)
-  //   }
-  // }
-
-  // get linearVelocity() {
-  //   if (!this.node) {
-  //     return Vec2.ZERO
-  //   }
-  //   const physics = this.node.instance
-  //   const vel = (physics as Sprite).getBody().getVel()
-  //   return v2(vel)
-  // }
-}
-
-interface PhysicsMaterialProps {
-  friction?: number
-  restitution?: number
-  density?: number
-}
-export 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 class ColliderPhysics<T extends ColliderPhysicsProps = ColliderPhysicsProps> extends NoRenderComponentX<T, PhysicsSprite['node']> {
-  enabled = true
-  instance: PhysicsSprite
-}
-
-interface BoxColliderPhysicsProps extends ColliderPhysicsProps {
-  width: number
-  height: number
-}
-export class BoxColliderPhysics extends ColliderPhysics<BoxColliderPhysicsProps> {
-
-  // set onCollisionEnter(val) {
-  //   const phys1 = this.getComponent(ColliderPhysics)
-  //   phys1._onCollisionEnter = val
-  // }
-
-  // get onCollisionEnter() {
-  //   const phys1 = this.getComponent(ColliderPhysics)
-  //   return phys1._onCollisionEnter
-  // }
-}
-interface CircleColliderPhysicsProps extends ColliderPhysicsProps {
-  radius: number
-}
-export class CircleColliderPhysics extends ColliderPhysics<CircleColliderPhysicsProps> {
-}
-interface PolygonColliderPhysicsProps extends ColliderPhysicsProps {
-  points: Array<Vec2>
-}
-export class PolygonColliderPhysics extends ColliderPhysics<PolygonColliderPhysicsProps> {
-}

package/src/box2d-wasm/PhysicsSprite.ts

@@ -1,42 +0,0 @@
-import { Container } from 'pixi.js'
-
-export class PhysicsSprite {
-  node: Container
-  physicsBody: Box2D.b2Body
-
-  constructor(node: Container, body: Box2D.b2Body) {
-    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: Container) {
-    this.node.addChild(child)
-  }
-}

package/src/box2d-wasm/PhysicsSystem.ts

@@ -1,142 +0,0 @@
-import Box2DFactory from 'box2d-wasm'
-import { EntityManager, EventManager, EventTypes, System } from 'entityx-ts'
-import { Graphics } from 'pixi.js'
-
-import { GameWorld, instantiate, NodeComp, Vec2 } 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: typeof Box2D
-export async function initBox2d() {
-  box2D = await 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: { [key: number]: NodeComp } = {}
-const pixelsPerMeter = 1
-
-export class PhysicsSystem implements System {
-  world: Box2D.b2World
-  listRemoveBody: Body[] = []
-  listRemoveShape: Box2D.b2Shape[] = []
-  colliderMatrix = [[true]]
-  graphics: Graphics
-
-  addDebug() {
-    const debugDraw = makeDebugDraw(this.graphics, pixelsPerMeter, box2D)
-    this.world.SetDebugDraw(debugDraw)
-  }
-
-  configure(event_manager: EventManager) {
-    const { b2BodyDef, b2_dynamicBody, b2_staticBody, b2FixtureDef, b2PolygonShape, b2Vec2, b2World, getPointer, b2ContactListener } =
-      box2D as typeof Box2D
-    const gravity = new b2Vec2(0, 10)
-    this.world = new b2World(gravity)
-    console.log('configure world', (event_manager.world as GameWorld).app)
-    // event_manager.world.physicsManager = this
-    const graphics = new Graphics()
-    this.graphics = graphics
-    graphics.zIndex = 1000
-    ;(event_manager.world as GameWorld).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?.props || {}
-      const box = component
-      const node = entity.getComponent(NodeComp)
-      const { width, height, ...colliderProps } = box.props
-      // 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: EntityManager, events: EventManager, dt: number) {
-    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: Vec2) {
-    this.world.SetGravity(new box2D.b2Vec2(val.x, val.y))
-    // this.world.iterations = 60
-    // this.world.collisionSlop = 0.5
-  }
-}