@safe-engine/pixi 8.4.6 → 8.5.1

package/src/components/NodeComp.ts

@@ -1,442 +0,0 @@
-import { Constructor, Entity } from 'entityx-ts'
-import { Action, actionManager, Animation } from 'pixi-action-ease'
-import { Color, ColorSource, Container, Point, Sprite, Text } from 'pixi.js'
-
-import { ComponentType, EnhancedComponent, instantiate } from '../base'
-import { updatePoint, Vec2 } from '../core'
-import { Size } from '../core/Size'
-import { ProgressBarComp } from '../gui/GUIComponent'
-import { ExtraDataComp } from '../norender/NoRenderComponent'
-
-export type EventCallbackType = (...args) => void
-export interface EventMap {
-  [key: string]: [EventCallbackType]
-}
-
-type TouchEventCallback = (target: { location: Vec2 }) => void
-
-export class NodeComp<C extends Container = Container> {
-  entity: Entity
-  instance: C
-  events: EventMap = {}
-  data: { [key: string]: any } = {}
-  parent: NodeComp
-  children: NodeComp[] = []
-  actionsList: Animation[] = []
-  // offset: cc.Point = cc.v2(0, 0);
-  name: string
-  // private lastMove: { x: number; y: number }
-  private _group = 0
-  private _active = true
-
-  onTouchStart?: TouchEventCallback
-  onTouchMove?: TouchEventCallback
-  onTouchEnd?: TouchEventCallback
-  onTouchCancel?: TouchEventCallback
-
-  setOnTouchStart(cb: TouchEventCallback) {
-    this.onTouchStart = cb
-    this.instance.on('touchstart', (event) => {
-      const { global } = event
-      this.onTouchStart({ location: updatePoint(global) })
-    })
-  }
-
-  setOnTouchMove(cb: TouchEventCallback) {
-    this.onTouchMove = cb
-    this.instance.on('touchmove', (event) => {
-      const { global } = event
-      this.onTouchMove({ location: updatePoint(global) })
-    })
-  }
-
-  setOnTouchEnd(cb: TouchEventCallback) {
-    this.onTouchEnd = cb
-    this.instance.on('touchend', (event) => {
-      const { global } = event
-      this.onTouchEnd({ location: updatePoint(global) })
-    })
-  }
-
-  setOnTouchCancel(cb: TouchEventCallback) {
-    this.onTouchCancel = cb
-    this.instance.on('touchcancel', (event) => {
-      const { global } = event
-      this.onTouchCancel({ location: updatePoint(global) })
-    })
-  }
-
-  constructor(instance: C, entity: Entity) {
-    this.entity = entity
-    this.instance = instance
-    this.instance.eventMode = 'static'
-  }
-
-  get uuid() {
-    return this.entity.id
-  }
-
-  get position(): Vec2 {
-    return this.getPosition()
-  }
-
-  set position(val: Vec2) {
-    this.setPosition(val.x, val.y)
-  }
-
-  get posX() {
-    return this.instance.x
-  }
-
-  set posX(val: number) {
-    this.instance.x = val
-  }
-
-  get posY() {
-    return this.instance.y
-  }
-
-  set posY(val: number) {
-    this.instance.y = val
-  }
-
-  set xy(val: [number, number]) {
-    this.setPosition(val[0], val[1])
-  }
-
-  get scale() {
-    return this.instance.scale.x
-  }
-
-  set scale(val: number) {
-    this.instance.scale = new Point(val, val)
-  }
-
-  get scaleX() {
-    return this.instance.scale.x
-  }
-
-  set scaleX(val: number) {
-    this.instance.scale.x = val
-  }
-
-  get scaleY() {
-    return this.instance.scale.y
-  }
-
-  set scaleY(val: number) {
-    this.instance.scale.y = val
-  }
-
-  get anchorX() {
-    if (this.instance instanceof Sprite || this.instance instanceof Text) return this.instance.anchor.x
-    return 0
-  }
-
-  set anchorX(val: number) {
-    if (this.instance instanceof Sprite || this.instance instanceof Text) this.instance.anchor.x = val
-  }
-
-  get anchorY() {
-    if (this.instance instanceof Sprite || this.instance instanceof Text) return this.instance.anchor.y
-    return 0
-  }
-
-  set anchorY(val: number) {
-    if (this.instance instanceof Sprite || this.instance instanceof Text) this.instance.anchor.y = val
-  }
-
-  /** rotation is in radians */
-  get rotation() {
-    return this.instance.rotation
-  }
-  /** rotation is in radians */
-  set rotation(val: number) {
-    this.instance.rotation = val
-  }
-
-  /** angle is in degrees. */
-  get angle() {
-    return this.instance.angle
-  }
-  /** angle is in degrees. */
-  set angle(val: number) {
-    this.instance.angle = val
-  }
-
-  get color() {
-    if (this.instance instanceof Sprite) return this.instance.tint
-    if (this.instance instanceof Text) return this.instance.style.fill as ColorSource
-    return 0xffffff
-  }
-
-  set color(val: ColorSource) {
-    if (this.instance instanceof Sprite) this.instance.tint = val
-    if (this.instance instanceof Text) this.instance.style.fill = val
-  }
-
-  get opacity() {
-    return this.instance.alpha
-  }
-
-  set opacity(val: number) {
-    this.instance.alpha = val
-  }
-
-  get active() {
-    if (!this._active) return false
-    let p = this.parent
-    while (p) {
-      if (!p.active) return false
-      p = p.parent
-    }
-    return this.instance.visible && !this.instance.destroyed
-  }
-
-  set active(val: boolean) {
-    this._active = val
-    this.instance.visible = val
-  }
-
-  get group() {
-    return this._group
-  }
-
-  set group(val: number) {
-    this._group = val
-  }
-
-  get width() {
-    return this.instance.width
-  }
-
-  set width(val) {
-    this.instance.width = val
-  }
-
-  get height() {
-    return this.instance.height
-  }
-
-  set height(val) {
-    this.instance.height = val
-  }
-
-  get zIndex() {
-    return this.instance.zIndex
-  }
-
-  set zIndex(val) {
-    this.instance.zIndex = val
-  }
-
-  get childrenCount() {
-    return this.children.length
-  }
-
-  addComponent<T extends ComponentType>(instance): T {
-    return this.entity.assign(instance)
-  }
-
-  getComponent<T extends Constructor<ComponentType>>(component: T): InstanceType<T> {
-    return this.entity.getComponent(component) as any
-  }
-
-  getComponentsInChildren<T extends ComponentType>(component: Constructor<T>): T[] {
-    if (!this.children.length) {
-      return []
-    }
-    const listHave = this.children.filter((child) => {
-      return child.getComponent(component)
-    })
-    return listHave.map((node) => node.getComponent(component))
-  }
-
-  getComponentInChildren<T extends ComponentType>(component: Constructor<T>): T {
-    return this.getComponentsInChildren(component)[0]
-  }
-
-  convertToNodeSpace(point: Vec2) {
-    return this.instance.toLocal(point)
-  }
-
-  convertToNodeSpaceAR(point: Vec2) {
-    return this.instance.toLocal(point)
-  }
-
-  convertToWorldSpaceAR(point: Vec2) {
-    return this.instance.toGlobal(point)
-  }
-
-  getPosition(): Vec2 {
-    return updatePoint(this.instance.position)
-  }
-
-  setPosition(x: number | Point, y?: number) {
-    if (typeof x !== 'number') {
-      this.instance.position = Vec2(x.x, x.y)
-    } else {
-      this.instance.position = Vec2(x, y)
-    }
-  }
-
-  setRotation(deg: number) {
-    this.instance.rotation = deg
-  }
-
-  getRotation() {
-    return this.instance.rotation
-  }
-
-  // setAnchorPoint(point: number | cc.Point, y?: number) {
-  //   this.instance.setAnchorPoint(point, y)
-  // }
-
-  // getAnchorPoint() {
-  //   return this.instance.getAnchorPoint()
-  // }
-
-  // getBoundingBox() {
-  //   const box = this.instance.getBoundingBox()
-  //   box.contains = function (point) {
-  //     return this.x <= point.x && this.x + this.width >= point.x && this.y <= point.y && this.y + this.height >= point.y
-  //   }
-  //   return box
-  // }
-
-  getContentSize(): Size {
-    return this.instance.boundsArea
-  }
-
-  // setContentSize(size: cc.Size | number, height?: number) {
-  //   this.instance.setContentSize(size, height)
-  //   if (this.instance instanceof cc.ClippingNode) {
-  //     const hw = ((size as any).width || size) * 0.5
-  //     const hh = ((size as any).height || height) * 0.5
-  //     const stencil = new cc.DrawNode()
-  //     const rectangle = [cc.p(-hw, -hh), cc.p(hw, -hh), cc.p(hw, hh), cc.p(-hw, hh)]
-  //     stencil.drawPoly(rectangle, cc.Color.WHITE, 0, cc.Color.WHITE)
-  //     // stencil.drawDot(cc.p(-height * 0.5, -height * 0.5), height, cc.Color.WHITE);
-  //     this.instance.stencil = stencil
-  //   }
-  // }
-
-  setColor(color: Color) {
-    if (this.instance instanceof Sprite) (this.instance as Sprite).tint = color
-  }
-
-  setScale(scaleX: number, scaleY?: number) {
-    this.instance.scale.x = scaleX
-    this.instance.scale.x = scaleY || scaleX
-  }
-
-  runAction(act: Action) {
-    const animation = actionManager.runAction(this.instance as any, act)
-    this.actionsList.push(animation)
-  }
-
-  stopAllActions() {
-    this.actionsList.forEach((act) => {
-      actionManager.cancelAction(act)
-    })
-    this.actionsList = []
-  }
-
-  pauseAllActions() {
-    this.actionsList.forEach((anim: Animation) => {
-      anim.isPause = true
-    })
-  }
-
-  resumeAllActions() {
-    this.actionsList.forEach((anim: Animation) => {
-      anim.isPause = false
-    })
-  }
-
-  destroy() {
-    if (this.parent) {
-      this.parent.children = this.parent.children.filter(({ entity }) => entity.id !== this.entity.id)
-    }
-    this.children.forEach((child) => {
-      child.destroy()
-    })
-    this.parent = null
-    this.entity.destroy()
-    this.stopAllActions()
-    this.instance.destroy()
-  }
-
-  removeFromParent() {
-    this.active = false
-    this.stopAllActions()
-    this.instance.removeFromParent()
-  }
-
-  addChild(child: NodeComp, zOrder?: number) {
-    child.parent = this
-    child.active = true
-    this.children.push(child)
-    this.instance.addChild(child.instance)
-    if (zOrder) child.zIndex = zOrder
-  }
-
-  destroyAllChildren() {
-    this.children.forEach((child) => {
-      child.destroy()
-    })
-  }
-
-  removeAllChildren() {
-    this.children.forEach((child) => {
-      child.removeFromParent()
-    })
-  }
-
-  on(name: string, callback: EventCallbackType, target?: any) {
-    const bound = target ? callback.bind(target) : callback
-    if (this.events[name]) {
-      this.events[name].push(bound)
-    } else {
-      this.events[name] = [bound]
-    }
-  }
-
-  off(name: string) {
-    this.events[name] = undefined
-  }
-
-  emit(name: string, ...params: any) {
-    if (this.events[name]) {
-      this.events[name].forEach((fc) => fc(...params))
-    }
-  }
-
-  resolveComponent(component: EnhancedComponent<object, NodeComp>) {
-    // console.log(component.constructor.name, (component.constructor as any).hasRender)
-    if ((component.constructor as any).hasRender) {
-      this.addChild(component.node)
-    } else {
-      this.addComponent(component)
-      if (component instanceof ProgressBarComp) {
-        this.addChild(component.node)
-      }
-    }
-  }
-
-  getData<T>(key: string): T {
-    const data = this.getComponent(ExtraDataComp)
-    if (!data) return console.warn('need add ExtraDataComp to Node') as T
-    return data.getData(key)
-  }
-
-  setData<T>(key: string, value: T) {
-    const data = this.getComponent(ExtraDataComp)
-    // console.log('setData', key, value, data)
-    if (!data) {
-      this.addComponent(instantiate(ExtraDataComp, { key, value }))
-    } else {
-      data.setData(key, value)
-    }
-  }
-}

