kiwiengine 0.0.1-alpha → 0.5.3

package/src/game-object/game-object-physics.ts

@@ -1,191 +0,0 @@
-import Matter, { IChamferableBodyDefinition } from 'matter-js';
-import { debugMode } from '../utils/debug';
-import { GameObject } from './game-object';
-import { localOffsetToWorld, worldToLocalWithNewWorld } from './transform';
-
-type BaseCollider = { x?: number; y?: number; };
-type RectangleCollider = BaseCollider & { type: 'rect'; width: number; height: number };
-type CircleCollider = BaseCollider & { type: 'circle'; radius: number };
-type VerticesCollider = BaseCollider & { type: 'vert'; vertices: { x: number; y: number }[] };
-export type Collider = RectangleCollider | CircleCollider | VerticesCollider;
-
-export class GameObjectPhysics {
-  #collider?: Collider;
-  #isStatic = false;
-  #isSensor = false;
-  #velocityX = 0;
-  #velocityY = 0;
-  #fixedRotation = false;
-
-  #go: GameObject;
-  #matterBody?: Matter.Body;
-
-  constructor(go: GameObject) {
-    this.#go = go;
-  }
-
-  #removeBody() {
-    const world = this.#go._getWorld();
-    if (!world || !this.#matterBody) return;
-    world._worldPhysics.removeBody(this.#matterBody);
-  }
-
-  #lastScaleX = 1;
-  #lastScaleY = 1;
-  #initialInertia?: number;
-
-  #createBody() {
-    const world = this.#go._getWorld();
-    if (!this.#collider || !world) return;
-
-    const wt = this.#go._wt;
-    const { x: ox, y: oy } = localOffsetToWorld(wt, this.#collider?.x ?? 0, this.#collider?.y ?? 0);
-    const x = wt.x.v + ox;
-    const y = wt.y.v + oy;
-
-    const bodyOpts: IChamferableBodyDefinition = {
-      angle: wt.rotation.v,
-      isStatic: this.#isStatic,
-      isSensor: this.#isSensor,
-      velocity: { x: this.#velocityX, y: this.#velocityY },
-    };
-
-    if (this.#collider.type === 'rect') this.#matterBody = Matter.Bodies.rectangle(x, y, this.#collider.width, this.#collider.height, bodyOpts);
-    else if (this.#collider.type === 'circle') this.#matterBody = Matter.Bodies.circle(x, y, this.#collider.radius, bodyOpts);
-    else if (this.#collider.type === 'vert') this.#matterBody = Matter.Bodies.fromVertices(x, y, [this.#collider.vertices], bodyOpts);
-    else throw new Error('Invalid collider type');
-
-    this.#matterBody.plugin.owner = this.#go;
-    this.#lastScaleX = wt.scaleX.v;
-    this.#lastScaleY = wt.scaleY.v;
-    Matter.Body.scale(this.#matterBody, wt.scaleX.v, wt.scaleY.v);
-
-    this.#initialInertia = this.#matterBody.inertia;
-    if (this.#fixedRotation) {
-      Matter.Body.setInertia(this.#matterBody, Infinity);
-      Matter.Body.setAngularVelocity(this.#matterBody, 0);
-    }
-
-    world._worldPhysics.addBody(this.#matterBody);
-    this.#setDebugRenderStyle();
-  }
-
-  applyChanges() {
-    if (this.#collider && !this.#matterBody) this.#createBody();
-    if (!this.#matterBody) return;
-
-    const wt = this.#go._wt;
-    const { x: ox, y: oy } = localOffsetToWorld(wt, this.#collider?.x ?? 0, this.#collider?.y ?? 0);
-
-    if (wt.x.dirty || wt.scaleX.dirty || wt.y.dirty || wt.scaleY.dirty) {
-      if ((wt.x.dirty || wt.scaleX.dirty) && (wt.y.dirty || wt.scaleY.dirty)) Matter.Body.setPosition(this.#matterBody, { x: wt.x.v + ox, y: wt.y.v + oy });
-      else if (wt.x.dirty || wt.scaleX.dirty) Matter.Body.setPosition(this.#matterBody, { x: wt.x.v + ox, y: this.#matterBody.position.y });
-      else if (wt.y.dirty || wt.scaleY.dirty) Matter.Body.setPosition(this.#matterBody, { x: this.#matterBody.position.x, y: wt.y.v + oy });
-    }
-    if (wt.scaleX.dirty || wt.scaleY.dirty) {
-      const scaleDiffX = wt.scaleX.v / this.#lastScaleX;
-      const scaleDiffY = wt.scaleY.v / this.#lastScaleY;
-      Matter.Body.scale(this.#matterBody, scaleDiffX, scaleDiffY);
-      this.#lastScaleX = wt.scaleX.v;
-      this.#lastScaleY = wt.scaleY.v;
-    }
-    if (wt.rotation.dirty) Matter.Body.setAngle(this.#matterBody, wt.rotation.v);
-
-    const lt = this.#go._lt;
-    if (!wt.x.dirty || !wt.y.dirty || !wt.rotation.dirty) {
-      const { x, y, rotation, newWorldX, newWorldY, newWorldRotation } =
-        worldToLocalWithNewWorld(
-          wt,
-          lt,
-          this.#matterBody.position.x - ox,
-          this.#matterBody.position.y - oy,
-          this.#matterBody.angle
-        );
-      if (!wt.x.dirty) { lt.x.v = x; wt.x.v = newWorldX; }
-      if (!wt.y.dirty) { lt.y.v = y; wt.y.v = newWorldY; }
-      if (!wt.rotation.dirty) { lt.rotation.v = rotation; wt.rotation.v = newWorldRotation; }
-    }
-  }
-
-  destroy() {
-    this.#removeBody();
-  }
-
-  get collider() { return this.#collider; }
-  set collider(value: Collider | undefined) {
-    this.#removeBody();
-    this.#collider = value;
-  }
-
-  get isStatic() {
-    if (this.#matterBody) return this.#matterBody.isStatic;
-    else return this.#isStatic;
-  }
-  set isStatic(value: boolean) {
-    this.#isStatic = value;
-    if (this.#matterBody) Matter.Body.setStatic(this.#matterBody, value);
-    this.#setDebugRenderStyle();
-  }
-
-  get isSensor() {
-    if (this.#matterBody) return this.#matterBody.isSensor;
-    else return this.#isSensor;
-  }
-  set isSensor(value: boolean) {
-    this.#isSensor = value;
-    if (this.#matterBody) this.#matterBody.isSensor = value;
-    this.#setDebugRenderStyle();
-  }
-
-  get velocityX() {
-    if (this.#matterBody) return this.#matterBody.velocity.x;
-    else return this.#velocityX;
-  }
-  set velocityX(value: number) {
-    this.#velocityX = value;
-    if (this.#matterBody) Matter.Body.setVelocity(this.#matterBody, { x: value, y: this.#velocityY });
-  }
-
-  get velocityY() {
-    if (this.#matterBody) return this.#matterBody.velocity.y;
-    else return this.#velocityY;
-  }
-  set velocityY(value: number) {
-    this.#velocityY = value;
-    if (this.#matterBody) Matter.Body.setVelocity(this.#matterBody, { x: this.#velocityX, y: value });
-  }
-
-  get fixedRotation() { return this.#fixedRotation; }
-  set fixedRotation(value: boolean) {
-    this.#fixedRotation = value;
-    if (this.#matterBody) {
-      if (value) {
-        Matter.Body.setInertia(this.#matterBody, Infinity);
-        Matter.Body.setAngularVelocity(this.#matterBody, 0);
-      } else {
-        Matter.Body.setInertia(this.#matterBody, this.#initialInertia!);
-        Matter.Body.setAngularVelocity(this.#matterBody, 0);
-      }
-    }
-  }
-
-  #setDebugRenderStyle() {
-    if (!debugMode || !this.#matterBody) return;
-
-    if (this.#isSensor) {
-      this.#matterBody.render.fillStyle = 'rgba(255,255,0,0.1)';
-      this.#matterBody.render.strokeStyle = 'rgba(255,255,0,0.25)';
-      this.#matterBody.render.lineWidth = 1;
-    }
-    else if (this.#isStatic) {
-      this.#matterBody.render.fillStyle = 'rgba(255,0,0,0.1)';
-      this.#matterBody.render.strokeStyle = 'rgba(255,0,0,0.25)';
-      this.#matterBody.render.lineWidth = 1;
-    }
-    else {
-      this.#matterBody.render.fillStyle = 'rgba(0,255,0,0.1)';
-      this.#matterBody.render.strokeStyle = 'rgba(0,255,0,0.25)';
-      this.#matterBody.render.lineWidth = 1;
-    }
-  }
-}

package/src/game-object/game-object-rendering.ts

@@ -1,27 +0,0 @@
-import { Container } from 'pixi.js';
-import { LocalTransform } from './transform';
-
-export class GameObjectRendering {
-  _container = new Container({ sortableChildren: true });
-  #yBasedDrawOrder = false;
-
-  addChild(child: GameObjectRendering) { this._container.addChild(child._container); }
-  removeChild(child: GameObjectRendering) { this._container.removeChild(child._container); }
-  destroy() { this._container.destroy({ children: true }); }
-
-  applyChanges(lt: LocalTransform) {
-    if (lt.x.dirty) this._container.x = lt.x.v;
-    if (lt.y.dirty) { this._container.y = lt.y.v; if (this.#yBasedDrawOrder) this.drawOrder = lt.y.v; }
-    if (lt.pivotX.dirty) this._container.pivot.x = lt.pivotX.v;
-    if (lt.pivotY.dirty) this._container.pivot.y = lt.pivotY.v;
-    if (lt.scaleX.dirty) this._container.scale.x = lt.scaleX.v;
-    if (lt.scaleY.dirty) this._container.scale.y = lt.scaleY.v;
-    if (lt.rotation.dirty) this._container.rotation = lt.rotation.v;
-    if (lt.alpha.dirty) this._container.alpha = lt.alpha.v;
-  }
-
-  get drawOrder() { return this._container.zIndex; }
-  set drawOrder(v: number) { this._container.zIndex = v; }
-  get yBasedDrawOrder() { return this.#yBasedDrawOrder; }
-  set yBasedDrawOrder(v: boolean) { this.#yBasedDrawOrder = v; if (v) this.drawOrder = this._container.y; }
-}

package/src/game-object/game-object.ts

@@ -1,190 +0,0 @@
-import { EventEmitter, EventMap } from '@webtaku/event-emitter';
-import { Container, Sprite } from 'pixi.js';
-import { textureLoader } from '../asset/loaders/texture';
-import { World } from '../world/world';
-import { Collider, GameObjectPhysics } from './game-object-physics';
-import { GameObjectRendering } from './game-object-rendering';
-import { LocalTransform, WorldTransform } from './transform';
-
-export class GameObject<E extends EventMap = EventMap> extends EventEmitter<E & {
-  update: (dt: number) => void
-}> {
-  _lt = new LocalTransform();
-  _wt = new WorldTransform();
-
-  _rendering = new GameObjectRendering();
-  #physics = new GameObjectPhysics(this);
-
-  #world?: World;
-  #parent?: GameObject;
-  #children: GameObject[] = [];
-
-  data: Record<string, any> = {};
-
-  protected _setWorld(world: World) {
-    this.#world = world;
-    for (const child of this.#children) {
-      child._setWorld(world);
-    }
-  }
-  _getWorld() { return this.#world; }
-
-  add(...children: GameObject[]) {
-    for (const child of children) {
-      if (child.#parent) {
-        const idx = child.#parent.#children.indexOf(child);
-        if (idx !== -1) child.#parent.#children.splice(idx, 1);
-        child.#parent._rendering.removeChild(child._rendering);
-      }
-      if (this.#world) child._setWorld(this.#world);
-      child.#parent = this;
-
-      this.#children.push(child);
-      this._rendering.addChild(child._rendering);
-    }
-  }
-
-  remove() {
-    if (this.#parent) {
-      const idx = this.#parent.#children.indexOf(this);
-      if (idx !== -1) this.#parent.#children.splice(idx, 1);
-      this.#parent = undefined;
-    }
-
-    for (const child of this.#children) {
-      child.#parent = undefined;
-      child.remove();
-    }
-    this.#children.length = 0;
-
-    this._rendering.destroy();
-    this.#physics.destroy();
-  }
-
-  protected update(dt: number): void { }
-
-  protected _afterRender() { }
-  _engineUpdate(dt: number, pt: WorldTransform) {
-    this.update(dt);
-
-    this._wt.update(pt, this._lt);
-    this.#physics.applyChanges();
-    this._rendering.applyChanges(this._lt);
-    this._afterRender();
-    this._lt.markClean();
-
-    (this as any).emit('update', dt);
-
-    for (const child of this.#children) {
-      child._engineUpdate(dt, this._wt);
-    }
-    this._wt.markClean();
-  }
-
-  constructor(opts?: GameObjectOptions) {
-    super();
-    if (opts) {
-      if (opts.x !== undefined) this.x = opts.x;
-      if (opts.y !== undefined) this.y = opts.y;
-      if (opts.pivotX !== undefined) this.pivotX = opts.pivotX;
-      if (opts.pivotY !== undefined) this.pivotY = opts.pivotY;
-      if (opts.scale !== undefined) this.scale = opts.scale;
-      if (opts.scaleX !== undefined) this.scaleX = opts.scaleX;
-      if (opts.scaleY !== undefined) this.scaleY = opts.scaleY;
-      if (opts.rotation !== undefined) this.rotation = opts.rotation;
-      if (opts.alpha !== undefined) this.alpha = opts.alpha;
-
-      if (opts.drawOrder !== undefined) this.drawOrder = opts.drawOrder;
-      if (opts.yBasedDrawOrder !== undefined) this.yBasedDrawOrder = opts.yBasedDrawOrder;
-
-      if (opts.collider !== undefined) this.collider = opts.collider;
-      if (opts.isStatic !== undefined) this.isStatic = opts.isStatic;
-      if (opts.isSensor !== undefined) this.isSensor = opts.isSensor;
-      if (opts.velocityX !== undefined) this.velocityX = opts.velocityX;
-      if (opts.velocityY !== undefined) this.velocityY = opts.velocityY;
-      if (opts.fixedRotation !== undefined) this.fixedRotation = opts.fixedRotation;
-
-      if (opts.image !== undefined) this.image = opts.image;
-    }
-  }
-
-  get x() { return this._lt.x.v; }
-  set x(v: number) { this._lt.x.v = v; }
-  get y() { return this._lt.y.v; }
-  set y(v: number) { this._lt.y.v = v; }
-  get pivotX() { return this._lt.pivotX.v; }
-  set pivotX(v: number) { this._lt.pivotX.v = v; }
-  get pivotY() { return this._lt.pivotY.v; }
-  set pivotY(v: number) { this._lt.pivotY.v = v; }
-  get scale() { return this._lt.scaleX.v; }
-  set scale(v: number) { this._lt.scaleX.v = v; this._lt.scaleY.v = v; }
-  get scaleX() { return this._lt.scaleX.v; }
-  set scaleX(v: number) { this._lt.scaleX.v = v; }
-  get scaleY() { return this._lt.scaleY.v; }
-  set scaleY(v: number) { this._lt.scaleY.v = v; }
-  get rotation() { return this._lt.rotation.v; }
-  set rotation(v: number) { this._lt.rotation.v = v; }
-  get alpha() { return this._lt.alpha.v; }
-  set alpha(v: number) { this._lt.alpha.v = v; }
-
-  get drawOrder() { return this._rendering.drawOrder; }
-  set drawOrder(v: number) { this._rendering.drawOrder = v; }
-  get yBasedDrawOrder() { return this._rendering.yBasedDrawOrder; }
-  set yBasedDrawOrder(v: boolean) { this._rendering.yBasedDrawOrder = v; }
-
-  get collider() { return this.#physics.collider; }
-  set collider(v: Collider | undefined) { this.#physics.collider = v; }
-  get isStatic() { return this.#physics.isStatic; }
-  set isStatic(v: boolean) { this.#physics.isStatic = v; }
-  get isSensor() { return this.#physics.isSensor; }
-  set isSensor(v: boolean) { this.#physics.isSensor = v; }
-  get velocityX() { return this.#physics.velocityX; }
-  set velocityX(v: number) { this.#physics.velocityX = v; }
-  get velocityY() { return this.#physics.velocityY; }
-  set velocityY(v: number) { this.#physics.velocityY = v; }
-  get fixedRotation() { return this.#physics.fixedRotation; }
-  set fixedRotation(v: boolean) { this.#physics.fixedRotation = v; }
-
-  _addPixiChild(child: Container) { this._rendering._container.addChild(child); }
-
-  #image?: string;
-  get image() { return this.#image; }
-  set image(value: string | undefined) {
-    if (value) {
-      if (!textureLoader.checkLoaded(value)) {
-        console.info(`Image not preloaded. Loading now: ${value}`);
-      }
-      textureLoader.load(value).then((texture) => {
-        if (texture) this._addPixiChild(new Sprite({
-          texture,
-          anchor: { x: 0.5, y: 0.5 },
-          zIndex: -999999,
-        }));
-      });
-    }
-  }
-}
-
-export type GameObjectOptions = {
-  x?: number;
-  y?: number;
-  pivotX?: number;
-  pivotY?: number;
-  scale?: number;
-  scaleX?: number;
-  scaleY?: number;
-  rotation?: number;
-  alpha?: number;
-
-  drawOrder?: number;
-  yBasedDrawOrder?: boolean;
-
-  collider?: Collider;
-  isStatic?: boolean;
-  isSensor?: boolean;
-  velocityX?: number;
-  velocityY?: number;
-  fixedRotation?: boolean;
-
-  image?: string;
-};

package/src/game-object/transform.ts

@@ -1,164 +0,0 @@
-class DirtyNumber {
-  #v: number;
-  #dirty: boolean;
-
-  constructor(v: number) {
-    this.#v = v;
-    this.#dirty = false;
-  }
-
-  get dirty(): boolean {
-    return this.#dirty;
-  }
-
-  get v(): number {
-    return this.#v;
-  }
-
-  set v(v: number) {
-    if (this.#v !== v) this.#dirty = true;
-    this.#v = v;
-  }
-
-  markClean() {
-    this.#dirty = false;
-  }
-}
-
-export class LocalTransform {
-  x = new DirtyNumber(0);
-  y = new DirtyNumber(0);
-  pivotX = new DirtyNumber(0);
-  pivotY = new DirtyNumber(0);
-  scaleX = new DirtyNumber(1);
-  scaleY = new DirtyNumber(1);
-  rotation = new DirtyNumber(0);
-  alpha = new DirtyNumber(1);
-
-  markClean() {
-    this.x.markClean();
-    this.y.markClean();
-    this.pivotX.markClean();
-    this.pivotY.markClean();
-    this.scaleX.markClean();
-    this.scaleY.markClean();
-    this.rotation.markClean();
-    this.alpha.markClean();
-  }
-}
-
-export class WorldTransform {
-  x = new DirtyNumber(0);
-  y = new DirtyNumber(0);
-  scaleX = new DirtyNumber(1);
-  scaleY = new DirtyNumber(1);
-  rotation = new DirtyNumber(0);
-  alpha = new DirtyNumber(1);
-
-  update(parent: WorldTransform, local: LocalTransform) {
-    const rx = local.x.v * parent.scaleX.v;
-    const ry = local.y.v * parent.scaleY.v;
-    const pCos = Math.cos(parent.rotation.v);
-    const pSin = Math.sin(parent.rotation.v);
-
-    this.scaleX.v = parent.scaleX.v * local.scaleX.v;
-    this.scaleY.v = parent.scaleY.v * local.scaleY.v;
-
-    const pivotX = local.pivotX.v * this.scaleX.v;
-    const pivotY = local.pivotY.v * this.scaleY.v;
-    const cos = Math.cos(local.rotation.v);
-    const sin = Math.sin(local.rotation.v);
-
-    this.x.v = parent.x.v + (rx * pCos - ry * pSin) - (pivotX * cos - pivotY * sin);
-    this.y.v = parent.y.v + (rx * pSin + ry * pCos) - (pivotX * sin + pivotY * cos);
-
-    this.rotation.v = parent.rotation.v + local.rotation.v;
-    this.alpha.v = parent.alpha.v * local.alpha.v;
-  }
-
-  markClean() {
-    this.x.markClean();
-    this.y.markClean();
-    this.scaleX.markClean();
-    this.scaleY.markClean();
-    this.rotation.markClean();
-    this.alpha.markClean();
-  }
-}
-
-export function localOffsetToWorld(
-  world: WorldTransform,
-  ox: number,
-  oy: number
-): { x: number; y: number } {
-  const cos = Math.cos(world.rotation.v);
-  const sin = Math.sin(world.rotation.v);
-  const sx = ox * world.scaleX.v;
-  const sy = oy * world.scaleY.v;
-
-  const x = sx * cos - sy * sin;
-  const y = sx * sin + sy * cos;
-  return { x, y };
-}
-
-export function worldToLocalWithNewWorld(
-  world: WorldTransform,
-  local: LocalTransform,
-  targetWorldX: number,
-  targetWorldY: number,
-  targetWorldRotation: number
-): {
-  x: number;
-  y: number;
-  rotation: number;
-  newWorldX: number;
-  newWorldY: number;
-  newWorldRotation: number;
-} {
-  const invLocalScaleX = local.scaleX.v !== 0 ? 1 / local.scaleX.v : 0;
-  const invLocalScaleY = local.scaleY.v !== 0 ? 1 / local.scaleY.v : 0;
-
-  const parentScaleX = world.scaleX.v * invLocalScaleX;
-  const parentScaleY = world.scaleY.v * invLocalScaleY;
-  const parentRot = world.rotation.v - local.rotation.v;
-
-  const pCos = Math.cos(parentRot);
-  const pSin = Math.sin(parentRot);
-
-  const cosOld = Math.cos(local.rotation.v);
-  const sinOld = Math.sin(local.rotation.v);
-
-  const pivotX = local.pivotX.v * world.scaleX.v;
-  const pivotY = local.pivotY.v * world.scaleY.v;
-
-  const rx0 = local.x.v * parentScaleX;
-  const ry0 = local.y.v * parentScaleY;
-
-  const parentX = world.x.v - (rx0 * pCos - ry0 * pSin) + (pivotX * cosOld - pivotY * sinOld);
-  const parentY = world.y.v - (rx0 * pSin + ry0 * pCos) + (pivotX * sinOld + pivotY * cosOld);
-
-  const rotation = targetWorldRotation - parentRot;
-
-  const cosNew = Math.cos(rotation);
-  const sinNew = Math.sin(rotation);
-
-  const tx = (targetWorldX - parentX) + (pivotX * cosNew - pivotY * sinNew);
-  const ty = (targetWorldY - parentY) + (pivotX * sinNew + pivotY * cosNew);
-
-  const rx = tx * pCos + ty * pSin;
-  const ry = -tx * pSin + ty * pCos;
-
-  const invParentScaleX = parentScaleX !== 0 ? 1 / parentScaleX : 0;
-  const invParentScaleY = parentScaleY !== 0 ? 1 / parentScaleY : 0;
-
-  const x = rx * invParentScaleX;
-  const y = ry * invParentScaleY;
-
-  const newRx = x * parentScaleX;
-  const newRy = y * parentScaleY;
-  const newWorldX = parentX + (newRx * pCos - newRy * pSin) - (pivotX * cosNew - pivotY * sinNew);
-  const newWorldY = parentY + (newRx * pSin + newRy * pCos) - (pivotX * sinNew + pivotY * cosNew);
-  const newWorldRotation = parentRot + rotation;
-
-  return { x, y, rotation, newWorldX, newWorldY, newWorldRotation };
-}

package/src/game-object-ext/animated-sprite.ts

@@ -1,140 +0,0 @@
-import { EventMap } from '@webtaku/event-emitter';
-import { AnimatedSprite, Spritesheet, SpritesheetData } from 'pixi.js';
-import { getCachedId, spritesheetLoader } from '../asset/loaders/spritesheet';
-import { GameObject, GameObjectOptions } from '../game-object/game-object';
-
-type AnimatedSpriteOptions = {
-  src?: string;
-  atlas?: SpritesheetData;
-  animation?: string;
-  fps?: number;
-  loop?: boolean;
-} & GameObjectOptions;
-
-class AnimatedSpriteObject<E extends EventMap = EventMap> extends GameObject<E & {
-  animationend: (animation: string) => void;
-}> {
-  #id?: string;
-  #sheet?: Spritesheet;
-  #sprite?: AnimatedSprite;
-
-  #src?: string;
-  #atlas?: SpritesheetData;
-  #animation?: string;
-  #fps?: number;
-  #loop?: boolean;
-
-  constructor(opts?: AnimatedSpriteOptions) {
-    super(opts);
-    if (opts) {
-      if (opts.src) this.src = opts.src;
-      if (opts.atlas) this.atlas = opts.atlas;
-      if (opts.animation) this.animation = opts.animation;
-      if (opts.fps) this.fps = opts.fps;
-      if (opts.loop) this.loop = opts.loop;
-    }
-  }
-
-  #updateAnimation() {
-    this.#sprite?.destroy();
-    this.#sprite = undefined;
-
-    if (this.#sheet && this.#animation) {
-      if (!this.#sheet.animations[this.#animation]) {
-        console.error(`Animation not found: ${this.#animation}`);
-        return;
-      }
-      const sprite = new AnimatedSprite(this.#sheet.animations[this.#animation]);
-      sprite.anchor.set(0.5, 0.5);
-      sprite.loop = this.#loop ?? true;
-      sprite.animationSpeed = (this.#fps ?? 0) / 60;
-      sprite.play();
-      this._addPixiChild(sprite);
-      this.#sprite = sprite;
-
-      sprite.onLoop = () => (this as any).emit('animationend', this.#animation);
-      sprite.onComplete = () => (this as any).emit('animationend', this.#animation);
-    }
-  }
-
-  async #load() {
-    if (this.#id) spritesheetLoader.release(this.#id);
-
-    this.#id = undefined;
-    this.#sheet = undefined;
-    this.#sprite?.destroy();
-    this.#sprite = undefined;
-
-    if (this.#src && this.#atlas) {
-      this.#id = getCachedId(this.#src, this.#atlas);
-      if (!spritesheetLoader.checkLoaded(this.#id)) {
-        console.info(`Spritesheet not preloaded. Loading now: ${this.#id}`);
-      }
-      this.#sheet = await spritesheetLoader.load(this.#id, this.#src, this.#atlas);
-    }
-
-    this.#updateAnimation();
-  }
-
-  get src() {
-    return this.#src;
-  }
-
-  set src(src: string | undefined) {
-    if (this.#src !== src) {
-      this.#src = src;
-      this.#load();
-    }
-  }
-
-  get atlas() {
-    return this.#atlas;
-  }
-
-  set atlas(atlas: SpritesheetData | undefined) {
-    if (this.#atlas !== atlas) {
-      this.#atlas = atlas;
-      this.#load();
-    }
-  }
-
-  get animation() {
-    return this.#animation;
-  }
-
-  set animation(animation: string | undefined) {
-    if (this.#animation !== animation) {
-      this.#animation = animation;
-      this.#updateAnimation();
-    }
-  }
-
-  get fps() {
-    return this.#fps;
-  }
-
-  set fps(fps: number | undefined) {
-    if (this.#fps !== fps) {
-      this.#fps = fps;
-      if (this.#sprite) this.#sprite.animationSpeed = (fps ?? 0) / 60;
-    }
-  }
-
-  get loop() {
-    return this.#loop;
-  }
-
-  set loop(loop: boolean | undefined) {
-    if (this.#loop !== loop) {
-      this.#loop = loop;
-      if (this.#sprite) this.#sprite.loop = loop === true;
-    }
-  }
-
-  remove() {
-    if (this.#id) spritesheetLoader.release(this.#id);
-    super.remove();
-  }
-}
-
-export { AnimatedSpriteObject };