@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/core/animation_manager.js

@@ -0,0 +1,238 @@
+/**
+ * @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 Animation from './animation';
+
+export default class {
+
+  constructor(sprite) {
+    this.sprite = sprite;
+    this.game = sprite.game;
+    this.currentFrame = null;
+    this.currentAnim = null;
+    this.updateIfVisible = true;
+    this.isLoaded = false;
+    this._frameData = null;
+    this._anims = {};
+    this._outputFrames = [];
+  }
+
+  destroy() {
+    const keys = Object.keys(this._anims);
+    for (let i = 0; i < keys.length; i += 1) {
+      this._anims[keys[i]].destroy();
+    }
+    this._anims = {};
+    this._outputFrames = [];
+    this._frameData = null;
+    this.currentAnim = null;
+    this.currentFrame = null;
+    this.sprite = null;
+    this.game = null;
+  }
+
+  loadFrameData(frameData, frame) {
+    if (!frameData) {
+      return false;
+    }
+    if (this.isLoaded) {
+      // We need to update the frameData that the animations are using
+      const keys = Object.keys(this._anims);
+      for (let i = 0; i < keys.length; i += 1) {
+        const anim = keys[i];
+        this._anims[anim].updateFrameData(frameData);
+      }
+    }
+    this._frameData = frameData;
+    if (frame === undefined || frame === null) {
+      this.frame = 0;
+    } else if (typeof frame === 'string') {
+      this.frameName = frame;
+    } else {
+      this.frame = frame;
+    }
+    this.isLoaded = true;
+    return true;
+  }
+
+  copyFrameData(frameData, frame) {
+    this._frameData = frameData.clone();
+    if (this.isLoaded) {
+      // We need to update the frameData that the animations are using
+      const keys = Object.keys(this._anims);
+      for (let i = 0; i < keys.length; i += 1) {
+        const anim = keys[i];
+        this._anims[anim].updateFrameData(this._frameData);
+      }
+    }
+    if (frame === undefined || frame === null) {
+      this.frame = 0;
+    } else if (typeof frame === 'string') {
+      this.frameName = frame;
+    } else {
+      this.frame = frame;
+    }
+    this.isLoaded = true;
+    return true;
+  }
+
+  add(name, frameList, frameRate = 60, loop = false, useNumericIndex = undefined) {
+    const frames = frameList || [];
+    //  If they didn't set the useNumericIndex then let's at least try and guess it
+    if (useNumericIndex === undefined) {
+      if (frames && typeof frames[0] === 'number') {
+        useNumericIndex = true;
+      } else {
+        useNumericIndex = false;
+      }
+    }
+    this._outputFrames = [];
+    this._frameData.getFrameIndexes(frames, useNumericIndex, this._outputFrames);
+    this._anims[name] = new Animation(this.game, this.sprite, name, this._frameData, this._outputFrames, frameRate, loop);
+    this.currentAnim = this._anims[name];
+    if (this.sprite.tilingTexture) {
+      this.sprite.refreshTexture = true;
+    }
+    return this._anims[name];
+  }
+
+  validateFrames(frames, useNumericIndex = false) {
+    for (let i = 0; i < frames.length; i += 1) {
+      if (useNumericIndex === true) {
+        if (frames[i] > this._frameData.total) {
+          return false;
+        }
+      } else if (this._frameData.checkFrameName(frames[i]) === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  play(name, frameRate, loop, killOnComplete) {
+    if (this._anims[name]) {
+      if (this.currentAnim === this._anims[name]) {
+        if (this.currentAnim.isPlaying === false) {
+          this.currentAnim.paused = false;
+          return this.currentAnim.play(frameRate, loop, killOnComplete);
+        }
+        return this.currentAnim;
+      }
+      if (this.currentAnim && this.currentAnim.isPlaying) {
+        this.currentAnim.stop();
+      }
+      this.currentAnim = this._anims[name];
+      this.currentAnim.paused = false;
+      this.currentFrame = this.currentAnim.currentFrame;
+      return this.currentAnim.play(frameRate, loop, killOnComplete);
+    }
+    return null;
+  }
+
+  stop(name, resetFrame = false) {
+    if (this.currentAnim && (typeof name !== 'string' || name === this.currentAnim.name)) {
+      this.currentAnim.stop(resetFrame);
+    }
+  }
+
+  update() {
+    if (this.updateIfVisible && !this.sprite.visible) {
+      return false;
+    }
+    if (this.currentAnim && this.currentAnim.update()) {
+      this.currentFrame = this.currentAnim.currentFrame;
+      return true;
+    }
+    return false;
+  }
+
+  next(quantity) {
+    if (this.currentAnim) {
+      this.currentAnim.next(quantity);
+      this.currentFrame = this.currentAnim.currentFrame;
+    }
+  }
+
+  previous(quantity) {
+    if (this.currentAnim) {
+      this.currentAnim.previous(quantity);
+      this.currentFrame = this.currentAnim.currentFrame;
+    }
+  }
+
+  getAnimation(name) {
+    if (name && this._anims[name]) {
+      return this._anims[name];
+    }
+    return null;
+  }
+
+  refreshFrame() {
+    // TODO
+    console.warn('animation_manager.refreshFrame() is not implemented');
+    // this.sprite.setTexture(PIXI.TextureCache[this.currentFrame.uuid]);
+  }
+
+  get frameData() {
+    return this._frameData;
+  }
+
+  get frameTotal() {
+    return this._frameData.total;
+  }
+
+  get paused() {
+    return this.currentAnim.isPaused;
+  }
+
+  set paused(value) {
+    this.currentAnim.paused = value;
+  }
+
+  get name() {
+    if (this.currentAnim) {
+      return this.currentAnim.name;
+    }
+    return null;
+  }
+
+  get frame() {
+    if (this.currentFrame) {
+      return this.currentFrame.index;
+    }
+    return 0;
+  }
+
+  set frame(value) {
+    if (typeof value === 'number' && this._frameData && this._frameData.getFrame(value) !== null) {
+      this.currentFrame = this._frameData.getFrame(value);
+      if (this.currentFrame) {
+        this.sprite.setFrame(this.currentFrame);
+      }
+    } else {
+      console.warn('Cannot set frame: ' + value);
+    }
+  }
+
+  get frameName() {
+    if (this.currentFrame) {
+      return this.currentFrame.name;
+    }
+    return null;
+  }
+
+  set frameName(value) {
+    if (typeof value === 'string' && this._frameData && this._frameData.getFrameByName(value) !== null) {
+      this.currentFrame = this._frameData.getFrameByName(value);
+      if (this.currentFrame) {
+        this._frameIndex = this.currentFrame.index;
+        this.sprite.setFrame(this.currentFrame);
+      }
+    } else {
+      console.warn('Cannot set frameName: ' + value);
+    }
+  }
+
+}

package/src/phaser/core/animation_parser.js

@@ -0,0 +1,130 @@
+/**
+ * @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 game
+ * @param key
+ * @param frameWidth
+ * @param frameHeight
+ * @param frameMax
+ * @param margin
+ * @param spacing
+ */
+export function spriteSheet(game, key, frameWidth, frameHeight, frameMax, margin, spacing) {
+  let img = key;
+  if (typeof key === 'string') {
+    img = game.cache.getImage(key);
+  }
+  if (img === null) {
+    return null;
+  }
+  const width = img.width;
+  const height = img.height;
+  if (frameWidth <= 0) {
+    frameWidth = Math.floor(-width / Math.min(-1, frameWidth));
+  }
+  if (frameHeight <= 0) {
+    frameHeight = Math.floor(-height / Math.min(-1, frameHeight));
+  }
+  const row = Math.floor((width - margin) / (frameWidth + spacing));
+  const column = Math.floor((height - margin) / (frameHeight + spacing));
+  let total = row * column;
+  if (frameMax !== -1) {
+    total = frameMax;
+  }
+  //  Zero or smaller than frame sizes?
+  if (width === 0 || height === 0 || width < frameWidth || height < frameHeight || total === 0) {
+    console.warn("AnimationParser.spriteSheet: '" + key + "'s width/height zero or width/height < given frameWidth/frameHeight");
+    return null;
+  }
+  //  Let's create some frames then
+  const data = new FrameData();
+  let x = margin;
+  let y = margin;
+  for (let i = 0; i < total; i += 1) {
+    data.addFrame(new Frame(i, x, y, frameWidth, frameHeight, ''));
+    x += frameWidth + spacing;
+    if (x + frameWidth > width) {
+      x = margin;
+      y += frameHeight + spacing;
+    }
+  }
+  return data;
+}
+
+/**
+ *
+ * @param game
+ * @param json
+ */
+export function JSONData(game, json) {
+  //  Malformed?
+  if (!json.frames) {
+    console.warn('AnimationParser.JSONData: Invalid Texture Atlas JSON given, missing frames array');
+    console.log(json);
+    return null;
+  }
+  //  Let's create some frames then
+  const data = new FrameData();
+  //  By this stage frames is a fully parsed array
+  const frames = json.frames;
+  let newFrame;
+  for (let i = 0; i < frames.length; i += 1) {
+    newFrame = data.addFrame(new Frame(i, frames[i].frame.x, frames[i].frame.y, frames[i].frame.w, frames[i].frame.h, frames[i].filename));
+    if (frames[i].trimmed) {
+      newFrame.setTrim(frames[i].trimmed, frames[i].sourceSize.w, frames[i].sourceSize.h, frames[i].spriteSourceSize.x, frames[i].spriteSourceSize.y, frames[i].spriteSourceSize.w, frames[i].spriteSourceSize.h);
+    }
+  }
+  return data;
+
+}
+
+/**
+ *
+ */
+export function JSONDataPyxel() {
+  // TODO
+  console.warn('animation_parser.JSONDataPyxel() is not implemented');
+}
+
+/**
+ *
+ * @param game
+ * @param json
+ */
+export function JSONDataHash(game, json) {
+  if (!json.frames) {
+    console.warn('JSONDataHash: Invalid Texture Atlas JSON given, missing frames object', json);
+    return null;
+  }
+  // Let's create some frames then
+  const data = new FrameData();
+  // By this stage frames is a fully parsed array
+  const frames = json.frames;
+  let newFrame;
+  let i = 0;
+  const keys = Object.keys(frames);
+  for (let k = 0; k < keys.length; k += 1) {
+    const key = keys[k];
+    newFrame = data.addFrame(new Frame(i, frames[key].frame.x, frames[key].frame.y, frames[key].frame.w, frames[key].frame.h, key));
+    if (frames[key].trimmed) {
+      newFrame.setTrim(frames[key].trimmed, frames[key].sourceSize.w, frames[key].sourceSize.h, frames[key].spriteSourceSize.x, frames[key].spriteSourceSize.y, frames[key].spriteSourceSize.w, frames[key].spriteSourceSize.h);
+    }
+    i += 1;
+  }
+  return data;
+}
+
+/**
+ *
+ */
+export function XMLData() {
+  // TODO
+  console.warn('animation_parser.XMLData() is not implemented');
+}

