@vpmedia/phaser 1.0.1 → 1.0.2

package/dist/phaser.cjs.LICENSE.txt

@@ -1 +1 @@
-/*! @vpmedia/phaser Copyright (c) 2022-present Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu) Wed Nov 02 2022 14:47:58 GMT+0100 (Central European Standard Time) */
+/*! @vpmedia/phaser Copyright (c) 2022-present Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu) Wed Nov 02 2022 14:59:47 GMT+0100 (Central European Standard Time) */

package/dist/phaser.js.LICENSE.txt

@@ -1 +1 @@
-/*! @vpmedia/phaser Copyright (c) 2022-present Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu) Wed Nov 02 2022 14:47:58 GMT+0100 (Central European Standard Time) */
+/*! @vpmedia/phaser Copyright (c) 2022-present Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu) Wed Nov 02 2022 14:59:47 GMT+0100 (Central European Standard Time) */

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@vpmedia/phaser",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "author": "Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)",
   "license": "MIT",
   "homepage": "https://github.com/vpmedia/phaser",
   "private": false,
-  "main": "./dist/phaser.cjs",
-  "module": "./dist/phaser.cjs",
+  "main": "./src/index.js",
   "devDependencies": {
     "@babel/cli": "^7.19.3",
     "@babel/core": "^7.19.6",

package/src/index.js

@@ -0,0 +1,99 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import * as Const from './phaser/core/const';
+import AnimationManager from './phaser/core/animation_manager';
+import * as AnimationParser from './phaser/core/animation_parser';
+import ArraySet from './phaser/core/array_set';
+import Device from './phaser/core/device';
+import * as DeviceUtils from './phaser/core/device_util';
+import DOM from './phaser/core/dom';
+import EventManager from './phaser/core/event_manager';
+import Frame from './phaser/core/frame';
+import FrameData from './phaser/core/frame_data';
+import InputManager from './phaser/core/input';
+import InputMouse from './phaser/core/input_mouse';
+import InputMSPointer from './phaser/core/input_mspointer';
+import InputPointer from './phaser/core/input_pointer';
+import InputTouch from './phaser/core/input_touch';
+import Loader from './phaser/core/loader';
+import GameLoopRAF from './phaser/core/raf';
+import GameLoopTO from './phaser/core/raf_to';
+import GameLoopFB from './phaser/core/raf_fb';
+import ScaleManager from './phaser/core/scale_manager';
+import Scene from './phaser/core/scene';
+import SceneManager from './phaser/core/scene_manager';
+import Signal from './phaser/core/signal';
+import SignalBinding from './phaser/core/signal_binding';
+import Sound from './phaser/core/sound';
+import SoundManager from './phaser/core/sound_manager';
+import Time from './phaser/core/time';
+import Timer from './phaser/core/timer';
+import TimerEvent from './phaser/core/timer_event';
+import Tween from './phaser/core/tween';
+import TweenData from './phaser/core/tween_data';
+import * as TweenEasing from './phaser/core/tween_easing';
+import TweenManager from './phaser/core/tween_manager';
+import Circle from './phaser/geom/circle';
+import Ellipse from './phaser/geom/ellipse';
+import Line from './phaser/geom/line';
+import Matrix from './phaser/geom/matrix';
+import Point from './phaser/geom/point';
+import Polygon from './phaser/geom/polygon';
+import Rectangle from './phaser/geom/rectangle';
+import * as MathUtils from './phaser/util/math';
+import * as StringUtils from './phaser/util/string';
+import RoundedRectangle from './phaser/geom/rounded_rectangle';
+import * as CircleUtils from './phaser/geom/util/circle';
+import * as EllipseUtils from './phaser/geom/util/ellipse';
+import * as LineUtils from './phaser/geom/util/line';
+import * as MatrixUtils from './phaser/geom/util/matrix';
+import * as PointUtils from './phaser/geom/util/point';
+import * as PolygonUtils from './phaser/geom/util/polygon';
+import * as RectangleUtils from './phaser/geom/util/rectangle';
+import * as RoundedRectangleUtils from './phaser/geom/util/rounded_rectangle';
+import GraphicsData from './phaser/display/graphics_data';
+import * as CanvasPool from './phaser/display/canvas/pool';
+import * as CanvasUtils from './phaser/display/canvas/util';
+import * as CanvasTinter from './phaser/display/canvas/tinter';
+import * as CanvasMasker from './phaser/display/canvas/masker';
+import * as CanvasGraphics from './phaser/display/canvas/graphics';
+import CanvasBuffer from './phaser/display/canvas/buffer';
+import CanvasRenderer from './phaser/display/canvas/renderer';
+import * as EarCut from './phaser/display/webgl/earcut';
+import Game from './phaser/core/game';
+import BitmapText from './phaser/display/bitmap_text';
+import DisplayObject from './phaser/display/display_object';
+import Button from './phaser/display/button';
+import Image from './phaser/display/image';
+import Group from './phaser/display/group';
+import Text from './phaser/display/text';
+
+export {
+  Const,
+  AnimationManager, AnimationParser,
+  ArraySet,
+  DOM,
+  Device, DeviceUtils,
+  EventManager,
+  Frame, FrameData,
+  InputManager, InputMouse, InputMSPointer, InputPointer, InputTouch,
+  Loader,
+  GameLoopRAF, GameLoopTO, GameLoopFB,
+  MathUtils, StringUtils,
+  ScaleManager,
+  Scene, SceneManager,
+  Signal, SignalBinding,
+  Sound, SoundManager,
+  Time, Timer, TimerEvent,
+  Tween, TweenData, TweenEasing, TweenManager,
+  Circle, CircleUtils, Ellipse, EllipseUtils, Line, LineUtils, Matrix, MatrixUtils, Point, PointUtils,
+  Polygon, PolygonUtils, Rectangle, RectangleUtils, RoundedRectangle, RoundedRectangleUtils,
+  Game,
+  GraphicsData,
+  CanvasPool, CanvasUtils, CanvasBuffer, CanvasTinter, CanvasMasker, CanvasGraphics, CanvasRenderer,
+  EarCut,
+  BitmapText, Button, DisplayObject, Image, Group, Text,
+};

package/src/phaser/core/animation.js

@@ -0,0 +1,355 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Signal from './signal';
+
+export default class {
+
+  constructor(game, parent, name, frameData, frames, frameRate, loop = false) {
+    this.game = game;
+    this._parent = parent;
+    this._frameData = frameData;
+    this.name = name;
+    this._frames = [];
+    this._frames = this._frames.concat(frames);
+    this.delay = 1000 / frameRate;
+    this.loop = loop;
+    this.loopCount = 0;
+    this.killOnComplete = false;
+    this.isFinished = false;
+    this.isPlaying = false;
+    this.isPaused = false;
+    this._pauseStartTime = 0;
+    this._frameIndex = 0;
+    this._frameDiff = 0;
+    this._frameSkip = 1;
+    this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
+    this.onStart = new Signal();
+    this.onUpdate = null;
+    this.onComplete = new Signal();
+    this.onLoop = new Signal();
+    this.isReversed = false;
+    //  Set-up some event listeners
+    this.game.onPause.add(this.onPause, this);
+    this.game.onResume.add(this.onResume, this);
+  }
+
+  play(frameRate, loop, killOnComplete) {
+    if (typeof frameRate === 'number') {
+      //  If they set a new frame rate then use it, otherwise use the one set on creation
+      this.delay = 1000 / frameRate;
+    }
+    if (typeof loop === 'boolean') {
+      //  If they set a new loop value then use it, otherwise use the one set on creation
+      this.loop = loop;
+    }
+    if (typeof killOnComplete !== 'undefined') {
+      //  Remove the parent sprite once the animation has finished?
+      this.killOnComplete = killOnComplete;
+    }
+    this.isPlaying = true;
+    this.isFinished = false;
+    this.paused = false;
+    this.loopCount = 0;
+    this._timeLastFrame = this.game.time.time;
+    this._timeNextFrame = this.game.time.time + this.delay;
+    this._frameIndex = this.isReversed ? this._frames.length - 1 : 0;
+    this.updateCurrentFrame(false, true);
+    this._parent.events.onAnimationStart$dispatch(this._parent, this);
+    this.onStart.dispatch(this._parent, this);
+    this._parent.animations.currentAnim = this;
+    this._parent.animations.currentFrame = this.currentFrame;
+    return this;
+  }
+
+  restart() {
+    this.isPlaying = true;
+    this.isFinished = false;
+    this.paused = false;
+    this.loopCount = 0;
+    this._timeLastFrame = this.game.time.time;
+    this._timeNextFrame = this.game.time.time + this.delay;
+    this._frameIndex = 0;
+    this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
+    this._parent.setFrame(this.currentFrame);
+    this._parent.animations.currentAnim = this;
+    this._parent.animations.currentFrame = this.currentFrame;
+    this.onStart.dispatch(this._parent, this);
+  }
+
+  reverse() {
+    this.reversed = !this.reversed;
+    return this;
+  }
+
+  reverseOnce() {
+    this.onComplete.addOnce(this.reverse, this);
+    return this.reverse();
+  }
+
+  setFrame(frameId, useLocalFrameIndex = false) {
+    let frameIndex;
+    //  Find the index to the desired frame.
+    if (typeof frameId === 'string') {
+      for (let i = 0; i < this._frames.length; i += 1) {
+        if (this._frameData.getFrame(this._frames[i]).name === frameId) {
+          frameIndex = i;
+        }
+      }
+    } else if (typeof frameId === 'number') {
+      if (useLocalFrameIndex) {
+        frameIndex = frameId;
+      } else {
+        for (let i = 0; i < this._frames.length; i += 1) {
+          if (this._frames[i] === frameId) {
+            frameIndex = i;
+          }
+        }
+      }
+    }
+    if (frameIndex) {
+      //  Set the current frame index to the found index. Subtract 1 so that it animates to the desired frame on update.
+      this._frameIndex = frameIndex - 1;
+      //  Make the animation update at next update
+      this._timeNextFrame = this.game.time.time;
+      this.update();
+    }
+  }
+
+  stop(resetFrame = false, dispatchComplete = false) {
+    this.isPlaying = false;
+    this.isFinished = true;
+    this.paused = false;
+    if (resetFrame) {
+      this.currentFrame = this._frameData.getFrame(this._frames[0]);
+      if (this.currentFrame) {
+        this._parent.setFrame(this.currentFrame);
+      }
+    }
+    if (dispatchComplete) {
+      this._parent.events.onAnimationComplete$dispatch(this._parent, this);
+      this.onComplete.dispatch(this._parent, this);
+    }
+  }
+
+  onPause() {
+    if (this.isPlaying) {
+      this._frameDiff = this._timeNextFrame - this.game.time.time;
+    }
+  }
+
+  onResume() {
+    if (this.isPlaying) {
+      this._timeNextFrame = this.game.time.time + this._frameDiff;
+    }
+  }
+
+  update() {
+    if (this.isPaused) {
+      return false;
+    }
+    if (this.isPlaying && this.game.time.time >= this._timeNextFrame) {
+      this._frameSkip = 1;
+      //  Lagging?
+      this._frameDiff = this.game.time.time - this._timeNextFrame;
+      this._timeLastFrame = this.game.time.time;
+      if (this._frameDiff > this.delay) {
+        //  We need to skip a frame, work out how many
+        this._frameSkip = Math.floor(this._frameDiff / this.delay);
+        this._frameDiff -= (this._frameSkip * this.delay);
+      }
+      //  And what's left now?
+      this._timeNextFrame = this.game.time.time + (this.delay - this._frameDiff);
+      if (this.isReversed) {
+        this._frameIndex -= this._frameSkip;
+      } else {
+        this._frameIndex += this._frameSkip;
+      }
+      if (!this.isReversed && this._frameIndex >= this._frames.length || this.isReversed && this._frameIndex <= -1) {
+        if (this.loop) {
+          // Update current state before event callback
+          this._frameIndex = Math.abs(this._frameIndex) % this._frames.length;
+          if (this.isReversed) {
+            this._frameIndex = this._frames.length - 1 - this._frameIndex;
+          }
+          this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
+          //  Instead of calling updateCurrentFrame we do it here instead
+          if (this.currentFrame) {
+            this._parent.setFrame(this.currentFrame);
+          }
+          this.loopCount += 1;
+          this._parent.events.onAnimationLoop$dispatch(this._parent, this);
+          this.onLoop.dispatch(this._parent, this);
+          if (this.onUpdate) {
+            this.onUpdate.dispatch(this, this.currentFrame);
+            // False if the animation was destroyed from within a callback
+            return !!this._frameData;
+          }
+          return true;
+        }
+        this.complete();
+        return false;
+      }
+      return this.updateCurrentFrame(true);
+    }
+
+    return false;
+  }
+
+  updateCurrentFrame(signalUpdate, fromPlay = false) {
+    if (!this._frameData || !this.currentFrame) {
+      // The animation is already destroyed, probably from a callback
+      return false;
+    }
+    //  Previous index
+    const idx = this.currentFrame.index;
+    this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
+    if (this.currentFrame && (fromPlay || (!fromPlay && idx !== this.currentFrame.index))) {
+      this._parent.setFrame(this.currentFrame);
+    }
+    if (this.onUpdate && signalUpdate) {
+      this.onUpdate.dispatch(this, this.currentFrame);
+      // False if the animation was destroyed from within a callback
+      return !!this._frameData;
+    }
+    return true;
+  }
+
+  next(quantity = 1) {
+    let frame = this._frameIndex + quantity;
+    if (frame >= this._frames.length) {
+      if (this.loop) {
+        frame %= this._frames.length;
+      } else {
+        frame = this._frames.length - 1;
+      }
+    }
+    if (frame !== this._frameIndex) {
+      this._frameIndex = frame;
+      this.updateCurrentFrame(true);
+    }
+  }
+
+  previous(quantity = 1) {
+    let frame = this._frameIndex - quantity;
+    if (frame < 0) {
+      if (this.loop) {
+        frame = this._frames.length + frame;
+      } else {
+        frame += 1;
+      }
+    }
+    if (frame !== this._frameIndex) {
+      this._frameIndex = frame;
+      this.updateCurrentFrame(true);
+    }
+  }
+
+  updateFrameData(frameData) {
+    this._frameData = frameData;
+    this.currentFrame = this._frameData ? this._frameData.getFrame(this._frames[this._frameIndex % this._frames.length]) : null;
+  }
+
+  destroy() {
+    if (!this._frameData) {
+      // Already destroyed
+      return;
+    }
+    this.game.onPause.remove(this.onPause, this);
+    this.game.onResume.remove(this.onResume, this);
+    this.game = null;
+    this._parent = null;
+    this._frames = null;
+    this._frameData = null;
+    this.currentFrame = null;
+    this.isPlaying = false;
+    this.onStart.dispose();
+    this.onLoop.dispose();
+    this.onComplete.dispose();
+    if (this.onUpdate) {
+      this.onUpdate.dispose();
+    }
+  }
+
+  complete() {
+    this._frameIndex = this._frames.length - 1;
+    this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
+    this.isPlaying = false;
+    this.isFinished = true;
+    this.paused = false;
+    this._parent.events.onAnimationComplete$dispatch(this._parent, this);
+    this.onComplete.dispatch(this._parent, this);
+    if (this.killOnComplete) {
+      this._parent.kill();
+    }
+  }
+
+  get paused() {
+    return this.isPaused;
+  }
+
+  set paused(value) {
+    this.isPaused = value;
+    if (value) {
+      this._pauseStartTime = this.game.time.time;
+    } else if (this.isPlaying) {
+      this._timeNextFrame = this.game.time.time + this.delay;
+    }
+  }
+
+  get reversed() {
+    return this.isReversed;
+  }
+
+  set reversed(value) {
+    this.isReversed = value;
+  }
+
+  get frameTotal() {
+    return this._frames.length;
+  }
+
+  get frame() {
+    if (this.currentFrame !== null) {
+      return this.currentFrame.index;
+    }
+    return this._frameIndex;
+  }
+
+  set frame(value) {
+    this.currentFrame = this._frameData.getFrame(this._frames[value]);
+    if (this.currentFrame !== null) {
+      this._frameIndex = value;
+      this._parent.setFrame(this.currentFrame);
+      if (this.onUpdate) {
+        this.onUpdate.dispatch(this, this.currentFrame);
+      }
+    }
+  }
+
+  get speed() {
+    return 1000 / this.delay;
+  }
+
+  set speed(value) {
+    if (value > 0) {
+      this.delay = 1000 / value;
+    }
+  }
+
+  get enableUpdate() {
+    return (this.onUpdate !== null);
+  }
+
+  set enableUpdate(value) {
+    if (value && this.onUpdate === null) {
+      this.onUpdate = new Signal();
+    } else if (!value && this.onUpdate !== null) {
+      this.onUpdate.dispose();
+      this.onUpdate = null;
+    }
+  }
+
+}