@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/core/timer.js

@@ -0,0 +1,276 @@
+/**
+ * @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';
+import TimerEvent from './timer_event';
+
+export default class {
+
+  constructor(game, autoDestroy = false) {
+    this.game = game;
+    this.running = false;
+    this.autoDestroy = autoDestroy;
+    this.expired = false;
+    this.elapsed = 0;
+    this.events = [];
+    this.onComplete = new Signal();
+    this.nextTick = 0;
+    this.timeCap = 1000;
+    this.paused = false;
+    this._codePaused = false;
+    this._started = 0;
+    this._pauseStarted = 0;
+    this._pauseTotal = 0;
+    this._now = Date.now();
+    this._len = 0;
+    this._marked = 0;
+    this._i = 0;
+    this._diff = 0;
+    this._newTick = 0;
+  }
+
+  create(delay, loop, repeatCount, callback, callbackContext, args) {
+    const roundedDelay = Math.round(delay);
+    let tick = roundedDelay;
+    if (this._now === 0) {
+      tick += this.game.time.time;
+    } else {
+      tick += this._now;
+    }
+    const event = new TimerEvent(this, roundedDelay, tick, repeatCount, loop, callback, callbackContext, args);
+    this.events.push(event);
+    this.order();
+    this.expired = false;
+    return event;
+  }
+
+  add(delay, callback, callbackContext, ...args) {
+    return this.create(delay, false, 0, callback, callbackContext, args);
+  }
+
+  repeat(delay, repeatCount, callback, callbackContext, ...args) {
+    return this.create(delay, false, repeatCount, callback, callbackContext, args);
+  }
+
+  loop(delay, callback, callbackContext, ...args) {
+    return this.create(delay, true, 0, callback, callbackContext, args);
+  }
+
+  start(delay) {
+    if (this.running) {
+      return;
+    }
+    this._started = this.game.time.time + (delay || 0);
+    this.running = true;
+    for (let i = 0; i < this.events.length; i += 1) {
+      this.events[i].tick = this.events[i].delay + this._started;
+    }
+  }
+
+  stop(clearEvents = true) {
+    this.running = false;
+    if (clearEvents) {
+      this.events.length = 0;
+    }
+  }
+
+  remove(event) {
+    for (let i = 0; i < this.events.length; i += 1) {
+      if (this.events[i] === event) {
+        this.events[i].pendingDelete = true;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  order() {
+    if (this.events.length > 0) {
+      //  Sort the events so the one with the lowest tick is first
+      this.events.sort(this.sortHandler);
+      this.nextTick = this.events[0].tick;
+    }
+  }
+
+  sortHandler(a, b) {
+    if (a.tick < b.tick) {
+      return -1;
+    } else if (a.tick > b.tick) {
+      return 1;
+    }
+    return 0;
+  }
+
+  clearPendingEvents() {
+    this._i = this.events.length;
+    while (this._i) {
+      this._i -= 1;
+      if (this.events[this._i].pendingDelete) {
+        this.events.splice(this._i, 1);
+      }
+    }
+    this._len = this.events.length;
+    this._i = 0;
+  }
+
+  update(time) {
+    if (this.paused) {
+      return true;
+    }
+    this.elapsed = time - this._now;
+    this._now = time;
+    //  spike-dislike
+    if (this.elapsed > this.timeCap) {
+      //  For some reason the time between now and the last time the game was updated was larger than our timeCap.
+      //  This can happen if the Game.config.disableVisibilityChange is true and you swap tabs, which makes the raf pause.
+      //  In this case we need to adjust the TimerEvents and nextTick.
+      this.adjustEvents(time - this.elapsed);
+    }
+    this._marked = 0;
+    //  Clears events marked for deletion and resets _len and _i to 0.
+    this.clearPendingEvents();
+    if (this.running && this._now >= this.nextTick && this._len > 0) {
+      while (this._i < this._len && this.running) {
+        if (this._now >= this.events[this._i].tick && !this.events[this._i].pendingDelete) {
+          //  (now + delay) - (time difference from last tick to now)
+          this._newTick = (this._now + this.events[this._i].delay) - (this._now - this.events[this._i].tick);
+          if (this._newTick < 0) {
+            this._newTick = this._now + this.events[this._i].delay;
+          }
+          if (this.events[this._i].loop === true) {
+            this.events[this._i].tick = this._newTick;
+            this.events[this._i].callback.apply(this.events[this._i].callbackContext, this.events[this._i].args);
+          } else if (this.events[this._i].repeatCount > 0) {
+            this.events[this._i].repeatCount -= 1;
+            this.events[this._i].tick = this._newTick;
+            this.events[this._i].callback.apply(this.events[this._i].callbackContext, this.events[this._i].args);
+          } else {
+            this._marked += 1;
+            this.events[this._i].pendingDelete = true;
+            this.events[this._i].callback.apply(this.events[this._i].callbackContext, this.events[this._i].args);
+          }
+          this._i += 1;
+        } else {
+          break;
+        }
+      }
+      //  Are there any events left?
+      if (this.events.length > this._marked) {
+        this.order();
+      } else {
+        this.expired = true;
+        this.onComplete.dispatch(this);
+      }
+    }
+    if (this.expired && this.autoDestroy) {
+      return false;
+    }
+    return true;
+  }
+
+  pause() {
+    if (!this.running) {
+      return;
+    }
+    this._codePaused = true;
+    if (this.paused) {
+      return;
+    }
+    this._pauseStarted = this.game.time.time;
+    this.paused = true;
+  }
+
+  _pause() {
+    if (this.paused || !this.running) {
+      return;
+    }
+    this._pauseStarted = this.game.time.time;
+    this.paused = true;
+  }
+
+  adjustEvents(baseTime) {
+    for (let i = 0; i < this.events.length; i += 1) {
+      if (!this.events[i].pendingDelete) {
+        //  Work out how long there would have been from when the game paused until the events next tick
+        let t = this.events[i].tick - baseTime;
+        if (t < 0) {
+          t = 0;
+        }
+        //  Add the difference on to the time now
+        this.events[i].tick = this._now + t;
+      }
+    }
+    const d = this.nextTick - baseTime;
+    if (d < 0) {
+      this.nextTick = this._now;
+    } else {
+      this.nextTick = this._now + d;
+    }
+  }
+
+  resume() {
+    if (!this.paused) {
+      return;
+    }
+    const now = this.game.time.time;
+    this._pauseTotal += now - this._now;
+    this._now = now;
+    this.adjustEvents(this._pauseStarted);
+    this.paused = false;
+    this._codePaused = false;
+  }
+
+  _resume() {
+    if (this._codePaused) {
+      return;
+    }
+    this.resume();
+  }
+
+  removeAll() {
+    this.onComplete.removeAll();
+    this.events.length = 0;
+    this._len = 0;
+    this._i = 0;
+  }
+
+  destroy() {
+    this.onComplete.removeAll();
+    this.running = false;
+    this.events = [];
+    this._len = 0;
+    this._i = 0;
+  }
+
+  get next() {
+    return this.nextTick;
+  }
+
+  get duration() {
+    if (this.running && this.nextTick > this._now) {
+      return this.nextTick - this._now;
+    }
+    return 0;
+  }
+
+  get length() {
+    return this.events.length;
+  }
+
+  get ms() {
+    if (this.running) {
+      return this._now - this._started - this._pauseTotal;
+    }
+    return 0;
+  }
+
+  get seconds() {
+    if (this.running) {
+      return this.ms * 0.001;
+    }
+    return 0;
+  }
+
+}

package/src/phaser/core/timer_event.js

@@ -0,0 +1,21 @@
+/**
+ * @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)
+ */
+
+export default class {
+
+  constructor(timer, delay, tick, repeatCount, loop, callback, callbackContext, args) {
+    this.timer = timer;
+    this.delay = delay;
+    this.tick = tick;
+    this.repeatCount = repeatCount - 1;
+    this.loop = loop;
+    this.callback = callback;
+    this.callbackContext = callbackContext;
+    this.args = args;
+    this.pendingDelete = false;
+  }
+
+}