package/src/phaser/core/array_set.js

@@ -0,0 +1,108 @@
+/**
+ * @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)
+ */
+/* eslint-disable prefer-spread */
+export default class {
+
+  constructor(list = []) {
+    this.position = 0;
+    this.list = list;
+  }
+
+  add(item) {
+    if (!this.exists(item)) {
+      this.list.push(item);
+    }
+    return item;
+  }
+
+  getIndex(item) {
+    return this.list.indexOf(item);
+  }
+
+  getByKey(property, value) {
+    let i = this.list.length;
+    while (i) {
+      i -= 1;
+      if (this.list[i][property] === value) {
+        return this.list[i];
+      }
+    }
+    return null;
+  }
+
+  exists(item) {
+    return (this.list.indexOf(item) > -1);
+  }
+
+  reset() {
+    this.list.length = 0;
+  }
+
+  remove(item) {
+    const idx = this.list.indexOf(item);
+    if (idx > -1) {
+      this.list.splice(idx, 1);
+      return item;
+    }
+    return null;
+  }
+
+  setAll(key, value) {
+    let i = this.list.length;
+    while (i) {
+      i -= 1;
+      if (this.list[i]) {
+        this.list[i][key] = value;
+      }
+    }
+  }
+
+  callAll(key, ...args) {
+    let i = this.list.length;
+    while (i) {
+      i -= 1;
+      if (this.list[i] && this.list[i][key]) {
+        this.list[i][key].apply(this.list[i], args);
+      }
+    }
+  }
+
+  removeAll(destroy = false) {
+    let i = this.list.length;
+    while (i) {
+      i -= 1;
+      if (this.list[i]) {
+        const item = this.remove(this.list[i]);
+        if (destroy) {
+          item.destroy();
+        }
+      }
+    }
+    this.position = 0;
+    this.list = [];
+  }
+
+  get total() {
+    return this.list.length;
+  }
+
+  get first() {
+    this.position = 0;
+    if (this.list.length > 0) {
+      return this.list[0];
+    }
+    return null;
+  }
+
+  get next() {
+    if (this.position < this.list.length) {
+      this.position += 1;
+      return this.list[this.position];
+    }
+    return null;
+  }
+
+}