package/src/components/Scene.ts

@@ -1,17 +0,0 @@
-import { EnhancedComponent, GameWorld } from '../base'
-
-import { NodeComp } from './NodeComp'
-
-export class SceneComponent extends EnhancedComponent<{}, NodeComp> {
-  render() {
-    const world = GameWorld.Instance
-    world.entities.reset()
-    const root = world.entities.create()
-    const node = root.assign(new NodeComp(GameWorld.Instance.app.stage, root))
-    GameWorld.Instance.app.stage.eventMode = 'static';
-    GameWorld.Instance.app.stage.hitArea = GameWorld.Instance.app.screen;
-    const sceneComponent = root.assign(this)
-    sceneComponent.node = node
-    return sceneComponent
-  }
-}

package/src/core/Color.ts

@@ -1,7 +0,0 @@
-import { Color } from 'pixi.js';
-
-export function Color4B(r: number, g: number, b: number, a: number) {
-  return new Color({ r, g, b, a })
-}
-
-export type Color4B = ReturnType<typeof Color4B>

package/src/core/LoadingBar.ts

@@ -1,63 +0,0 @@
-import { Container, Graphics, Point, Sprite, Texture } from 'pixi.js'
-
-export enum LoadingBarMode {
-  BAR,
-  RADIAL,
-}
-
-export class LoadingBar extends Graphics {
-  spriteComp: Sprite
-  mode: LoadingBarMode
-  fillCenter = new Point(0.5, 0.5)
-  constructor(mode: LoadingBarMode, spriteComp: Sprite) {
-    super()
-    this.spriteComp = spriteComp
-    this.mode = mode || LoadingBarMode.BAR
-    this.fill(0xffffff)
-    this.rect(0, 0, spriteComp.width, spriteComp.height)
-    spriteComp.mask = this
-    spriteComp.addChild(this)
-  }
-
-  set progress(val: number) {
-    this.clear()
-    this.fill(0xffffff)
-    if (this.mode === LoadingBarMode.BAR) {
-      const spriteComp = this.spriteComp
-      this.rect(0, 0, spriteComp.width * val, spriteComp.height)
-      // console.log('new length', spriteComp.width)
-      this.x = -spriteComp.width * 0.5
-      this.y = -spriteComp.height * 0.5
-    }
-  }
-}
-
-export class ProgressTimer extends Container {
-  graphics: Graphics
-  spriteComp: Sprite
-  mode: LoadingBarMode
-  fillCenter = new Point(0.5, 0.5)
-  constructor(mode: LoadingBarMode, spriteFrame: string) {
-    super()
-    const texture = Texture.from(spriteFrame)
-    this.spriteComp = Sprite.from(texture)
-    this.graphics = new Graphics()
-    this.mode = mode || LoadingBarMode.BAR
-    this.graphics.fill(0xffffff)
-    this.graphics.rect(0, 0, this.spriteComp.width, this.spriteComp.height)
-    this.spriteComp.mask = this.graphics
-    this.addChild(this.graphics)
-    this.addChild(this.spriteComp)
-    // this.graphics.x = -this.spriteComp.width * this.fillCenter.x
-    // this.graphics.y = -this.spriteComp.height * this.fillCenter.y
-  }
-
-  set progress(val: number) {
-    this.graphics.clear()
-    if (this.mode === LoadingBarMode.BAR) {
-      this.graphics.rect(0, 0, this.spriteComp.width * val, this.spriteComp.height)
-      // console.log('new length', this.width)
-      this.graphics.fill(0xffffff)
-    }
-  }
-}

