@safe-engine/pixi 8.4.7 → 8.5.4

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'

package/src/core/loader.ts

@@ -1,14 +0,0 @@
-import { AssetsClass } from 'pixi.js'
-
-const jsonCache = {}
-export function loadJsonAsync<T>(Assets: AssetsClass) {
-  return async (filePath: string): Promise<T> => {
-    const json = await Assets.load(filePath)
-    jsonCache[filePath] = json
-    return json
-  }
-}
-
-export function loadJsonFromCache<T>(filePath: string): T {
-  return jsonCache[filePath]
-}

package/src/core/math.ts

@@ -1,22 +0,0 @@
-import { DEG_TO_RAD, RAD_TO_DEG } from 'pixi.js'
-
-export function randomRangeInt(minInclude: Integer, maxExclude: Integer) {
-  return Math.round(Math.random() * (maxExclude - minInclude - 1)) + minInclude
-}
-
-export function degreesToRadians(deg: Float) {
-  return DEG_TO_RAD * deg
-}
-
-export function radiansToDegrees(rad: Float) {
-  return RAD_TO_DEG * rad
-}
-
-export function clampf(theta: number, arg1: number, arg2: number): number {
-  if (theta < arg1) {
-    return arg1
-  } else if (theta > arg2) {
-    return arg2
-  }
-  return theta
-}

package/src/dragonbones/DragonBonesComponent.ts

@@ -1,32 +0,0 @@
-import { ComponentX } from "../components/BaseComponent"
-interface DragonBonesData {
-  atlas: string
-  skeleton: string
-  texture: string
-}
-
-interface DragonBonesProps {
-  data: DragonBonesData
-  skin?: string
-  animation?: string
-  playTimes?: number
-  timeScale?: number
-  onAnimationStart?: (event: { name: string }) => void
-  onAnimationEnd?: (event: { name: string }) => void
-  onAnimationComplete?: (event: { name: string }) => void
-}
-export class DragonBones extends ComponentX<DragonBonesProps> {
-
-  setAnimation(name: string, playTimes = 0) {
-    const skel: any = this.node.instance
-    if (skel.animation) {
-      skel.animation.play(name, playTimes)
-    }
-  }
-
-  setSkeletonData(data: string) {
-    const skel: any = this.node.instance
-    const atlas = data.replace('.json', '.atlas')
-    skel.initWithArgs(data, atlas, this.node.scale)
-  }
-}

package/src/dragonbones/DragonBonesSystem.ts

@@ -1,35 +0,0 @@
-import { PixiFactory } from 'dragonbones-pixijs';
-import { EntityManager, EventManager, EventTypes, System } from 'entityx-ts';
-
-import { Assets } from 'pixi.js';
-import { GameWorld } from '../base';
-import { NodeComp } from '../components/NodeComp';
-import { DragonBones } from './DragonBonesComponent';
-
-export class DragonBonesSystem implements System {
-  configure(event_manager: EventManager<GameWorld>) {
-    event_manager.subscribe(EventTypes.ComponentAdded, DragonBones, ({ entity, component }) => {
-      const { data, animation, playTimes = 0 } = component.props
-      const { skeleton, atlas, texture } = data
-      const skeletonAsset = Assets.get(skeleton)
-      const atlasAsset = Assets.get(atlas)
-      const textureAsset = Assets.get(texture)
-      const armatureName = skeletonAsset.armature[0].name
-      // console.log(skeletonAsset, textureAsset, atlasAsset)
-      const factory = PixiFactory.factory;
-      factory.parseDragonBonesData(skeletonAsset);
-      factory.parseTextureAtlasData(atlasAsset, textureAsset)
-      const armatureDisplay = factory.buildArmatureDisplay(armatureName)!;
-      armatureDisplay.debugDraw = false;
-      const node = armatureDisplay;
-      if (animation) {
-        armatureDisplay.animation.play(animation, playTimes);
-      }
-      component.node = entity.assign(new NodeComp(node, entity))
-    })
-    // event_manager.subscribe(EventTypes.ComponentRemoved, DragonBones, ({ }) => { })
-  }
-
-  update(entities: EntityManager, events: EventManager<GameWorld>, dt: number) {
-  }
-}

package/src/dragonbones/index.ts

