@vpmedia/phaser 1.11.0 → 1.12.0

package/src/phaser/display/display_object.js

@@ -11,7 +11,6 @@ import { PI_2 } from '../util/math';
 import { renderCanvas, renderWebGL } from './sprite_util';
 
 export default class {
-
   constructor() {
     this.exists = true;
     this.renderable = false;
@@ -83,7 +82,13 @@ export default class {
       this.children.splice(index, 0, child);
       return child;
     }
-    throw new Error(child + 'addChildAt: The index ' + index + ' supplied is out of bounds ' + this.children.length);
+    throw new Error(
+      child +
+        'addChildAt: The index ' +
+        index +
+        ' supplied is out of bounds ' +
+        this.children.length
+    );
   }
 
   swapChildren(child, child2) {
@@ -93,7 +98,9 @@ export default class {
     const index1 = this.getChildIndex(child);
     const index2 = this.getChildIndex(child2);
     if (index1 < 0 || index2 < 0) {
-      throw new Error('swapChildren: Both the supplied DisplayObjects must be a child of the caller.');
+      throw new Error(
+        'swapChildren: Both the supplied DisplayObjects must be a child of the caller.'
+      );
     }
     this.children[index1] = child2;
     this.children[index2] = child;
@@ -118,7 +125,11 @@ export default class {
 
   getChildAt(index) {
     if (index < 0 || index >= this.children.length) {
-      throw new Error('getChildAt: Supplied index ' + index + ' does not exist in the child list, or the supplied DisplayObject must be a child of the caller');
+      throw new Error(
+        'getChildAt: Supplied index ' +
+          index +
+          ' does not exist in the child list, or the supplied DisplayObject must be a child of the caller'
+      );
     }
     return this.children[index];
   }
@@ -228,7 +239,10 @@ export default class {
     //  Set the World values
     this.worldAlpha = this.alpha * p.worldAlpha;
     // this.worldPosition.set(wt.tx, wt.ty);
-    this.worldScale.set(this.scale.x * Math.sqrt(wt.a * wt.a + wt.c * wt.c), this.scale.y * Math.sqrt(wt.b * wt.b + wt.d * wt.d));
+    this.worldScale.set(
+      this.scale.x * Math.sqrt(wt.a * wt.a + wt.c * wt.c),
+      this.scale.y * Math.sqrt(wt.b * wt.b + wt.d * wt.d)
+    );
     this.worldRotation = Math.atan2(-wt.c, wt.d);
     // reset the bounds each time this is called!
     this.currentBounds = null;
@@ -243,7 +257,8 @@ export default class {
   }
 
   getBounds(targetCoordinateSpace) {
-    const isTargetCoordinateSpaceDisplayObject = (targetCoordinateSpace && targetCoordinateSpace.contains !== undefined);
+    const isTargetCoordinateSpaceDisplayObject =
+      targetCoordinateSpace && targetCoordinateSpace.contains !== undefined;
     let isTargetCoordinateSpaceThisOrParent = true;
     if (!isTargetCoordinateSpaceDisplayObject) {
       targetCoordinateSpace = this;
@@ -274,12 +289,12 @@ export default class {
       if (child.visible) {
         childVisible = true;
         childBounds = this.children[i].getBounds();
-        minX = (minX < childBounds.x) ? minX : childBounds.x;
-        minY = (minY < childBounds.y) ? minY : childBounds.y;
+        minX = minX < childBounds.x ? minX : childBounds.x;
+        minY = minY < childBounds.y ? minY : childBounds.y;
         childMaxX = childBounds.width + childBounds.x;
         childMaxY = childBounds.height + childBounds.y;
-        maxX = (maxX > childMaxX) ? maxX : childMaxX;
-        maxY = (maxY > childMaxY) ? maxY : childMaxY;
+        maxX = maxX > childMaxX ? maxX : childMaxX;
+        maxY = maxY > childMaxY ? maxY : childMaxY;
       }
     }
     let bounds = this.cachedBounds;
@@ -542,19 +557,19 @@ export default class {
   }
 
   get centerX() {
-    return (this.x - this.offsetX) + (this.width * 0.5);
+    return this.x - this.offsetX + this.width * 0.5;
   }
 
   set centerX(value) {
-    this.x = (value + this.offsetX) - (this.width * 0.5);
+    this.x = value + this.offsetX - this.width * 0.5;
   }
 
   get centerY() {
-    return (this.y - this.offsetY) + (this.height * 0.5);
+    return this.y - this.offsetY + this.height * 0.5;
   }
 
   set centerY(value) {
-    this.y = (value + this.offsetY) - (this.height * 0.5);
+    this.y = value + this.offsetY - this.height * 0.5;
   }
 
   get left() {
@@ -566,11 +581,11 @@ export default class {
   }
 
   get right() {
-    return (this.x + this.width) - this.offsetX;
+    return this.x + this.width - this.offsetX;
   }
 
   set right(value) {
-    this.x = value - (this.width) + this.offsetX;
+    this.x = value - this.width + this.offsetX;
   }
 
   get top() {
@@ -582,11 +597,10 @@ export default class {
   }
 
   get bottom() {
-    return (this.y + this.height) - this.offsetY;
+    return this.y + this.height - this.offsetY;
   }
 
   set bottom(value) {
-    this.y = value - (this.height) + this.offsetY;
+    this.y = value - this.height + this.offsetY;
   }
-
 }

package/src/phaser/display/graphics.js

@@ -16,13 +16,23 @@ import CanvasBuffer from './canvas/buffer';
 import { textureFromCanvas } from './webgl/texture_util';
 import { renderGraphics as renderCanvasGraphics } from './canvas/graphics';
 import { renderGraphics as renderWebGLGraphics } from './webgl/graphics';
-import { renderCanvas as renderSpriteCanvas, renderWebGL as renderSpriteWebGL } from './sprite_util';
+import {
+  renderCanvas as renderSpriteCanvas,
+  renderWebGL as renderSpriteWebGL,
+} from './sprite_util';
 import { getEmptyRectangle } from '../geom/util/rectangle';
 import { getIdentityMatrix } from '../geom/util/matrix';
-import { BLEND_NORMAL, GRAPHICS, GEOM_POLYGON, GEOM_CIRCLE, GEOM_ELLIPSE, GEOM_RECTANGLE, GEOM_ROUNDED_RECTANGLE } from '../core/const';
+import {
+  BLEND_NORMAL,
+  GRAPHICS,
+  GEOM_POLYGON,
+  GEOM_CIRCLE,
+  GEOM_ELLIPSE,
+  GEOM_RECTANGLE,
+  GEOM_ROUNDED_RECTANGLE,
+} from '../core/const';
 
 export default class extends DisplayObject {
-
   constructor(game, x = 0, y = 0) {
     super();
     this.game = game;
@@ -33,7 +43,7 @@ export default class extends DisplayObject {
     this.lineWidth = 0;
     this.lineColor = 0;
     this.graphicsData = [];
-    this.tint = 0xFFFFFF;
+    this.tint = 0xffffff;
     this.blendMode = BLEND_NORMAL;
     this.currentPath = null;
     this._webGL = [];
@@ -55,7 +65,7 @@ export default class extends DisplayObject {
   lineStyle(lineWidth = 0, color = 0, alpha = 1) {
     this.lineWidth = lineWidth || 0;
     this.lineColor = color || 0;
-    this.lineAlpha = (alpha === undefined) ? 1 : alpha;
+    this.lineAlpha = alpha === undefined ? 1 : alpha;
     if (this.currentPath) {
       if (this.currentPath.shape.points.length) {
         // halfway through a line? start a new one!
@@ -105,9 +115,9 @@ export default class extends DisplayObject {
     let j = 0;
     for (let i = 1; i <= n; i += 1) {
       j = i / n;
-      xa = fromX + ((cpX - fromX) * j);
-      ya = fromY + ((cpY - fromY) * j);
-      points.push(xa + (((cpX + ((toX - cpX) * j)) - xa) * j), ya + (((cpY + ((toY - cpY) * j)) - ya) * j));
+      xa = fromX + (cpX - fromX) * j;
+      ya = fromY + (cpY - fromY) * j;
+      points.push(xa + (cpX + (toX - cpX) * j - xa) * j, ya + (cpY + (toY - cpY) * j - ya) * j);
     }
     this.dirty = true;
     this._boundsDirty = true;
@@ -134,12 +144,15 @@ export default class extends DisplayObject {
     let j = 0;
     for (let i = 1; i <= n; i += 1) {
       j = i / n;
-      dt = (1 - j);
+      dt = 1 - j;
       dt2 = dt * dt;
       dt3 = dt2 * dt;
       t2 = j * j;
       t3 = t2 * j;
-      points.push(dt3 * fromX + 3 * dt2 * j * cpX + 3 * dt * t2 * cpX2 + t3 * toX, dt3 * fromY + 3 * dt2 * j * cpY + 3 * dt * t2 * cpY2 + t3 * toY);
+      points.push(
+        dt3 * fromX + 3 * dt2 * j * cpX + 3 * dt * t2 * cpX2 + t3 * toX,
+        dt3 * fromY + 3 * dt2 * j * cpY + 3 * dt * t2 * cpY2 + t3 * toY
+      );
     }
     this.dirty = true;
     this._boundsDirty = true;
@@ -170,10 +183,10 @@ export default class extends DisplayObject {
       const dd = a1 * a1 + b1 * b1;
       const cc = a2 * a2 + b2 * b2;
       const tt = a1 * a2 + b1 * b2;
-      const k1 = radius * Math.sqrt(dd) / mm;
-      const k2 = radius * Math.sqrt(cc) / mm;
-      const j1 = k1 * tt / dd;
-      const j2 = k2 * tt / cc;
+      const k1 = (radius * Math.sqrt(dd)) / mm;
+      const k2 = (radius * Math.sqrt(cc)) / mm;
+      const j1 = (k1 * tt) / dd;
+      const j2 = (k2 * tt) / cc;
       const cx = k1 * b2 + k2 * b1;
       const cy = k1 * a2 + k2 * a1;
       const px = b1 * (k2 + j1);
@@ -199,7 +212,7 @@ export default class extends DisplayObject {
     } else if (anticlockwise && startAngle <= endAngle) {
       startAngle += Math.PI * 2;
     }
-    const sweep = anticlockwise ? (startAngle - endAngle) * -1 : (endAngle - startAngle);
+    const sweep = anticlockwise ? (startAngle - endAngle) * -1 : endAngle - startAngle;
     const segs = Math.ceil(Math.abs(sweep) / (Math.PI * 2)) * segments;
     //  Sweep check - moved here because we don't want to do the moveTo below if the arc fails
     if (sweep === 0) {
@@ -222,10 +235,13 @@ export default class extends DisplayObject {
     const remainder = (segMinus % 1) / segMinus;
     for (let i = 0; i <= segMinus; i += 1) {
       const real = i + remainder * i;
-      const angle = ((theta) + startAngle + (theta2 * real));
+      const angle = theta + startAngle + theta2 * real;
       const c = Math.cos(angle);
       const s = -Math.sin(angle);
-      points.push(((cTheta * c) + (sTheta * s)) * radius + cx, ((cTheta * -s) + (sTheta * c)) * radius + cy);
+      points.push(
+        (cTheta * c + sTheta * s) * radius + cx,
+        (cTheta * -s + sTheta * c) * radius + cy
+      );
     }
     this.dirty = true;
     this._boundsDirty = true;
@@ -235,7 +251,7 @@ export default class extends DisplayObject {
   beginFill(color = 0, alpha = 1) {
     this.filling = true;
     this.fillColor = color || 0;
-    this.fillAlpha = (alpha === undefined) ? 1 : alpha;
+    this.fillAlpha = alpha === undefined ? 1 : alpha;
     if (this.currentPath) {
       if (this.currentPath.shape.points.length <= 2) {
         this.currentPath.fill = this.filling;
@@ -336,7 +352,8 @@ export default class extends DisplayObject {
       // check blend mode
       if (this.blendMode !== renderSession.spriteBatch.currentBlendMode) {
         renderSession.spriteBatch.currentBlendMode = this.blendMode;
-        const blendModeWebGL = window.PhaserRegistry.blendModesWebGL[renderSession.spriteBatch.currentBlendMode];
+        const blendModeWebGL =
+          window.PhaserRegistry.blendModesWebGL[renderSession.spriteBatch.currentBlendMode];
         renderSession.spriteBatch.gl.blendFunc(blendModeWebGL[0], blendModeWebGL[1]);
       }
       // check if the webgl graphic needs to be updated
@@ -390,21 +407,22 @@ export default class extends DisplayObject {
       const transform = this.worldTransform;
       if (this.blendMode !== renderSession.currentBlendMode) {
         renderSession.currentBlendMode = this.blendMode;
-        context.globalCompositeOperation = window.PhaserRegistry.blendModesCanvas[renderSession.currentBlendMode];
+        context.globalCompositeOperation =
+          window.PhaserRegistry.blendModesCanvas[renderSession.currentBlendMode];
       }
       if (this._mask) {
         renderSession.maskManager.pushMask(this._mask, renderSession);
       }
       const resolution = renderSession.resolution;
-      const tx = (transform.tx * renderSession.resolution) + renderSession.shakeX;
-      const ty = (transform.ty * renderSession.resolution) + renderSession.shakeY;
+      const tx = transform.tx * renderSession.resolution + renderSession.shakeX;
+      const ty = transform.ty * renderSession.resolution + renderSession.shakeY;
       context.setTransform(
         transform.a * resolution,
         transform.b * resolution,
         transform.c * resolution,
         transform.d * resolution,
         tx,
-        ty,
+        ty
       );
       renderCanvasGraphics(this, context);
       // simple render children!
@@ -574,9 +592,9 @@ export default class extends DisplayObject {
     }
     const padding = this.boundsPadding;
     this._localBounds.x = minX - padding;
-    this._localBounds.width = (maxX - minX) + padding * 2;
+    this._localBounds.width = maxX - minX + padding * 2;
     this._localBounds.y = minY - padding;
-    this._localBounds.height = (maxY - minY) + padding * 2;
+    this._localBounds.height = maxY - minY + padding * 2;
   }
 
   generateCachedSprite() {
@@ -639,7 +657,15 @@ export default class extends DisplayObject {
       shape = shape.clone();
       shape.flatten();
     }
-    const data = new GraphicsData(this.lineWidth, this.lineColor, this.lineAlpha, this.fillColor, this.fillAlpha, this.filling, shape);
+    const data = new GraphicsData(
+      this.lineWidth,
+      this.lineColor,
+      this.lineAlpha,
+      this.fillColor,
+      this.fillAlpha,
+      this.filling,
+      shape
+    );
     this.graphicsData.push(data);
     if (data.type === GEOM_POLYGON) {
       data.shape.closed = this.filling;
@@ -719,5 +745,4 @@ export default class extends DisplayObject {
       }
     }
   }
-
 }

package/src/phaser/display/graphics_data.js

@@ -6,7 +6,6 @@
 import { clone } from './graphics_data_util';
 
 export default class {
-
   constructor(lineWidth, lineColor, lineAlpha, fillColor, fillAlpha, fill, shape) {
     this.lineWidth = lineWidth;
     this.lineColor = lineColor;
@@ -23,5 +22,4 @@ export default class {
   clone() {
     return clone(this);
   }
-
 }

package/src/phaser/display/graphics_data_util.js

@@ -11,5 +11,13 @@ import GraphicsData from './graphics_data';
  * @returns {object} TBD
  */
 export function clone(source) {
-  return new GraphicsData(source.lineWidth, source.lineColor, source.lineAlpha, source.fillColor, source.fillAlpha, source.fill, source.shape);
+  return new GraphicsData(
+    source.lineWidth,
+    source.lineColor,
+    source.lineAlpha,
+    source.fillColor,
+    source.fillAlpha,
+    source.fill,
+    source.shape
+  );
 }

package/src/phaser/display/group.js

@@ -12,7 +12,6 @@ export const SORT_ASCENDING = -1;
 export const SORT_DESCENDING = 1;
 
 export default class extends DisplayObject {
-
   constructor(game, parent = null, name = 'group', addToStage = false) {
     super();
     this.game = game;
@@ -219,9 +218,7 @@ export default class extends DisplayObject {
       if (destroy && removed) {
         removed.destroy(true, destroyTexture);
       }
-    }
-    while (this.children.length > 0);
+    } while (this.children.length > 0);
     this.cursor = null;
   }
-
 }

package/src/phaser/display/image.js

@@ -13,7 +13,6 @@ import { IMAGE, PENDING_ATLAS, BLEND_NORMAL, SCALE_NEAREST } from '../core/const
 import { setTexture, getBounds, getLocalBounds, renderCanvas, renderWebGL } from './sprite_util';
 
 export default class extends DisplayObject {
-
   constructor(game, x, y, key, frame) {
     super();
     this.game = game;
@@ -24,7 +23,7 @@ export default class extends DisplayObject {
     this.data = {};
     this._width = 0;
     this._height = 0;
-    this.tint = 0xFFFFFF;
+    this.tint = 0xffffff;
     this.cachedTint = -1;
     this.tintedTexture = null;
     this.blendMode = BLEND_NORMAL;
@@ -44,7 +43,7 @@ export default class extends DisplayObject {
     this.key = null;
     this.data = null;
     this.texture = null;
-    this.tint = 0xFFFFFF;
+    this.tint = 0xffffff;
     this.cachedTint = -1;
     this.tintedTexture = null;
     this.shader = null;
@@ -284,5 +283,4 @@ export default class extends DisplayObject {
   renderCanvas(renderSession, matrix = null) {
     renderCanvas(this, renderSession, matrix);
   }
-
 }

package/src/phaser/display/sprite_batch.js

@@ -6,10 +6,8 @@
 import DisplayObject from './display_object';
 
 export default class extends DisplayObject {
-
   constructor(game) {
     super();
     this.game = game;
   }
-
 }

package/src/phaser/display/sprite_util.js

@@ -183,7 +183,13 @@ export function renderWebGL(target, renderSession, matrix) {
  */
 export function renderCanvas(target, renderSession, matrix) {
   // If the sprite is not visible or the alpha is 0 then no need to render this element
-  if (!target.visible || target.alpha === 0 || !target.renderable || target.texture.crop.width <= 0 || target.texture.crop.height <= 0) {
+  if (
+    !target.visible ||
+    target.alpha === 0 ||
+    !target.renderable ||
+    target.texture.crop.width <= 0 ||
+    target.texture.crop.height <= 0
+  ) {
     return;
   }
   let wt = target.worldTransform;
@@ -193,7 +199,8 @@ export function renderCanvas(target, renderSession, matrix) {
   }
   if (target.blendMode !== renderSession.currentBlendMode) {
     renderSession.currentBlendMode = target.blendMode;
-    renderSession.context.globalCompositeOperation = window.PhaserRegistry.blendModesCanvas[renderSession.currentBlendMode];
+    renderSession.context.globalCompositeOperation =
+      window.PhaserRegistry.blendModesCanvas[renderSession.currentBlendMode];
   }
   if (target._mask) {
     renderSession.maskManager.pushMask(target._mask, renderSession);
@@ -204,15 +211,23 @@ export function renderCanvas(target, renderSession, matrix) {
     renderSession.context.globalAlpha = target.worldAlpha;
 
     //  If smoothingEnabled is supported and we need to change the smoothing property for this texture
-    if (renderSession.smoothProperty && renderSession.scaleMode !== target.texture.baseTexture.scaleMode) {
+    if (
+      renderSession.smoothProperty &&
+      renderSession.scaleMode !== target.texture.baseTexture.scaleMode
+    ) {
       renderSession.scaleMode = target.texture.baseTexture.scaleMode;
-      renderSession.context[renderSession.smoothProperty] = (renderSession.scaleMode === SCALE_LINEAR);
+      renderSession.context[renderSession.smoothProperty] =
+        renderSession.scaleMode === SCALE_LINEAR;
     }
     //  If the texture is trimmed we offset by the trim x/y, otherwise we use the frame dimensions
-    let dx = (target.texture.trim) ? target.texture.trim.x - target.anchor.x * target.texture.trim.width : target.anchor.x * -target.texture.frame.width;
-    let dy = (target.texture.trim) ? target.texture.trim.y - target.anchor.y * target.texture.trim.height : target.anchor.y * -target.texture.frame.height;
-    const tx = (wt.tx * renderSession.resolution) + renderSession.shakeX;
-    const ty = (wt.ty * renderSession.resolution) + renderSession.shakeY;
+    let dx = target.texture.trim
+      ? target.texture.trim.x - target.anchor.x * target.texture.trim.width
+      : target.anchor.x * -target.texture.frame.width;
+    let dy = target.texture.trim
+      ? target.texture.trim.y - target.anchor.y * target.texture.trim.height
+      : target.anchor.y * -target.texture.frame.height;
+    const tx = wt.tx * renderSession.resolution + renderSession.shakeX;
+    const ty = wt.ty * renderSession.resolution + renderSession.shakeY;
     //  Allow for pixel rounding
     if (renderSession.roundPixels) {
       renderSession.context.setTransform(wt.a, wt.b, wt.c, wt.d, tx | 0, ty | 0);
@@ -225,20 +240,40 @@ export function renderCanvas(target, renderSession, matrix) {
     let ch = target.texture.crop.height;
     dx /= resolution;
     dy /= resolution;
-    if (target.tint !== 0xFFFFFF) {
+    if (target.tint !== 0xffffff) {
       if (target.texture.requiresReTint || target.cachedTint !== target.tint) {
         target.tintedTexture = getTintedTexture(target, target.tint);
         target.cachedTint = target.tint;
         target.texture.requiresReTint = false;
       }
-      renderSession.context.drawImage(target.tintedTexture, 0, 0, cw, ch, dx, dy, cw / resolution, ch / resolution);
+      renderSession.context.drawImage(
+        target.tintedTexture,
+        0,
+        0,
+        cw,
+        ch,
+        dx,
+        dy,
+        cw / resolution,
+        ch / resolution
+      );
     } else {
       const cx = target.texture.crop.x;
       const cy = target.texture.crop.y;
       // https://github.com/photonstorm/phaser-ce/pull/61
       cw = Math.floor(cw);
       ch = Math.floor(ch);
-      renderSession.context.drawImage(target.texture.baseTexture.source, cx, cy, cw, ch, dx, dy, cw / resolution, ch / resolution);
+      renderSession.context.drawImage(
+        target.texture.baseTexture.source,
+        cx,
+        cy,
+        cw,
+        ch,
+        dx,
+        dy,
+        cw / resolution,
+        ch / resolution
+      );
     }
   }
   for (let i = 0; i < target.children.length; i += 1) {