package/src/core/NodePool.ts

@@ -1,28 +0,0 @@
-import { NodeComp } from "../components/NodeComp"
-
-export class NodePool {
-  items: NodeComp[] = []
-
-  put(node: NodeComp) {
-    if (node) {
-      node.active = false
-      node.removeFromParent()
-      this.items.push(node)
-    }
-  }
-
-  get(): NodeComp {
-    const node = this.items.pop()
-    node.active = true
-    return node
-  }
-
-  size() {
-    return this.items.length
-  }
-
-  clear() {
-    this.items.forEach((node) => node.destroy())
-    this.items.length = 0
-  }
-}

package/src/core/Size.ts

@@ -1,21 +0,0 @@
-class _Size {
-  width: number
-  height: number
-  static ZERO
-  constructor(width = 0, height = 0) {
-    if (!(this instanceof _Size)) {
-      return new _Size(width, height)
-    }
-    if (height === undefined) {
-      this.width = (width as any).width
-      this.height = (width as any).height
-    }
-    this.width = width
-    this.height = height
-  }
-}
-
-export type Size = _Size
-export function Size(x?: number, y?: number): Size {
-  return new _Size(x, y)
-}

package/src/core/Vec2.ts

@@ -1,108 +0,0 @@
-import { Point } from 'pixi.js'
-
-import { clampf } from './math'
-
-export function updatePoint(p) {
-  const { x, y } = p
-  return Vec2(x, y)
-}
-
-class _Vec2 {
-  x: number
-  y: number
-  static ZERO
-  constructor(x: number | object = 0, y = 0) {
-    if (!(this instanceof _Vec2)) {
-      return new _Vec2(x, y)
-    }
-    if (typeof x === 'object') {
-      this.x = (x as any).x
-      this.y = (x as any).y
-      return
-    }
-    this.x = x
-    this.y = y
-  }
-
-  equals(other: _Vec2) {
-    return this.x === other.x && this.y === other.y
-  }
-
-  add(value: Point | Vec2): _Vec2 {
-    return updatePoint(new Point(this.x, this.y).add(value))
-  }
-
-  addSelf(value: Point | Vec2): _Vec2 {
-    const nor = updatePoint(new Point(this.x, this.y).add(value))
-    this.x = nor.x
-    this.y = nor.y
-    return nor
-  }
-
-  sub(value: Point | Vec2): _Vec2 {
-    return updatePoint(new Point(this.x, this.y).subtract(value))
-  }
-
-  mul(multiply: number): _Vec2 {
-    return updatePoint(new Point(this.x, this.y).multiply(new Point(multiply, multiply)))
-  }
-
-  mulSelf(multiply: number): _Vec2 {
-    const nor = updatePoint(new Point(this.x, this.y).multiply(new Point(multiply, multiply)))
-    this.x = nor.x
-    this.y = nor.y
-    return nor
-  }
-
-  mag(): number {
-    return new Point(this.x, this.y).magnitude()
-  }
-
-  normalizeSelf(): _Vec2 {
-    const nor = updatePoint(new Point(this.x, this.y).normalize())
-    this.x = nor.x
-    this.y = nor.y
-    return nor
-  }
-
-  normalize(): _Vec2 {
-    return updatePoint(new Point(this.x, this.y).normalize())
-  }
-
-  public cross(other: Vec2) {
-    return this.x * other.y - this.y * other.x
-  }
-  public signAngle(other: Vec2) {
-    const angle = this.angle(other)
-    return this.cross(other) < 0 ? -angle : angle
-  }
-  public lengthSqr() {
-    return this.x * this.x + this.y * this.y
-  }
-  public dot(other: Vec2) {
-    return this.x * other.x + this.y * other.y
-  }
-  public angle(other: Vec2) {
-    const magSqr1 = this.lengthSqr()
-    const magSqr2 = other.lengthSqr()
-
-    if (magSqr1 === 0 || magSqr2 === 0) {
-      console.warn('Cant get angle between zero vector')
-      return 0.0
-    }
-
-    const dot = this.dot(other)
-    let theta = dot / Math.sqrt(magSqr1 * magSqr2)
-    theta = clampf(theta, -1.0, 1.0)
-    return Math.acos(theta)
-  }
-  public distance(other: _Vec2) {
-    return this.sub(other).mag()
-  }
-}
-export type Vec2 = _Vec2
-export function Vec2(x?: number | object, y?: number): Vec2 {
-  return new _Vec2(x, y)
-}
-
-Vec2.ZERO = Object.freeze(Vec2(0, 0))

package/src/core/director.ts

@@ -1,11 +0,0 @@
-// import { app } from "../app"
-
-import { GameWorld } from ".."
-
-export function pauseAll() {
-  GameWorld.Instance.app.ticker.stop()
-}
-
-export function resumeAll() {
-  GameWorld.Instance.app.ticker.start()
-}

package/src/core/index.ts

@@ -1,7 +0,0 @@
-export * from './Color'
-export * from './director'
-export * from './loader'
-export * from './math'
-export * from './NodePool'
-// export * from './Size'
-export * from './Vec2'