@@ -1,11 +0,0 @@
-import { GameWorld } from '..'
-import { DragonBonesSystem } from './DragonBonesSystem'
-
-export * from './DragonBonesComponent'
-export * from './DragonBonesSystem'
-
-export function setupDragonBones() {
-  GameWorld.Instance.systems.add(DragonBonesSystem)
-  GameWorld.Instance.listUpdate.push(DragonBonesSystem)
-  GameWorld.Instance.systems.configureOnce(DragonBonesSystem)
-}

package/src/gui/GUIComponent.ts

@@ -1,155 +0,0 @@
-import { CheckBox, CheckBoxOptions, Input, List, ProgressBar, RadioGroup, Slider, SliderOptions } from '@pixi/ui'
-import { Assets, Container, Point, Text } from 'pixi.js'
-
-import { BaseComponentProps } from '..'
-import { ComponentX, NoRenderComponentX } from '../components/BaseComponent'
-import { Color4B } from '../core/Color'
-import { LoadingBarMode, ProgressTimer } from '../core/LoadingBar'
-
-export const FillType = {
-  HORIZONTAL: 0,
-  VERTICAL: 1,
-  RADIAL: 2,
-}
-// type Keys = keyof typeof FillType
-// type Values = (typeof FillType)[Keys]
-
-interface ButtonCompProps extends BaseComponentProps<ButtonComp> {
-  normalImage?: string
-  selectedImage?: string
-  disableImage?: string
-  zoomScale?: number
-  onPress: (target: ButtonComp) => void
-}
-export class ButtonComp extends NoRenderComponentX<ButtonCompProps> {
-  // setOnPress(cb: (target: ButtonComp) => void) {
-  //   this.onPress = cb
-  // }
-  // set enabled(val) {
-  //   this.node.instance.interactive = val
-  // }
-}
-
-export class ProgressBarComp extends ComponentX<{}, ProgressBar> {
-  mode = LoadingBarMode.BAR
-  isReverse: boolean
-  bg: string
-  fill: string
-
-  get progress() {
-    return this.node.instance.progress
-  }
-
-  set progress(val: number) {
-    this.node.instance.progress = val
-  }
-}
-interface LabelCompProps extends BaseComponentProps<LabelComp> {
-  font?: string
-  string?: string
-  size?: number
-}
-export class LabelComp extends ComponentX<LabelCompProps, Text> {
-  get string() {
-    return this.props.string
-  }
-
-  set string(val: string) {
-    this.props.string = val
-    if (!this.node) return
-    if (this.node.instance instanceof Text) {
-      this.node.instance.text = val
-    }
-  }
-
-  get size() {
-    return this.props.size
-  }
-  set size(val) {
-    this.props.size = val
-    if (!this.node) return
-    if (this.node.instance instanceof Text) {
-      this.node.instance.style.fontSize = val
-    }
-  }
-
-  get font() {
-    return this.props.font
-  }
-
-  set font(val: string) {
-    this.props.font = val
-    if (!this.node) return
-    // console.log('set font', val, Assets.get(val))
-    if (this.node.instance instanceof Text) {
-      if (Assets.get(val)) this.node.instance.style.fontFamily = Assets.get(val).family
-    }
-  }
-}
-
-interface ScrollViewProps {
-  width: number
-  height: number
-}
-export class ScrollView extends NoRenderComponentX<ScrollViewProps> {}
-
-export class BlockInputEventsComp extends NoRenderComponentX {}
-
-interface ProgressTimerProps extends BaseComponentProps<ProgressTimerComp> {
-  spriteFrame: string
-  fillType?: number
-  fillRange?: number
-  fillCenter?: Point
-  isReverse?: boolean
-}
-export class ProgressTimerComp extends ComponentX<ProgressTimerProps, ProgressTimer> {
-  getFillRange() {
-    return this.node.instance.progress
-  }
-
-  setFillStart(val: number) {
-    this.node.instance.fillCenter.x = val
-  }
-
-  setFillRange(val: number) {
-    // console.log('setFillRange', this.node.instance);
-    this.node.instance.progress = val
-  }
-}
-
-interface LabelOutlineCompProps {
-  color: Color4B
-  width: number
-}
-export class LabelOutlineComp extends NoRenderComponentX<LabelOutlineCompProps> {}
-
-interface LabelShadowCompProps extends BaseComponentProps<LabelShadowComp> {
-  color: Color4B
-  blur: number
-  offset?: Point
-}
-export class LabelShadowComp extends NoRenderComponentX<LabelShadowCompProps> {}
-
-interface InputCompProps extends BaseComponentProps<InputComp> {
-  placeHolder?: string
-  font?: string
-  size?: Integer
-  maxLength?: Integer
-  isPassword?: boolean
-  bg?: string
-  // fill?: FillInput
-}
-export class InputComp extends ComponentX<InputCompProps, Input> {
-  get string() {
-    return this.node.instance.value
-  }
-}
-
-export class ListComp extends ComponentX<{}, List> {}
-export class SliderComp extends ComponentX<{}, Slider> {
-  bg: string
-  fill: SliderOptions['fill']
-  slider: Container
-}
-export class RadioGroupComp extends ComponentX<{}, RadioGroup> {}
-export class CheckBoxComp extends ComponentX<{ style: CheckBoxOptions['style'] }, CheckBox> {}

