@vpmedia/phaser 1.0.1 → 1.0.3

package/src/phaser/core/scene.js

@@ -0,0 +1,65 @@
+/**
+ * @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() {
+    this.game = null;
+    this.key = '';
+  }
+
+  init() {
+    // inherit
+  }
+
+  preload() {
+    // inherit
+  }
+
+  loadUpdate() {
+    // inherit
+  }
+
+  loadRender() {
+    // inherit
+  }
+
+  create() {
+    // inherit
+  }
+
+  update() {
+    // inherit
+  }
+
+  preRender() {
+    // inherit
+  }
+
+  render() {
+    // inherit
+  }
+
+  resize() {
+    // inherit
+  }
+
+  paused() {
+    // inherit
+  }
+
+  resumed() {
+    // inherit
+  }
+
+  pauseUpdate() {
+    // inherit
+  }
+
+  shutdown() {
+    // inherit
+  }
+
+}

package/src/phaser/core/scene_manager.js

@@ -0,0 +1,309 @@
+/**
+ * @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 Scene from './scene';
+import { RENDER_CANVAS } from './const';
+
+export default class {
+
+  constructor(game, pendingState) {
+    this.game = game;
+    this.states = {};
+    this._pendingState = null;
+    if (typeof pendingState !== 'undefined' && pendingState !== null) {
+      this._pendingState = pendingState;
+    }
+    this._clearWorld = false;
+    this._clearCache = false;
+    this._created = false;
+    this._args = [];
+    this.current = '';
+    this.onInitCallback = null;
+    this.onPreloadCallback = null;
+    this.onCreateCallback = null;
+    this.onUpdateCallback = null;
+    this.onRenderCallback = null;
+    this.onResizeCallback = null;
+    this.onPreRenderCallback = null;
+    this.onLoadUpdateCallback = null;
+    this.onLoadRenderCallback = null;
+    this.onPausedCallback = null;
+    this.onResumedCallback = null;
+    this.onPauseUpdateCallback = null;
+    this.onShutDownCallback = null;
+  }
+
+  boot() {
+    if (this._pendingState !== null && typeof this._pendingState !== 'string') {
+      this.add('default', this._pendingState, true);
+    }
+  }
+
+  add(key, state, autoStart = false) {
+    let newState = null;
+    if (state instanceof Scene) {
+      newState = state;
+    } else if (typeof state === 'object') {
+      newState = state;
+      newState.game = this.game;
+    } else if (typeof state === 'function') {
+      newState = new state(this.game);
+    }
+    this.states[key] = newState;
+    if (autoStart) {
+      if (this.game.isBooted) {
+        this.start(key);
+      } else {
+        this._pendingState = key;
+      }
+    }
+    return newState;
+  }
+
+  remove(key) {
+    if (this.current === key) {
+      this.callbackContext = null;
+      this.onInitCallback = null;
+      this.onShutDownCallback = null;
+      this.onPreloadCallback = null;
+      this.onLoadRenderCallback = null;
+      this.onLoadUpdateCallback = null;
+      this.onCreateCallback = null;
+      this.onUpdateCallback = null;
+      this.onPreRenderCallback = null;
+      this.onRenderCallback = null;
+      this.onResizeCallback = null;
+      this.onPausedCallback = null;
+      this.onResumedCallback = null;
+      this.onPauseUpdateCallback = null;
+    }
+    delete this.states[key];
+  }
+
+  start(key, clearWorld = true, clearCache = false, ...args) {
+    if (this.checkState(key)) {
+      //  Place the state in the queue. It will be started the next time the game loop begins.
+      this._pendingState = key;
+      this._clearWorld = clearWorld;
+      this._clearCache = clearCache;
+      if (args && args.length > 0) {
+        this._args = args.slice();
+      }
+    }
+  }
+
+  restart(clearWorld = true, clearCache = false, ...args) {
+    this._pendingState = this.current;
+    this._clearWorld = clearWorld;
+    this._clearCache = clearCache;
+    if (args && args.length > 0) {
+      this._args = args.slice();
+    }
+  }
+
+  preUpdate() {
+    if (this._pendingState && this.game.isBooted) {
+      // var previousStateKey = this.current;
+      //  Already got a state running?
+      this.clearCurrentState();
+      this.setCurrentState(this._pendingState);
+      this.game.world.x = 0;
+      this.game.world.y = 0;
+      if (this.current !== this._pendingState) {
+        return;
+      }
+      this._pendingState = null;
+      //  If StateManager.start has been called from the init of a State that ALSO has a preload, then
+      //  onPreloadCallback will be set, but must be ignored
+      if (this.onPreloadCallback) {
+        this.game.load.reset(true);
+        this.onPreloadCallback.call(this.callbackContext, this.game);
+        //  Is the loader empty?
+        if (this.game.load.totalQueuedFiles() === 0 && this.game.load.totalQueuedPacks() === 0) {
+          this.loadComplete();
+        } else {
+          //  Start the loader going as we have something in the queue
+          this.game.load.start();
+        }
+      } else {
+        //  No init? Then there was nothing to load either
+        this.loadComplete();
+      }
+    }
+  }
+
+  clearCurrentState() {
+    if (this.current) {
+      if (this.onShutDownCallback) {
+        this.onShutDownCallback.call(this.callbackContext, this.game);
+      }
+      this.game.tweens.removeAll();
+      this.game.input.reset(true);
+      this.game.time.removeAll();
+      this.game.scale.reset(this._clearWorld);
+      if (this._clearWorld) {
+        this.game.world.destroy(true, true);
+        if (this._clearCache) {
+          this.game.cache.destroy();
+        }
+      }
+    }
+  }
+
+  checkState(key) {
+    if (this.states[key]) {
+      if (this.states[key].preload || this.states[key].create || this.states[key].update || this.states[key].render) {
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
+
+  link(key) {
+    this.states[key].game = this.game;
+    this.states[key].key = key;
+  }
+
+  unlink(key) {
+    if (this.states[key]) {
+      this.states[key].game = null;
+    }
+  }
+
+  setCurrentState(key) {
+    this.callbackContext = this.states[key];
+    this.link(key);
+    //  Used when the state is set as being the current active state
+    this.onInitCallback = this.callbackContext.init || this.dummy;
+    this.onPreloadCallback = this.callbackContext.preload || null;
+    this.onLoadRenderCallback = this.callbackContext.loadRender || null;
+    this.onLoadUpdateCallback = this.callbackContext.loadUpdate || null;
+    this.onCreateCallback = this.callbackContext.create || null;
+    this.onUpdateCallback = this.callbackContext.update || null;
+    this.onPreRenderCallback = this.callbackContext.preRender || null;
+    this.onRenderCallback = this.callbackContext.render || null;
+    this.onResizeCallback = this.callbackContext.resize || null;
+    this.onPausedCallback = this.callbackContext.paused || null;
+    this.onResumedCallback = this.callbackContext.resumed || null;
+    this.onPauseUpdateCallback = this.callbackContext.pauseUpdate || null;
+    this.onShutDownCallback = this.callbackContext.shutdown || this.dummy;
+    this.current = key;
+    this._created = false;
+    this.onInitCallback.apply(this.callbackContext, this._args);
+    if (key === this._pendingState) {
+      this._args = [];
+    }
+    this.game.isKickStart = true;
+  }
+
+  getCurrentState() {
+    return this.states[this.current];
+  }
+
+  loadComplete() {
+    if (this._created === false && this.onLoadUpdateCallback) {
+      this.onLoadUpdateCallback.call(this.callbackContext, this.game);
+    }
+    if (this._created === false && this.onCreateCallback) {
+      this._created = true;
+      this.onCreateCallback.call(this.callbackContext, this.game);
+    } else {
+      this._created = true;
+    }
+  }
+
+  pause() {
+    if (this._created && this.onPausedCallback) {
+      this.onPausedCallback.call(this.callbackContext, this.game);
+    }
+  }
+
+  resume() {
+    if (this._created && this.onResumedCallback) {
+      this.onResumedCallback.call(this.callbackContext, this.game);
+    }
+  }
+
+  update() {
+    if (this._created) {
+      if (this.onUpdateCallback) {
+        this.onUpdateCallback.call(this.callbackContext, this.game);
+      }
+    } else if (this.onLoadUpdateCallback) {
+      this.onLoadUpdateCallback.call(this.callbackContext, this.game);
+    }
+  }
+
+  pauseUpdate() {
+    if (this._created) {
+      if (this.onPauseUpdateCallback) {
+        this.onPauseUpdateCallback.call(this.callbackContext, this.game);
+      }
+    } else if (this.onLoadUpdateCallback) {
+      this.onLoadUpdateCallback.call(this.callbackContext, this.game);
+    }
+  }
+
+  preRender(elapsedTime) {
+    if (this._created && this.onPreRenderCallback) {
+      this.onPreRenderCallback.call(this.callbackContext, this.game, elapsedTime);
+    }
+  }
+
+  resize(width, height) {
+    if (this.onResizeCallback) {
+      this.onResizeCallback.call(this.callbackContext, width, height);
+    }
+  }
+
+  render() {
+    if (this._created) {
+      if (this.onRenderCallback) {
+        if (this.game.renderer.type === RENDER_CANVAS) {
+          this.game.context.save();
+          this.game.context.setTransform(1, 0, 0, 1, 0, 0);
+          this.onRenderCallback.call(this.callbackContext, this.game);
+          this.game.context.restore();
+        } else {
+          this.onRenderCallback.call(this.callbackContext, this.game);
+        }
+      }
+    } else if (this.onLoadRenderCallback) {
+      this.onLoadRenderCallback.call(this.callbackContext, this.game);
+    }
+  }
+
+  destroy() {
+    this._clearWorld = true;
+    this._clearCache = true;
+    this.clearCurrentState();
+    this.callbackContext = null;
+    this.onInitCallback = null;
+    this.onShutDownCallback = null;
+    this.onPreloadCallback = null;
+    this.onLoadRenderCallback = null;
+    this.onLoadUpdateCallback = null;
+    this.onCreateCallback = null;
+    this.onUpdateCallback = null;
+    this.onRenderCallback = null;
+    this.onPausedCallback = null;
+    this.onResumedCallback = null;
+    this.onPauseUpdateCallback = null;
+    this.game = null;
+    this.states = {};
+    this._pendingState = null;
+    this.current = '';
+  }
+
+  dummy() {
+    // pass
+  }
+
+  get created() {
+    return this._created;
+  }
+
+}

package/src/phaser/core/signal.js

@@ -0,0 +1,175 @@
+/**
+ * @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 SignalBinding from './signal_binding';
+
+export default class {
+
+  constructor() {
+    this._bindings = null;
+    this._prevParams = null;
+    this.memorize = false;
+    this._shouldPropagate = true;
+    this.active = true;
+    this._boundDispatch = false;
+  }
+
+  validateListener(listener, fnName) {
+    if (typeof listener !== 'function') {
+      throw new Error('Signal: listener is a required param of {fn}() and should be a Function.'.replace('{fn}', fnName));
+    }
+  }
+
+  _registerListener(listener, isOnce, listenerContext, priority, args) {
+    const prevIndex = this._indexOfListener(listener, listenerContext);
+    let binding;
+    if (prevIndex !== -1) {
+      binding = this._bindings[prevIndex];
+      if (binding.isOnce() !== isOnce) {
+        throw new Error('You cannot add' + (isOnce ? '' : 'Once') + '() then add' + (!isOnce ? '' : 'Once') + '() the same listener without removing the relationship first.');
+      }
+    } else {
+      binding = new SignalBinding(this, listener, isOnce, listenerContext, priority, args);
+      this._addBinding(binding);
+    }
+    if (this.memorize && this._prevParams) {
+      binding.execute(this._prevParams);
+    }
+    return binding;
+  }
+
+  _addBinding(binding) {
+    if (!this._bindings) {
+      this._bindings = [];
+    }
+    //  Simplified insertion sort
+    let n = this._bindings.length;
+    do {
+      n -= 1;
+    }
+    while (this._bindings[n] && binding._priority <= this._bindings[n]._priority);
+    this._bindings.splice(n + 1, 0, binding);
+  }
+
+  _indexOfListener(listener, context = null) {
+    if (!this._bindings) {
+      return -1;
+    }
+    let n = this._bindings.length;
+    let cur;
+    while (n) {
+      n -= 1;
+      cur = this._bindings[n];
+      if (cur._listener === listener && cur.context === context) {
+        return n;
+      }
+    }
+    return -1;
+  }
+
+  has(listener, context) {
+    return this._indexOfListener(listener, context) !== -1;
+  }
+
+  add(listener, listenerContext, priority, ...args) {
+    this.validateListener(listener, 'add');
+    return this._registerListener(listener, false, listenerContext, priority, args);
+  }
+
+  addOnce(listener, listenerContext, priority, ...args) {
+    this.validateListener(listener, 'addOnce');
+    return this._registerListener(listener, true, listenerContext, priority, args);
+  }
+
+  remove(listener, context) {
+    this.validateListener(listener, 'remove');
+    const i = this._indexOfListener(listener, context);
+    if (i !== -1) {
+      // no reason to a SignalBinding exist if it isn't attached to a signal
+      this._bindings[i]._destroy();
+      this._bindings.splice(i, 1);
+    }
+    return listener;
+  }
+
+  removeAll(context = null) {
+    if (!this._bindings) {
+      return;
+    }
+    let n = this._bindings.length;
+    while (n) {
+      n -= 1;
+      if (context) {
+        if (this._bindings[n].context === context) {
+          this._bindings[n]._destroy();
+          this._bindings.splice(n, 1);
+        }
+      } else {
+        this._bindings[n]._destroy();
+      }
+    }
+    if (!context) {
+      this._bindings.length = 0;
+    }
+  }
+
+  getNumListeners() {
+    return this._bindings ? this._bindings.length : 0;
+  }
+
+  halt() {
+    this._shouldPropagate = false;
+  }
+
+  dispatch(...args) {
+    if (!this.active || !this._bindings) {
+      return;
+    }
+    const paramsArr = args.slice();
+    let n = this._bindings.length;
+
+    if (this.memorize) {
+      this._prevParams = paramsArr;
+    }
+    if (!n) {
+      // Should come after memorize
+      return;
+    }
+    const bindings = this._bindings.slice(); // clone array in case add/remove items during dispatch
+    this._shouldPropagate = true; // in case `halt` was called before dispatch or during the previous dispatch.
+
+    // execute all callbacks until end of the list or until a callback returns `false` or stops propagation
+    // reverse loop since listeners with higher priority will be added at the end of the list
+    do {
+      n -= 1;
+    }
+    while (bindings[n] && this._shouldPropagate && bindings[n].execute(paramsArr) !== false);
+  }
+
+  forget() {
+    if (this._prevParams) {
+      this._prevParams = null;
+    }
+  }
+
+  dispose() {
+    this.removeAll();
+    this.forget();
+    this._bindings = null;
+  }
+
+  toString() {
+    return '[Signal active:' + this.active + ' numListeners:' + this.getNumListeners() + ']';
+  }
+
+  get boundDispatch() {
+    const _this = this;
+    if (!this._boundDispatch) {
+      this._boundDispatch = (...rest) => _this.dispatch(...rest);
+    }
+    return this._boundDispatch;
+  }
+
+}

package/src/phaser/core/signal_binding.js

@@ -0,0 +1,69 @@
+/**
+ * @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(signal, listener, isOnce = false, listenerContext = null, priority = 0, args = null) {
+    this._signal = signal;
+    this._listener = listener;
+    this._args = args;
+    this._priority = priority;
+    this._isOnce = isOnce;
+    this.context = listenerContext;
+    this.callCount = 0;
+    this.active = true;
+    this.params = null;
+  }
+
+  execute(paramsArr) {
+    let handlerReturn;
+    let params;
+    if (this.active && !!this._listener) {
+      params = this.params ? this.params.concat(paramsArr) : paramsArr;
+      if (this._args) {
+        params = params.concat(this._args);
+      }
+      handlerReturn = this._listener.apply(this.context, params);
+      this.callCount += 1;
+      if (this._isOnce) {
+        this.detach();
+      }
+    }
+    return handlerReturn;
+
+  }
+
+  detach() {
+    return this.isBound() ? this._signal.remove(this._listener, this.context) : null;
+  }
+
+  isBound() {
+    return (!!this._signal && !!this._listener);
+  }
+
+  isOnce() {
+    return this._isOnce;
+  }
+
+  getListener() {
+    return this._listener;
+  }
+
+  getSignal() {
+    return this._signal;
+  }
+
+  _destroy() {
+    delete this._signal;
+    delete this._listener;
+    delete this.context;
+  }
+
+  toString() {
+    return '[SignalBinding isOnce:' + this._isOnce + ', isBound:' + this.isBound() + ', active:' + this.active + ']';
+  }
+
+}