@vpmedia/phaser 1.0.1 → 1.0.3

package/src/phaser/core/tween_manager.js

@@ -0,0 +1,185 @@
+/**
+ * @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 Tween from './tween';
+import {
+  LinearNone,
+  QuadraticIn, QuadraticOut, QuadraticInOut,
+  CubicIn, CubicOut, CubicInOut,
+  QuarticIn, QuarticOut, QuarticInOut,
+  QuinticIn, QuinticOut, QuinticInOut,
+  SinusoidalIn, SinusoidalOut, SinusoidalInOut,
+  ExponentialIn, ExponentialOut, ExponentialInOut,
+  CircularIn, CircularOut, CircularInOut,
+  ElasticIn, ElasticOut, ElasticInOut,
+  BackIn, BackOut, BackInOut,
+  BounceIn, BounceOut, BounceInOut,
+} from './tween_easing';
+import { GROUP } from './const';
+
+export default class {
+
+  constructor(game) {
+    this.game = game;
+    this.frameBased = false;
+    this._tweens = [];
+    this._add = [];
+    this.easeMap = {
+      Linear: LinearNone,
+      Quad: QuadraticOut,
+      Cubic: CubicOut,
+      Quart: QuarticOut,
+      Quint: QuinticOut,
+      Sine: SinusoidalOut,
+      Expo: ExponentialOut,
+      Circ: CircularOut,
+      Elastic: ElasticOut,
+      Back: BackOut,
+      Bounce: BounceOut,
+      'Quad.easeIn': QuadraticIn,
+      'Cubic.easeIn': CubicIn,
+      'Quart.easeIn': QuarticIn,
+      'Quint.easeIn': QuinticIn,
+      'Sine.easeIn': SinusoidalIn,
+      'Expo.easeIn': ExponentialIn,
+      'Circ.easeIn': CircularIn,
+      'Elastic.easeIn': ElasticIn,
+      'Back.easeIn': BackIn,
+      'Bounce.easeIn': BounceIn,
+      'Quad.easeOut': QuadraticOut,
+      'Cubic.easeOut': CubicOut,
+      'Quart.easeOut': QuarticOut,
+      'Quint.easeOut': QuinticOut,
+      'Sine.easeOut': SinusoidalOut,
+      'Expo.easeOut': ExponentialOut,
+      'Circ.easeOut': CircularOut,
+      'Elastic.easeOut': ElasticOut,
+      'Back.easeOut': BackOut,
+      'Bounce.easeOut': BounceOut,
+      'Quad.easeInOut': QuadraticInOut,
+      'Cubic.easeInOut': CubicInOut,
+      'Quart.easeInOut': QuarticInOut,
+      'Quint.easeInOut': QuinticInOut,
+      'Sine.easeInOut': SinusoidalInOut,
+      'Expo.easeInOut': ExponentialInOut,
+      'Circ.easeInOut': CircularInOut,
+      'Elastic.easeInOut': ElasticInOut,
+      'Back.easeInOut': BackInOut,
+      'Bounce.easeInOut': BounceInOut,
+    };
+
+    this.game.onPause.add(this._pauseAll, this);
+    this.game.onResume.add(this._resumeAll, this);
+  }
+
+  getAll() {
+    return this._tweens;
+  }
+
+  removeAll() {
+    for (let i = 0; i < this._tweens.length; i += 1) {
+      this._tweens[i].pendingDelete = true;
+    }
+    this._add = [];
+  }
+
+  removeFrom(obj, children) {
+    let i;
+    let len;
+    if (Array.isArray(obj)) {
+      for (i = 0, len = obj.length; i < len; i += 1) {
+        this.removeFrom(obj[i]);
+      }
+    } else if (obj.type === GROUP && children) {
+      for (i = 0, len = obj.children.length; i < len; i += 1) {
+        this.removeFrom(obj.children[i]);
+      }
+    } else {
+      for (i = 0, len = this._tweens.length; i < len; i += 1) {
+        if (obj === this._tweens[i].target) {
+          this.remove(this._tweens[i]);
+        }
+      }
+      for (i = 0, len = this._add.length; i < len; i += 1) {
+        if (obj === this._add[i].target) {
+          this.remove(this._add[i]);
+        }
+      }
+    }
+  }
+
+  add(tween) {
+    tween._manager = this;
+    this._add.push(tween);
+  }
+
+  create(object) {
+    return new Tween(object, this.game, this);
+  }
+
+  remove(tween) {
+    let i = this._tweens.indexOf(tween);
+    if (i !== -1) {
+      this._tweens[i].pendingDelete = true;
+    } else {
+      i = this._add.indexOf(tween);
+      if (i !== -1) {
+        this._add[i].pendingDelete = true;
+      }
+    }
+  }
+
+  update() {
+    const addTweens = this._add.length;
+    let numTweens = this._tweens.length;
+    if (numTweens === 0 && addTweens === 0) {
+      return false;
+    }
+    let i = 0;
+    while (i < numTweens) {
+      if (this._tweens[i].update(this.game.time.time)) {
+        i += 1;
+      } else {
+        this._tweens.splice(i, 1);
+        numTweens -= 1;
+      }
+    }
+    //  If there are any new tweens to be added, do so now - otherwise they can be spliced out of the array before ever running
+    if (addTweens > 0) {
+      this._tweens = this._tweens.concat(this._add);
+      this._add.length = 0;
+    }
+    return true;
+  }
+
+  isTweening(object) {
+    return this._tweens.some(tween => tween.target === object);
+  }
+
+  _pauseAll() {
+    for (let i = this._tweens.length - 1; i >= 0; i -= 1) {
+      this._tweens[i]._pause();
+    }
+  }
+
+  _resumeAll() {
+    for (let i = this._tweens.length - 1; i >= 0; i -= 1) {
+      this._tweens[i]._resume();
+    }
+  }
+
+  pauseAll() {
+    for (let i = this._tweens.length - 1; i >= 0; i -= 1) {
+      this._tweens[i].pause();
+    }
+  }
+
+  resumeAll() {
+    for (let i = this._tweens.length - 1; i >= 0; i -= 1) {
+      this._tweens[i].resume(true);
+    }
+  }
+
+}

package/src/phaser/core/world.js

@@ -0,0 +1,18 @@
+/**
+ * @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 Group from '../display/group';
+
+export default class extends Group {
+
+  constructor(game) {
+    super(game, null, '__world', false);
+  }
+
+  boot() {
+    this.game.stage.addChild(this);
+  }
+
+}

package/src/phaser/display/bitmap_text.js

@@ -0,0 +1,322 @@
+/**
+ * @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 DisplayObject from './display_object';
+import Image from './image';
+import Point from '../geom/point';
+import { BITMAP_TEXT } from '../core/const';
+
+export default class extends DisplayObject {
+
+  constructor(game, x = 0, y = 0, font = '', text = '', size = 32, align = 'left') {
+    super();
+    this.game = game;
+    this.type = BITMAP_TEXT;
+    this.position.set(x, y);
+    this.textWidth = 0;
+    this.textHeight = 0;
+    this._prevAnchor = new Point();
+    this._glyphs = [];
+    this._maxWidth = 0;
+    this._text = text.toString() || '';
+    this._data = game.cache.getBitmapFont(font);
+    this._font = font;
+    this._fontSize = size;
+    this._align = align;
+    this._tint = 0xFFFFFF;
+    this.updateText();
+    this.dirty = false;
+  }
+
+  destroy() {
+    this._prevAnchor = null;
+    this._glyphs = null;
+    this._text = null;
+    this._data = null;
+    super.destroy();
+  }
+
+  preUpdate() {
+    if (this.pendingDestroy) {
+      this.destroy();
+      return;
+    }
+
+    if (!this.exists || !this.parent.exists) {
+      this.renderOrderID = -1;
+      return;
+    }
+    if (this.visible) {
+      this.game.stage.currentRenderOrderID += 1;
+      this.renderOrderID = this.game.stage.currentRenderOrderID;
+    }
+    for (let i = 0; i < this.children.length; i += 1) {
+      this.children[i].preUpdate();
+    }
+  }
+
+  setText(text) {
+    this.text = text;
+  }
+
+  scanLine(data, scale, text) {
+    let x = 0;
+    let w = 0;
+    let lastSpace = -1;
+    let wrappedWidth = 0;
+    let prevCharCode = null;
+    const maxWidth = (this._maxWidth > 0) ? this._maxWidth : null;
+    const chars = [];
+    //  Let's scan the text and work out if any of the lines are > maxWidth
+    let end = true;
+    for (let i = 0; i < text.length; i += 1) {
+      end = i === text.length - 1;
+      if (/(?:\r\n|\r|\n)/.test(text.charAt(i))) {
+        return {
+          width: w,
+          text: text.substr(0, i),
+          end,
+          chars,
+        };
+      }
+      let charCode = text.charCodeAt(i);
+      let charData = data.chars[charCode];
+      let c = 0;
+      //  If the character data isn't found in the data array
+      //  then we replace it with a blank space
+      if (charData === undefined) {
+        charCode = 32;
+        charData = data.chars[charCode];
+      }
+      //  Adjust for kerning from previous character to this one
+      const kerning = (prevCharCode && charData.kerning[prevCharCode]) ? charData.kerning[prevCharCode] : 0;
+      //  Record the last space in the string and the current width
+      if (/(\s)/.test(text.charAt(i))) {
+        lastSpace = i;
+        wrappedWidth = w;
+      }
+      //  What will the line width be if we add this character to it?
+      c = (kerning + charData.texture.width + charData.xOffset) * scale;
+      //  Do we need to line-wrap?
+      if (maxWidth && ((w + c) >= maxWidth) && lastSpace > -1) {
+        //  The last space was at "lastSpace" which was "i - lastSpace" characters ago
+        return {
+          width: wrappedWidth || w,
+          text: text.substr(0, i - (i - lastSpace)),
+          end,
+          chars,
+        };
+      }
+      w += (charData.xAdvance + kerning) * scale;
+      chars.push(x + (charData.xOffset + kerning) * scale);
+      x += (charData.xAdvance + kerning) * scale;
+      prevCharCode = charCode;
+    }
+    return {
+      width: w,
+      text,
+      end,
+      chars,
+    };
+  }
+
+  cleanText(text, replace = '') {
+    const data = this._data.font;
+    if (!data) {
+      return '';
+    }
+    const re = /\r\n|\n\r|\n|\r/g;
+    const lines = text.replace(re, '\n').split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+      let output = '';
+      const line = lines[i];
+      for (let c = 0; c < line.length; c += 1) {
+        if (data.chars[line.charCodeAt(c)]) {
+          output = output.concat(line[c]);
+        } else {
+          output = output.concat(replace);
+        }
+      }
+      lines[i] = output;
+    }
+    return lines.join('\n');
+  }
+
+  updateText() {
+    const data = this._data.font;
+    if (!data) {
+      return;
+    }
+    let text = this.text;
+    const scale = this._fontSize / data.size;
+    const lines = [];
+    let y = 0;
+    this.textWidth = 0;
+    let line = { end: text.length === 0 };
+    do {
+      line = this.scanLine(data, scale, text);
+      line.y = y;
+      lines.push(line);
+      if (line.width > this.textWidth) {
+        this.textWidth = line.width;
+      }
+      y += (data.lineHeight * scale);
+      text = text.substr(line.text.length + 1);
+    } while (line.end === false);
+    this.textHeight = y;
+    let t = 0;
+    let align = 0;
+    const ax = this.textWidth * this.anchor.x;
+    const ay = this.textHeight * this.anchor.y;
+    for (let i = 0; i < lines.length; i += 1) {
+      const currentLine = lines[i];
+      if (this._align === 'right') {
+        align = this.textWidth - currentLine.width;
+      } else if (this._align === 'center') {
+        align = (this.textWidth - currentLine.width) / 2;
+      }
+      for (let c = 0; c < currentLine.text.length; c += 1) {
+        let charCode = currentLine.text.charCodeAt(c);
+        let charData = data.chars[charCode];
+        if (charData === undefined) {
+          charCode = 32;
+          charData = data.chars[charCode];
+        }
+        let g = this._glyphs[t];
+        if (g) {
+          // Sprite already exists in the glyphs pool, so we'll reuse it for this letter
+          g.texture = charData.texture;
+        } else {
+          // We need a new sprite as the pool is empty or exhausted
+          g = new Image(this.game, 0, 0, charData.texture);
+          g.name = currentLine.text[c];
+          this._glyphs.push(g);
+        }
+        g.position.x = (currentLine.chars[c] + align) - ax;
+        g.position.y = (currentLine.y + (charData.yOffset * scale)) - ay;
+        g.scale.set(scale);
+        g.tint = this.tint;
+        g.texture.requiresReTint = true;
+        if (!g.parent) {
+          this.addChild(g);
+        }
+        t += 1;
+      }
+    }
+    //  Remove unnecessary children
+    //  This moves them from the display list (children array) but retains them in the _glyphs pool
+    for (let i = t; i < this._glyphs.length; i += 1) {
+      this.removeChild(this._glyphs[i]);
+    }
+  }
+
+  purgeGlyphs() {
+    const len = this._glyphs.length;
+    const kept = [];
+    for (let i = 0; i < this._glyphs.length; i += 1) {
+      if (this._glyphs[i].parent !== this) {
+        this._glyphs[i].destroy();
+      } else {
+        kept.push(this._glyphs[i]);
+      }
+    }
+    this._glyphs = [];
+    this._glyphs = kept;
+    this.updateText();
+    return len - kept.length;
+  }
+
+  updateTransform() {
+    if (this.dirty || !this.anchor.equals(this._prevAnchor)) {
+      this.updateText();
+      this.dirty = false;
+      this._prevAnchor.copyFrom(this.anchor);
+    }
+    super.updateTransform();
+  }
+
+  get align() {
+    return this._align;
+  }
+
+  set align(value) {
+    if (value !== this._align && (value === 'left' || value === 'center' || value === 'right')) {
+      this._align = value;
+      this.updateText();
+    }
+  }
+
+  get tint() {
+    return this._tint;
+  }
+
+  set tint(value) {
+    if (value !== this._tint) {
+      this._tint = value;
+      this.updateText();
+    }
+  }
+
+  get font() {
+    return this._font;
+  }
+
+  set font(value) {
+    const trimmedValue = value.trim();
+    if (trimmedValue !== this._font) {
+      this._font = trimmedValue;
+      this._data = this.game.cache.getBitmapFont(this._font);
+      this.updateText();
+    }
+  }
+
+  get fontSize() {
+    return this._fontSize;
+  }
+
+  set fontSize(value) {
+    value = parseInt(value, 10);
+    if (value !== this._fontSize && value > 0) {
+      this._fontSize = value;
+      this.updateText();
+    }
+  }
+
+  get text() {
+    return this._text;
+  }
+
+  set text(value) {
+    const typedValue = value.toString();
+    if (typedValue !== this._text) {
+      this._text = typedValue || '';
+      this.updateText();
+    }
+  }
+
+  get maxWidth() {
+    return this._maxWidth;
+  }
+
+  set maxWidth(value) {
+    if (value !== this._maxWidth) {
+      this._maxWidth = value;
+      this.updateText();
+    }
+  }
+
+  get smoothed() {
+    return !this._data.base.scaleMode;
+  }
+
+  set smoothed(value) {
+    if (value) {
+      this._data.base.scaleMode = 0;
+    } else {
+      this._data.base.scaleMode = 1;
+    }
+  }
+
+}

package/src/phaser/display/button.js

@@ -0,0 +1,194 @@
+/**
+ * @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 Image from './image';
+import Signal from '../core/signal';
+import InputHandler from '../core/input_handler';
+import { BUTTON, POINTER_CONTACT } from '../core/const';
+
+const STATE_OVER = 'Over';
+const STATE_OUT = 'Out';
+const STATE_DOWN = 'Down';
+const STATE_UP = 'Up';
+const STATE_DISABLED = 'Disabled';
+
+export default class extends Image {
+
+  constructor(game, x = 0, y = 0, key = null, callback = null, callbackContext = null, overFrame = null, outFrame = null, downFrame = null, upFrame = null) {
+    super(game, x, y, key, outFrame);
+    this.type = BUTTON;
+    this._onOverFrame = null;
+    this._onOutFrame = null;
+    this._onDownFrame = null;
+    this._onUpFrame = null;
+    this._onDisabledFrame = null;
+    this.onInputOver = new Signal();
+    this.onInputOut = new Signal();
+    this.onInputDown = new Signal();
+    this.onInputUp = new Signal();
+    this.onOverMouseOnly = true;
+    this.justReleasedPreventsOver = POINTER_CONTACT;
+    this.freezeFrames = false;
+    this.forceOut = false;
+    this.input = new InputHandler(this);
+    this.input.start(0, true);
+    this.input.useHandCursor = true;
+    this.setFrames(overFrame, outFrame, downFrame, upFrame);
+    if (callback !== null) {
+      this.onInputUp.add(callback, callbackContext);
+    }
+    //  Redirect the input events to here so we can handle animation updates, etc
+    this.events.onInputOver.add(this.onInputOverHandler, this);
+    this.events.onInputOut.add(this.onInputOutHandler, this);
+    this.events.onInputDown.add(this.onInputDownHandler, this);
+    this.events.onInputUp.add(this.onInputUpHandler, this);
+  }
+
+  destroy() {
+    this._onOverFrame = null;
+    this._onOutFrame = null;
+    this._onDownFrame = null;
+    this._onUpFrame = null;
+    this._onDisabledFrame = null;
+    if (this.onInputOver) {
+      this.onInputOver.dispose();
+      this.onInputOut.dispose();
+      this.onInputDown.dispose();
+      this.onInputUp.dispose();
+    }
+    this.onInputOver = null;
+    this.onInputOut = null;
+    this.onInputDown = null;
+    this.onInputUp = null;
+    if (this.input) {
+      this.input.destroy();
+    }
+    this.input = null;
+    super.destroy();
+  }
+
+  setEnabled(isEnabled, isImmediate) {
+    this.input.enabled = isEnabled;
+    if (isImmediate) {
+      this.changeStateFrame(isEnabled ? STATE_UP : STATE_DISABLED);
+    } else {
+      setTimeout(() => {
+        this.changeStateFrame(isEnabled ? STATE_UP : STATE_DISABLED);
+      }, 1);
+    }
+  }
+
+  clearFrames() {
+    this.setFrames(null, null, null, null);
+  }
+
+  removedFromWorld() {
+    this.inputEnabled = false;
+  }
+
+  setStateFrame(state, frame, switchImmediately = false) {
+    const frameKey = '_on' + state + 'Frame';
+    if (frame) {
+      this[frameKey] = frame;
+      if (switchImmediately) {
+        this.changeStateFrame(state);
+      }
+    } else {
+      this[frameKey] = null;
+    }
+  }
+
+  changeStateFrame(newState) {
+    if (this.freezeFrames) {
+      return false;
+    }
+    const state = this.input.enabled || !this._onDisabledFrame ? newState : STATE_DISABLED;
+    const frameKey = '_on' + state + 'Frame';
+    const frame = this[frameKey];
+    if (typeof frame === 'string') {
+      this.frameName = frame;
+      return true;
+    } else if (typeof frame === 'number') {
+      this.frame = frame;
+      return true;
+    }
+    return false;
+  }
+
+  setFrames(overFrame, outFrame, downFrame, upFrame) {
+    this.setStateFrame(STATE_OVER, overFrame, this.input.pointerOver());
+    this.setStateFrame(STATE_OUT, outFrame, !this.input.pointerOver());
+    this.setStateFrame(STATE_DOWN, downFrame, this.input.pointerDown());
+    this.setStateFrame(STATE_UP, upFrame, this.input.pointerUp());
+  }
+
+  onInputOverHandler(sprite, pointer) {
+    if (pointer.justReleased() && (this.justReleasedPreventsOver & pointer.pointerMode) === pointer.pointerMode) {
+      //  If the Pointer was only just released then we don't fire an over event
+      return;
+    }
+    this.changeStateFrame(STATE_OVER);
+    if (this.onOverMouseOnly && !pointer.isMouse) {
+      return;
+    }
+    if (this.onInputOver) {
+      this.onInputOver.dispatch(this, pointer);
+    }
+  }
+
+  onInputOutHandler(sprite, pointer) {
+    this.changeStateFrame(STATE_OUT);
+    if (this.onInputOut) {
+      this.onInputOut.dispatch(this, pointer);
+    }
+  }
+
+  onInputDownHandler(sprite, pointer) {
+    this.changeStateFrame(STATE_DOWN);
+    if (this.onInputDown) {
+      this.onInputDown.dispatch(this, pointer);
+    }
+  }
+
+  onInputUpHandler(sprite, pointer, isOver) {
+    if (this.onInputUp) {
+      this.onInputUp.dispatch(this, pointer, isOver);
+    }
+    if (this.freezeFrames) {
+      return;
+    }
+    if (this.forceOut === true || (this.forceOut & pointer.pointerMode) === pointer.pointerMode) {
+      this.changeStateFrame(STATE_OUT);
+    } else {
+      const changedUp = this.changeStateFrame(STATE_UP);
+      if (!changedUp) {
+        //  No Up frame to show..
+        if (isOver) {
+          this.changeStateFrame(STATE_OVER);
+        } else {
+          this.changeStateFrame(STATE_OUT);
+        }
+      }
+    }
+  }
+
+  get inputEnabled() {
+    return this.input && this.input.enabled;
+  }
+
+  set inputEnabled(value) {
+    if (value) {
+      if (this.input === null) {
+        this.input = new InputHandler(this);
+        this.input.start();
+      } else if (this.input && !this.input.enabled) {
+        this.input.start();
+      }
+    } else if (this.input && this.input.enabled) {
+      this.input.stop();
+    }
+  }
+
+}