package/src/gui/GUISystem.ts

@@ -1,125 +0,0 @@
-import { Button, CheckBox, Input, List, RadioGroup, ScrollBox } from '@pixi/ui'
-import { EventManager, EventTypes, System } from 'entityx-ts'
-import { callFunc, easeBackIn, scaleTo, sequence } from 'pixi-action-ease'
-import { Text } from 'pixi.js'
-
-import { Color4B, NodeComp } from '..'
-import { GameWorld } from '../base'
-import { LoadingBarMode, ProgressTimer } from '../core/LoadingBar'
-import {
-  ButtonComp,
-  CheckBoxComp,
-  InputComp,
-  LabelComp,
-  LabelOutlineComp,
-  LabelShadowComp,
-  ListComp,
-  ProgressTimerComp,
-  RadioGroupComp,
-  ScrollView,
-} from './GUIComponent'
-
-export class GUISystem implements System {
-  defaultFont: string
-  configure(event_manager: EventManager<GameWorld>) {
-    event_manager.subscribe(EventTypes.ComponentAdded, ButtonComp, ({ entity, component }) => {
-      const nodeComp = entity.getComponent(NodeComp)
-      // const { normalImage, selectedImage, disableImage, texType, zoomScale } = button
-      // console.log('onPress.ButtonComp', component)
-      const button = new Button(nodeComp.instance)
-      // node.setZoomScale(zoomScale - 1)
-      component.node = nodeComp
-      // component.node = entity.assign(new NodeComp(node, entity))
-      button.onPress.connect(() => {
-        if (!component.enabled) return
-        // console.log('onPress.connect')
-        const scale = scaleTo(0.5, 1.2)
-        const scaleDown = scaleTo(0.5, 1)
-        const seq = sequence(
-          scale,
-          callFunc(() => {
-            if (Object.prototype.hasOwnProperty.call(component.props, 'onPress')) {
-              component.props.onPress(component)
-            }
-          }),
-          scaleDown,
-        )
-        const ease = easeBackIn(seq)
-        component.node.runAction(ease)
-      })
-    })
-    // event_manager.subscribe(EventTypes.ComponentAdded, ProgressBarComp, ({ entity, component }) => {
-    //   const { progress = 1, bg, fill } = component.props
-    //   const node = new ProgressBar({ bg, fill, progress })
-    //   component.node = entity.assign(new NodeComp(node, entity))
-    // })
-    event_manager.subscribe(EventTypes.ComponentAdded, ProgressTimerComp, ({ entity, component }) => {
-      // console.log(component, '.progress')
-      const { spriteFrame, fillCenter, fillRange = 0 } = component.props
-      const node = new ProgressTimer(LoadingBarMode.BAR, spriteFrame)
-      if (fillCenter) {
-        node.fillCenter = fillCenter
-      }
-      node.progress = fillRange * 100
-      component.node = entity.assign(new NodeComp(node, entity))
-    })
-    event_manager.subscribe(EventTypes.ComponentAdded, ScrollView, ({ entity, component }) => {
-      const { width, height } = component.props
-      const view = new ScrollBox({ width, height })
-      component.node = entity.assign(new NodeComp(view, entity))
-    })
-    event_manager.subscribe(EventTypes.ComponentAdded, ListComp, ({ entity, component }) => {
-      const view = new List()
-      component.node = entity.assign(new NodeComp(view, entity))
-    })
-    // event_manager.subscribe(EventTypes.ComponentAdded, SliderComp, ({ entity, component }) => {
-    //   const { bg, slider, fill } = component.props
-    //   const view = new Slider({ bg, fill, slider })
-    //   component.node = entity.assign(new NodeComp(view, entity))
-    // })
-    event_manager.subscribe(EventTypes.ComponentAdded, RadioGroupComp, ({ entity, component }) => {
-      const view = new RadioGroup()
-      component.node = entity.assign(new NodeComp(view, entity))
-    })
-    event_manager.subscribe(EventTypes.ComponentAdded, CheckBoxComp, ({ entity, component }) => {
-      const { style } = component.props
-      const view = new CheckBox({ style })
-      component.node = entity.assign(new NodeComp(view, entity))
-    })
-    event_manager.subscribe(EventTypes.ComponentAdded, InputComp, ({ entity, component }) => {
-      const { bg, size = 48 } = component.props
-      const view = new Input({ bg, textStyle: { fontSize: size, fill: { color: Color4B(255, 255, 255, 255) } } })
-      component.node = entity.assign(new NodeComp(view, entity))
-    })
-    event_manager.subscribe(EventTypes.ComponentAdded, LabelComp, ({ entity, component }) => {
-      // console.log('ComponentAddedEvent LabelComp', component)
-      const node = new Text()
-      // node.texture.rotate = 8
-      node.style.fill = '#fff'
-      component.node = entity.assign(new NodeComp(node, entity))
-      const { string = '', font = this.defaultFont, size = 64 } = component.props
-      if (font) component.font = font
-      component.size = size
-      component.string = string
-    })
-    event_manager.subscribe(EventTypes.ComponentAdded, LabelOutlineComp, ({ entity, component }) => {
-      const { color, width } = component.props
-      const node = entity.getComponent(NodeComp)
-      if (node.instance instanceof Text) {
-        node.instance.style.stroke = { color, width }
-      }
-    })
-    event_manager.subscribe(EventTypes.ComponentAdded, LabelShadowComp, ({ entity, component }) => {
-      const { color, blur } = component.props
-      const node = entity.getComponent(NodeComp)
-      if (node.instance instanceof Text) {
-        node.instance.style.dropShadow = { color, blur, alpha: 1, angle: 0, distance: 0 }
-      }
-    })
-
-    // event_manager.subscribe(EventTypes.ComponentAdded, BlockInputEventsComp), this);
-  }
-  // update() {
-  // throw new Error('Method not implemented.');
-  // }
-}