package/src/phaser/core/tween.js

@@ -0,0 +1,329 @@
+/**
+ * @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';
+import TweenData from './tween_data';
+import * as MathUtils from '../util/math';
+import { TWEEN_PENDING, TWEEN_RUNNING, TWEEN_COMPLETE, TWEEN_LOOPED } from './const';
+
+export default class {
+
+  constructor(target, game, manager) {
+    this.game = game;
+    this.target = target;
+    this.manager = manager;
+    this.timeline = [];
+    this.reverse = false;
+    this.timeScale = 1;
+    this.repeatCounter = 0;
+    this.pendingDelete = false;
+    this.onStart = new Signal();
+    this.onLoop = new Signal();
+    this.onRepeat = new Signal();
+    this.onChildComplete = new Signal();
+    this.onComplete = new Signal();
+    this.isRunning = false;
+    this.current = 0;
+    this.properties = {};
+    this.chainedTween = null;
+    this.isPaused = false;
+    this.frameBased = manager.frameBased;
+    this._onUpdateCallback = null;
+    this._onUpdateCallbackContext = null;
+    this._pausedTime = 0;
+    this._codePaused = false;
+    this._hasStarted = false;
+  }
+
+  to(properties, duration = 1000, ease = 'Linear', autoStart = false, delay = 0, repeat = 0, yoyo = false) {
+    if (typeof ease === 'string' && this.manager.easeMap[ease]) {
+      ease = this.manager.easeMap[ease];
+    }
+    if (this.isRunning) {
+      return this;
+    }
+    this.timeline.push(new TweenData(this).to(properties, duration, ease, delay, repeat, yoyo));
+    if (autoStart) {
+      this.start();
+    }
+    return this;
+  }
+
+  from(properties, duration = 1000, ease = 'Linear', autoStart = false, delay = 0, repeat = 0, yoyo = false) {
+    if (typeof ease === 'string' && this.manager.easeMap[ease]) {
+      ease = this.manager.easeMap[ease];
+    }
+    if (this.isRunning) {
+      console.warn('Tween.from cannot be called after Tween.start');
+      return this;
+    }
+    this.timeline.push(new TweenData(this).from(properties, duration, ease, delay, repeat, yoyo));
+    if (autoStart) {
+      this.start();
+    }
+    return this;
+  }
+
+  start(index = 0) {
+    if (this.game === null || this.target === null || this.timeline.length === 0 || this.isRunning) {
+      return this;
+    }
+    //  Populate the tween data
+    for (let i = 0; i < this.timeline.length; i += 1) {
+      //  Build our master property list with the starting values
+      const keys = Object.keys(this.timeline[i].vEnd);
+      for (let k = 0; k < keys.length; k += 1) {
+        const property = keys[k];
+        this.properties[property] = this.target[property] || 0;
+        if (!Array.isArray(this.properties[property])) {
+          //  Ensures we're using numbers, not strings
+          this.properties[property] *= 1.0;
+        }
+      }
+    }
+    for (let i = 0; i < this.timeline.length; i += 1) {
+      this.timeline[i].loadValues();
+    }
+    this.manager.add(this);
+    this.isRunning = true;
+    if (index < 0 || index > this.timeline.length - 1) {
+      index = 0;
+    }
+    this.current = index;
+    this.timeline[this.current].start();
+    return this;
+  }
+
+  stop(complete = false) {
+    this.isRunning = false;
+    this._onUpdateCallback = null;
+    this._onUpdateCallbackContext = null;
+    if (complete) {
+      this.onComplete.dispatch(this.target, this);
+      this._hasStarted = false;
+      if (this.chainedTween) {
+        this.chainedTween.start();
+      }
+    }
+    this.manager.remove(this);
+    return this;
+  }
+
+  updateTweenData(property, value, index = 0) {
+    if (this.timeline.length === 0) {
+      return this;
+    }
+    if (index === -1) {
+      for (let i = 0; i < this.timeline.length; i += 1) {
+        this.timeline[i][property] = value;
+      }
+    } else {
+      this.timeline[index][property] = value;
+    }
+    return this;
+  }
+
+  delay(duration, index) {
+    return this.updateTweenData('delay', duration, index);
+  }
+
+  repeat(total, repeatDelay = 0, index = 0) {
+    this.updateTweenData('repeatCounter', total, index);
+    return this.updateTweenData('repeatDelay', repeatDelay, index);
+  }
+
+  repeatDelay(duration, index) {
+    return this.updateTweenData('repeatDelay', duration, index);
+  }
+
+  yoyo(enable, yoyoDelay = 0, index = 0) {
+    this.updateTweenData('yoyo', enable, index);
+    return this.updateTweenData('yoyoDelay', yoyoDelay, index);
+  }
+
+  yoyoDelay(duration, index) {
+    return this.updateTweenData('yoyoDelay', duration, index);
+  }
+
+  easing(ease, index) {
+    if (typeof ease === 'string' && this.manager.easeMap[ease]) {
+      ease = this.manager.easeMap[ease];
+    }
+    return this.updateTweenData('easingFunction', ease, index);
+  }
+
+  interpolation(interpolation, context = MathUtils, index = 0) {
+    this.updateTweenData('interpolationFunction', interpolation, index);
+    return this.updateTweenData('interpolationContext', context, index);
+  }
+
+  repeatAll(total = 0) {
+    this.repeatCounter = total;
+    return this;
+  }
+
+  chain(...args) {
+    let i = args.length;
+    while (i) {
+      i -= 1;
+      if (i > 0) {
+        args[i - 1].chainedTween = args[i];
+      } else {
+        this.chainedTween = args[i];
+      }
+    }
+    return this;
+  }
+
+  loop(value = true) {
+    this.repeatCounter = (value) ? -1 : 0;
+    return this;
+  }
+
+  onUpdateCallback(callback, callbackContext) {
+    this._onUpdateCallback = callback;
+    this._onUpdateCallbackContext = callbackContext;
+    return this;
+  }
+
+  pause() {
+    this.isPaused = true;
+    this._codePaused = true;
+    this._pausedTime = this.game.time.time;
+  }
+
+  _pause() {
+    if (!this._codePaused) {
+      this.isPaused = true;
+      this._pausedTime = this.game.time.time;
+    }
+  }
+
+  resume() {
+    if (this.isPaused) {
+      this.isPaused = false;
+      this._codePaused = false;
+      for (let i = 0; i < this.timeline.length; i += 1) {
+        if (!this.timeline[i].isRunning) {
+          this.timeline[i].startTime += (this.game.time.time - this._pausedTime);
+        }
+      }
+    }
+  }
+
+  _resume() {
+    if (!this._codePaused) {
+      this.resume();
+    }
+  }
+
+  update(time) {
+    if (this.pendingDelete || !this.target) {
+      return false;
+    }
+    if (this.isPaused) {
+      return true;
+    }
+    const status = this.timeline[this.current].update(time);
+    if (status === TWEEN_PENDING) {
+      return true;
+    } else if (status === TWEEN_RUNNING) {
+      if (!this._hasStarted) {
+        this.onStart.dispatch(this.target, this);
+        this._hasStarted = true;
+      }
+      if (this._onUpdateCallback !== null) {
+        this._onUpdateCallback.call(this._onUpdateCallbackContext, this, this.timeline[this.current].value, this.timeline[this.current]);
+      }
+      //  In case the update callback modifies this tween
+      return this.isRunning;
+    } else if (status === TWEEN_LOOPED) {
+      if (this.timeline[this.current].repeatCounter === -1) {
+        this.onLoop.dispatch(this.target, this);
+      } else {
+        this.onRepeat.dispatch(this.target, this);
+      }
+      return true;
+    } else if (status === TWEEN_COMPLETE) {
+      let complete = false;
+      //  What now?
+      if (this.reverse) {
+        this.current -= 1;
+        if (this.current < 0) {
+          this.current = this.timeline.length - 1;
+          complete = true;
+        }
+      } else {
+        this.current += 1;
+        if (this.current === this.timeline.length) {
+          this.current = 0;
+          complete = true;
+        }
+      }
+      if (complete) {
+        //  We've reached the start or end of the child tweens (depending on Tween.reverse), should we repeat it?
+        if (this.repeatCounter === -1) {
+          this.timeline[this.current].start();
+          this.onLoop.dispatch(this.target, this);
+          return true;
+        } else if (this.repeatCounter > 0) {
+          this.repeatCounter -= 1;
+
+          this.timeline[this.current].start();
+          this.onRepeat.dispatch(this.target, this);
+          return true;
+        }
+        //  No more repeats and no more children, so we're done
+        this.isRunning = false;
+        this.onComplete.dispatch(this.target, this);
+        this._hasStarted = false;
+        if (this.chainedTween) {
+          this.chainedTween.start();
+        }
+        return false;
+      }
+      //  We've still got some children to go
+      this.onChildComplete.dispatch(this.target, this);
+      this.timeline[this.current].start();
+      return true;
+    }
+    return false;
+  }
+
+  generateData(frameRate = 60, data = []) {
+    if (this.game === null || this.target === null) {
+      return null;
+    }
+    //  Populate the tween data
+    for (let i = 0; i < this.timeline.length; i += 1) {
+      //  Build our master property list with the starting values
+      const keys = Object.keys(this.timeline[i].vEnd);
+      for (let k = 0; k < keys.length; k += 1) {
+        const property = keys[k];
+        this.properties[property] = this.target[property] || 0;
+        if (!Array.isArray(this.properties[property])) {
+          //  Ensures we're using numbers, not strings
+          this.properties[property] *= 1.0;
+        }
+      }
+    }
+    for (let i = 0; i < this.timeline.length; i += 1) {
+      this.timeline[i].loadValues();
+    }
+    for (let i = 0; i < this.timeline.length; i += 1) {
+      data = data.concat(this.timeline[i].generateData(frameRate));
+    }
+    return data;
+  }
+
+  get totalDuration() {
+    let total = 0;
+    for (let i = 0; i < this.timeline.length; i += 1) {
+      total += this.timeline[i].duration;
+    }
+    return total;
+  }
+
+}