@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/core/event_manager.js

@@ -0,0 +1,243 @@
+/**
+ * @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(sprite) {
+    this.parent = sprite;
+    this._onAddedToGroup = null;
+    this._onRemovedFromGroup = null;
+    this._onDestroy = null;
+    this._onOutOfBounds = null;
+    this._onEnterBounds = null;
+    this._onInputOver = null;
+    this._onInputOut = null;
+    this._onInputDown = null;
+    this._onInputUp = null;
+    this._onDragStart = null;
+    this._onDragUpdate = null;
+    this._onDragStop = null;
+    this._onAnimationStart = null;
+    this._onAnimationComplete = null;
+    this._onAnimationLoop = null;
+  }
+
+  destroy() {
+    this._parent = null;
+    if (this._onDestroy) { this._onDestroy.dispose(); }
+    if (this._onAddedToGroup) { this._onAddedToGroup.dispose(); }
+    if (this._onRemovedFromGroup) { this._onRemovedFromGroup.dispose(); }
+    if (this._onEnterBounds) { this._onEnterBounds.dispose(); }
+    if (this._onOutOfBounds) { this._onOutOfBounds.dispose(); }
+    if (this._onInputOver) { this._onInputOver.dispose(); }
+    if (this._onInputOut) { this._onInputOut.dispose(); }
+    if (this._onInputDown) { this._onInputDown.dispose(); }
+    if (this._onInputUp) { this._onInputUp.dispose(); }
+    if (this._onDragStart) { this._onDragStart.dispose(); }
+    if (this._onDragUpdate) { this._onDragUpdate.dispose(); }
+    if (this._onDragStop) { this._onDragStop.dispose(); }
+    if (this._onAnimationStart) { this._onAnimationStart.dispose(); }
+    if (this._onAnimationComplete) { this._onAnimationComplete.dispose(); }
+    if (this._onAnimationLoop) { this._onAnimationLoop.dispose(); }
+  }
+
+  get onAddedToGroup() {
+    if (!this._onAddedToGroup) {
+      this._onAddedToGroup = new Signal();
+    }
+    return this._onAddedToGroup;
+  }
+
+  onAddedToGroup$dispatch(...args) {
+    if (this._onAddedToGroup) {
+      this._onAddedToGroup.dispatch(...args);
+    }
+  }
+
+  get onRemovedFromGroup() {
+    if (!this._onRemovedFromGroup) {
+      this._onRemovedFromGroup = new Signal();
+    }
+    return this._onRemovedFromGroup;
+  }
+
+  onRemovedFromGroup$dispatch(...args) {
+    if (this._onRemovedFromGroup) {
+      this._onRemovedFromGroup.dispatch(...args);
+    }
+  }
+
+  get onDestroy() {
+    if (!this._onDestroy) {
+      this._onDestroy = new Signal();
+    }
+    return this._onDestroy;
+  }
+
+  onDestroy$dispatch(...args) {
+    if (this._onDestroy) {
+      this._onDestroy.dispatch(...args);
+    }
+  }
+
+  get onOutOfBounds() {
+    if (!this._onOutOfBounds) {
+      this._onOutOfBounds = new Signal();
+    }
+    return this._onOutOfBounds;
+  }
+
+  onOutOfBounds$dispatch(...args) {
+    if (this._onOutOfBounds) {
+      this._onOutOfBounds.dispatch(...args);
+    }
+  }
+
+  get onEnterBounds() {
+    if (!this._onEnterBounds) {
+      this._onEnterBounds = new Signal();
+    }
+    return this._onEnterBounds;
+  }
+
+  onEnterBounds$dispatch(...args) {
+    if (this._onEnterBounds) {
+      this._onEnterBounds.dispatch(...args);
+    }
+  }
+
+  get onInputOver() {
+    if (!this._onInputOver) {
+      this._onInputOver = new Signal();
+    }
+    return this._onInputOver;
+  }
+
+  onInputOver$dispatch(...args) {
+    if (this._onInputOver) {
+      this._onInputOver.dispatch(...args);
+    }
+  }
+
+  get onInputOut() {
+    if (!this._onInputOut) {
+      this._onInputOut = new Signal();
+    }
+    return this._onInputOut;
+  }
+
+  onInputOut$dispatch(...args) {
+    if (this._onInputOut) {
+      this._onInputOut.dispatch(...args);
+    }
+  }
+
+  get onInputDown() {
+    if (!this._onInputDown) {
+      this._onInputDown = new Signal();
+    }
+    return this._onInputDown;
+  }
+
+  onInputDown$dispatch(...args) {
+    if (this._onInputDown) {
+      this._onInputDown.dispatch(...args);
+    }
+  }
+
+  get onInputUp() {
+    if (!this._onInputUp) {
+      this._onInputUp = new Signal();
+    }
+    return this._onInputUp;
+  }
+
+  onInputUp$dispatch(...args) {
+    if (this._onInputUp) {
+      this._onInputUp.dispatch(...args);
+    }
+  }
+
+  get onDragStart() {
+    if (!this._onDragStart) {
+      this._onDragStart = new Signal();
+    }
+    return this._onDragStart;
+  }
+
+  onDragStart$dispatch(...args) {
+    if (this._onDragStart) {
+      this._onDragStart.dispatch(...args);
+    }
+  }
+
+  get onDragUpdate() {
+    if (!this._onDragUpdate) {
+      this._onDragUpdate = new Signal();
+    }
+    return this._onDragUpdate;
+  }
+
+  onDragUpdate$dispatch(...args) {
+    if (this._onDragUpdate) {
+      this._onDragUpdate.dispatch(...args);
+    }
+  }
+
+  get onDragStop() {
+    if (!this._onDragStop) {
+      this._onDragStop = new Signal();
+    }
+    return this._onDragStop;
+  }
+
+  onDragStop$dispatch(...args) {
+    if (this._onDragStop) {
+      this._onDragStop.dispatch(...args);
+    }
+  }
+
+  get onAnimationStart() {
+    if (!this._onAnimationStart) {
+      this._onAnimationStart = new Signal();
+    }
+    return this._onAnimationStart;
+  }
+
+  onAnimationStart$dispatch(...args) {
+    if (this._onAnimationStart) {
+      this._onAnimationStart.dispatch(...args);
+    }
+  }
+
+  get onAnimationComplete() {
+    if (!this._onAnimationComplete) {
+      this._onAnimationComplete = new Signal();
+    }
+    return this._onAnimationComplete;
+  }
+
+  onAnimationComplete$dispatch(...args) {
+    if (this._onAnimationComplete) {
+      this._onAnimationComplete.dispatch(...args);
+    }
+  }
+
+  get onAnimationLoop() {
+    if (!this._onAnimationLoop) {
+      this._onAnimationLoop = new Signal();
+    }
+    return this._onAnimationLoop;
+  }
+
+  onAnimationLoop$dispatch(...args) {
+    if (this._onAnimationLoop) {
+      this._onAnimationLoop.dispatch(...args);
+    }
+  }
+
+}

package/src/phaser/core/factory.js

@@ -0,0 +1,74 @@
+/**
+ * @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 BitmapText from '../display/bitmap_text';
+import Button from '../display/button';
+import Group from '../display/group';
+import Graphics from '../display/graphics';
+import Image from '../display/image';
+import SpriteBatch from '../display/sprite_batch';
+import Text from '../display/text';
+
+export default class {
+
+  constructor(game) {
+    this.game = game;
+  }
+
+  existing(object) {
+    return this.game.world.add(object);
+  }
+
+  image(x, y, key, frame, group = null) {
+    if (!group) {
+      group = this.game.world;
+    }
+    return group.add(new Image(this.game, x, y, key, frame));
+  }
+
+  group(parent, name, addToStage) {
+    return new Group(this.game, parent, name, addToStage);
+  }
+
+  spriteBatch(parent = null, name = 'group', addToStage = false) {
+    return new SpriteBatch(this.game, parent, name, addToStage);
+  }
+
+  audio(key, volume, loop, connect) {
+    console.warn('[GameObjectFactory] game.add.audio() is deprecated, use game.sound.add() directly.');
+    return this.game.sound.add(key, volume, loop, connect);
+  }
+
+  sound(key, volume, loop, connect) {
+    console.warn('[GameObjectFactory] game.add.sound() is deprecated, use game.sound.add() directly.');
+    return this.game.sound.add(key, volume, loop, connect);
+  }
+
+  text(x, y, text, style, group = null) {
+    const parent = group || this.game.world;
+    return parent.add(new Text(this.game, x, y, text, style));
+  }
+
+  button(x, y, key, callback, callbackContext, overFrame, outFrame, downFrame, upFrame, group = null) {
+    const parent = group || this.game.world;
+    return parent.add(new Button(this.game, x, y, key, callback, callbackContext, overFrame, outFrame, downFrame, upFrame));
+  }
+
+  graphics(x, y, group = null) {
+    const parent = group || this.game.world;
+    return parent.add(new Graphics(this.game, x, y));
+  }
+
+  bitmapText(x, y, font, text, size, group = null) {
+    const parent = group || this.game.world;
+    return parent.add(new BitmapText(this.game, x, y, font, text, size));
+  }
+
+  tween(object) {
+    console.warn('game.add.tween(target) is deprecated, please use game.tweens.create(target) directly.');
+    return this.game.tweens.create(object);
+  }
+
+}

package/src/phaser/core/frame.js

@@ -0,0 +1,75 @@
+/**
+ * @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 Rectangle from '../geom/rectangle';
+import { distance } from '../util/math';
+import { cloneFrame } from './frame_util';
+
+export default class {
+
+  constructor(index, x, y, width, height, name) {
+    this.initialize(index, x, y, width, height, name);
+  }
+
+  initialize(index, x, y, width, height, name) {
+    this.index = index;
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.name = name;
+    this.centerX = Math.floor(width / 2);
+    this.centerY = Math.floor(height / 2);
+    this.distance = distance(0, 0, width, height);
+    this.rotated = false;
+    this.rotationDirection = 'cw';
+    this.trimmed = false;
+    this.sourceSizeW = width;
+    this.sourceSizeH = height;
+    this.spriteSourceSizeX = 0;
+    this.spriteSourceSizeY = 0;
+    this.spriteSourceSizeW = 0;
+    this.spriteSourceSizeH = 0;
+    this.right = this.x + this.width;
+    this.bottom = this.y + this.height;
+  }
+
+  resize(width, height) {
+    this.width = width;
+    this.height = height;
+    this.centerX = Math.floor(width / 2);
+    this.centerY = Math.floor(height / 2);
+    this.distance = distance(0, 0, width, height);
+    this.sourceSizeW = width;
+    this.sourceSizeH = height;
+    this.right = this.x + width;
+    this.bottom = this.y + height;
+  }
+
+  setTrim(trimmed, actualWidth, actualHeight, destX, destY, destWidth, destHeight) {
+    this.trimmed = trimmed;
+    if (trimmed) {
+      this.sourceSizeW = actualWidth;
+      this.sourceSizeH = actualHeight;
+      this.centerX = Math.floor(actualWidth / 2);
+      this.centerY = Math.floor(actualHeight / 2);
+      this.spriteSourceSizeX = destX;
+      this.spriteSourceSizeY = destY;
+      this.spriteSourceSizeW = destWidth;
+      this.spriteSourceSizeH = destHeight;
+    }
+  }
+
+  clone() {
+    return cloneFrame(this);
+  }
+
+  getRect(output = null) {
+    const result = output || new Rectangle();
+    result.setTo(this.x, this.y, this.width, this.height);
+    return result;
+  }
+
+}

package/src/phaser/core/frame_data.js

@@ -0,0 +1,84 @@
+/**
+ * @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 { cloneFrameData } from './frame_util';
+
+export default class {
+
+  constructor() {
+    this._frames = [];
+    this._frameNames = [];
+  }
+
+  addFrame(frame) {
+    frame.index = this._frames.length;
+    this._frames.push(frame);
+    if (frame.name !== '') {
+      this._frameNames[frame.name] = frame.index;
+    }
+    return frame;
+  }
+
+  getFrame(index = 0) {
+    if (index >= this._frames.length) {
+      index = 0;
+    }
+    return this._frames[index];
+  }
+
+  getFrameByName(name) {
+    if (typeof this._frameNames[name] === 'number') {
+      return this._frames[this._frameNames[name]];
+    }
+    return null;
+  }
+
+  checkFrameName(name) {
+    if (this._frameNames[name] == null) {
+      return false;
+    }
+    return true;
+  }
+
+  clone() {
+    return cloneFrameData(this);
+  }
+
+  getFrameRange(start, end, output = null) {
+    const result = output || [];
+    for (let i = start; i <= end; i += 1) {
+      result.push(this._frames[i]);
+    }
+    return result;
+  }
+
+  getFrameIndexes(frames, useNumericIndex = true, output = null) {
+    const result = output || [];
+    if (frames && frames.length > 0) {
+      for (let i = 0; i < frames.length; i += 1) {
+        if (useNumericIndex && this._frames[frames[i]]) {
+          result.push(this._frames[frames[i]].index);
+        } else if (this.getFrameByName(frames[i])) {
+          result.push(this.getFrameByName(frames[i]).index);
+        }
+      }
+    } else {
+      for (let i = 0; i < this._frames.length; i += 1) {
+        result.push(this._frames[i].index);
+      }
+    }
+    return result;
+  }
+
+  destroy() {
+    this._frames = null;
+    this._frameNames = null;
+  }
+
+  get total() {
+    return this._frames.length;
+  }
+
+}

package/src/phaser/core/frame_util.js

@@ -0,0 +1,31 @@
+/**
+ * @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 Frame from './frame';
+import FrameData from './frame_data';
+
+/**
+ *
+ * @param frame
+ * @param output
+ */
+export function cloneFrame(frame, output = null) {
+  const result = output || new Frame();
+  result.initialize(frame.index, frame.x, frame.y, frame.width, frame.height);
+  return result;
+}
+
+/**
+ *
+ * @param frameData
+ * @param output
+ */
+export function cloneFrameData(frameData, output = null) {
+  const result = output || new FrameData();
+  for (let i = 0; i < frameData.total; i += 1) {
+    result.addFrame(frameData.getFrame(i).clone());
+  }
+  return result;
+}