package/src/helper/utils.ts

@@ -1,50 +0,0 @@
-import { Constructor, EntityManager, EventManager, EventReceive, EventTypes, System } from 'entityx-ts';
-import { Point } from 'pixi.js';
-import { EnhancedComponent, GameWorld } from '../base';
-
-import { NodeComp } from '../components/NodeComp';
-
-export function v2(x: number | { x: number, y: number } = 0, y = 0) {
-  if (typeof x === 'object' && 'x' in x && 'y' in x) {
-    return new Point(x.x, x.y)
-  }
-  return new Point(x, y)
-}
-
-export function getDistance(point1: Point, point2: Point) {
-  const dx = point2.x - point1.x;
-  const dy = point2.y - point1.y;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-
-export function registerSystem<T extends EnhancedComponent<any>>(component: Constructor<T>) {
-  if (GameWorld.Instance.systems.isRegistered(`${component.name}System`)) {
-    return
-  }
-  class NewSystem implements System {
-    configure(event_manager: EventManager<GameWorld>) {
-      console.log('configure registerSystem core', component.name)
-      event_manager.subscribe(EventTypes.ComponentAdded, component, (event: EventReceive<T>) => {
-        // console.log('receiveComponentAddedEvent', event)
-        const ett = event.entity
-        const newComp = ett.getComponent<T>(component)
-        newComp.node = ett.getComponent(NodeComp)
-      })
-    }
-
-    update(entities: EntityManager, events: EventManager<GameWorld>, dt: number) {
-      for (const entt of entities.entities_with_components(component)) {
-        const comp = entt.getComponent(component)
-        // console.log('comp', comp.constructor.name, typeof comp['update'] === 'function')
-        if (comp.node.active && typeof comp['update'] === 'function') {
-          comp['update'](dt)
-        }
-      }
-    }
-  }
-  Object.defineProperty(NewSystem, 'name', { value: `${component.name}System` })
-  GameWorld.Instance.systems.add(NewSystem)
-  GameWorld.Instance.systems.configureOnce(NewSystem)
-  GameWorld.Instance.listUpdate.push(NewSystem)
-  return NewSystem
-}