@safe-engine/pixi 8.4.6 → 8.5.1

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
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-export * from 'pixi.js'
-export * from './app'
-export * from './base'
-export * from './collider'
-export * from './collider/helper/Intersection'
-export * from './components/BaseComponent'
-export * from './components/NodeComp'
-export * from './components/Scene'
-export * from './core'
-export * from './dragonbones'
-export * from './gui/GUIComponent'
-export * from './gui/GUISystem'
-export * from './helper/utils'
-export * from './norender/NoRenderComponent'
-export * from './norender/Touch'
-export * from './render/RenderComponent'
-export * from './render/RenderSystem'
-export * from './richtext'
-export * from './spine'

package/src/norender/NoRenderComponent.ts

@@ -1,60 +0,0 @@
-import { NoRenderComponentX } from '../components/BaseComponent'
-import { EventCallbackType, EventMap, NodeComp } from '../components/NodeComp'
-import { Touch } from './Touch'
-
-// export class Touch extends FederatedPointerEvent {
-// declare getLocation: () => Vec2
-// declare getDelta: () => Vec2
-// }
-
-export type TouchEventCallback = (touch?: Touch, node?: NodeComp) => void
-
-export class EventRegister extends NoRenderComponentX {
-  events: EventMap = {}
-
-  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, callback?: EventCallbackType, target?: any)
-  off(name: string) {
-    this.events[name] = undefined
-  }
-
-  emit(name: string, ...params: any) {
-    if (this.events[name]) {
-      this.events[name].forEach((fc) => fc(...params))
-    }
-  }
-}
-
-interface TouchEventProps {
-  onTouchStart?: TouchEventCallback
-  onTouchMove?: TouchEventCallback
-  onTouchEnd?: TouchEventCallback
-  onTouchCancel?: TouchEventCallback
-}
-export class TouchEventRegister extends NoRenderComponentX<TouchEventProps> {
-  listener: EventListener
-  touch: Touch
-}
-
-interface ExtraDataProps {
-  key: string
-  value: any
-}
-export class ExtraDataComp extends NoRenderComponentX<ExtraDataProps> {
-  data: { [key: string]: any } = {}
-
-  getData<T>(key: string): T {
-    return this.data[key]
-  }
-  setData<T>(key: string, val: T) {
-    this.data[key] = val
-  }
-}

package/src/norender/NoRenderSystem.ts

@@ -1,67 +0,0 @@
-import { EventManager, EventTypes, System } from 'entityx-ts'
-// import { Touch } from '../../polyfills'
-import { Container } from 'pixi.js'
-
-import { NodeComp } from '../components/NodeComp'
-import { ExtraDataComp, TouchEventRegister } from './NoRenderComponent'
-import { Touch } from './Touch'
-
-export class NoRenderSystem implements System {
-  configure(event_manager: EventManager) {
-    event_manager.subscribe(EventTypes.ComponentAdded, ExtraDataComp, ({ component }) => {
-      const { key, value } = component.props
-      component.data[key] = value
-    })
-    event_manager.subscribe(EventTypes.ComponentAdded, TouchEventRegister, ({ entity, component }) => {
-      const ett = entity
-      const touchComp = component
-      const nodeComp = ett.getComponent(NodeComp)
-      touchComp.node = nodeComp
-      const container: Container = nodeComp.instance
-      if (touchComp.props.onTouchStart) {
-        container.on('pointerdown', (event) => {
-          touchComp.props.onTouchStart(new Touch(event), nodeComp)
-        })
-      }
-      if (touchComp.props.onTouchMove) {
-        container.on('pointermove', (event) => {
-          touchComp.props.onTouchMove(new Touch(event), nodeComp)
-        })
-      }
-      if (touchComp.props.onTouchEnd) {
-        container.on('pointerup', (event) => {
-          touchComp.props.onTouchEnd(new Touch(event), nodeComp)
-        })
-      }
-      if (touchComp.props.onTouchEnd) {
-        container.on('pointercancel', (event) => {
-          touchComp.props.onTouchEnd(new Touch(event), nodeComp)
-        })
-      }
-    })
-    event_manager.subscribe(EventTypes.ComponentRemoved, TouchEventRegister, ({ component }) => {
-      console.log('ComponentRemovedEvent TouchEventRegister', event)
-      // const ett = event.entity
-      // const nodeComp = ett.getComponent(NodeComp)
-      const touchComp = component as TouchEventRegister
-      const container: Container = touchComp.node.instance
-      if (touchComp.props.onTouchStart) {
-        container.removeListener('touchstart')
-      }
-      if (touchComp.props.onTouchMove) {
-        container.removeListener('touchmove')
-      }
-      if (touchComp.props.onTouchEnd) {
-        container.removeListener('touchend')
-      }
-      if (touchComp.props.onTouchEnd) {
-        container.removeListener('touchcancel')
-      }
-    })
-  }
-
-  // update(entities: EntityManager, events: EventManager, dt: number)
-  // update() {
-  // throw new Error('Method not implemented.');
-  // }
-}

package/src/norender/Touch.ts

@@ -1,37 +0,0 @@
-import { FederatedPointerEvent } from 'pixi.js'
-
-import { Vec2 } from '..'
-
-export class Touch {
-  private event: FederatedPointerEvent
-  constructor(event) {
-    this.event = event
-  }
-
-  getLocation(): ReturnType<typeof Vec2> {
-    return Vec2(this.event.global)
-  }
-  getLocationX() {
-    return this.event.globalX
-  }
-  getLocationY() {
-    return this.event.globalY
-  }
-  getDelta(): ReturnType<typeof Vec2> {
-    return Vec2(this.event.movementX, this.event.movementY)
-  }
-  getDeltaX() {
-    return this.event.movementX
-  }
-  getDeltaY() {
-    return this.event.movementY
-  }
-  getLocationInView(view: any) {
-    const { x, y } = this.event.global
-    return view.toLocal({ x, y })
-  }
-  getLocationInNode(node: any) {
-    const { x, y } = this.event.global
-    return node.toLocal({ x, y })
-  }
-}