@vpmedia/phaser 1.0.1 → 1.0.3

package/package.json

@@ -1,47 +1,53 @@
 {
   "name": "@vpmedia/phaser",
-  "version": "1.0.1",
+  "version": "1.0.3",
+  "description": "@vpmedia/phaser is the modern ECMAScript port of the popular Phaser game engine v2.6.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",
+  "homepage": "https://github.com/vpmedia/phaser#readme",
+  "bugs": {
+    "url": "https://github.com/vpmedia/phaser/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vpmedia/phaser.git"
+  },
+  "keywords": [
+    "phaser"
+  ],
+  "main": "./src/index.js",
   "devDependencies": {
     "@babel/cli": "^7.19.3",
     "@babel/core": "^7.19.6",
     "@babel/eslint-parser": "^7.19.1",
     "@babel/preset-env": "^7.19.4",
     "@babel/register": "^7.18.9",
-    "babel-loader": "^8.2.5",
-    "chai": "^4.3.6",
+    "babel-loader": "^8.3.0",
     "eslint": "^8.26.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jsdoc": "^39.5.0",
+    "eslint-plugin-jest": "^27.1.3",
+    "eslint-plugin-jsdoc": "^39.6.2",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.1",
+    "jest": "^29.2.2",
     "lint-staged": "^13.0.3",
-    "mocha": "^10.1.0",
-    "mocha-junit-reporter": "^2.1.1",
     "prettier": "^2.7.1",
-    "sinon": "^14.0.1",
-    "sinon-chai": "^3.7.0",
     "webpack": "^5.74.0",
     "webpack-cli": "^4.10.0"
   },
   "scripts": {
     "prebuild": "rm -rf ./dist && mkdir -p ./dist",
     "build": "webpack --config webpack.config.babel.js --mode production",
-    "test": "mocha \"test/**/*test.js\" --require test/setup.js --require @babel/register --colors",
-    "lint": "eslint src/**/*.js && eslint test/**/*.js",
-    "lint-fix": "eslint src/**/*.js --fix && eslint test/**/*.js --fix",
+    "test": "jest --passWithNoTests",
+    "lint": "eslint \"**/*.js\"",
+    "lint-fix": "eslint \"**/*.js\" --fix",
     "format": "prettier --write \"**/*.{js,json}\"",
     "lint-staged": "lint-staged",
     "prepack": "npm run build"
   },
   "engines": {
-    "npm": ">=8.0.0",
-    "node": ">=18.0.0"
+    "npm": ">=7.0.0",
+    "node": ">=16.0.0"
   }
 }

package/src/index.js

@@ -0,0 +1,142 @@
+/**
+ * @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;
+    }
+  }
+
+}