@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/core/sound_manager.js

@@ -0,0 +1,365 @@
+/**
+ * @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 ArraySet from './array_set';
+import Signal from './signal';
+import Sound from './sound';
+
+export default class {
+
+  constructor(game) {
+    this.game = game;
+    this.onSoundDecode = new Signal();
+    this.onVolumeChange = new Signal();
+    this.onMute = new Signal();
+    this.onUnMute = new Signal();
+    this.context = null;
+    this.baseLatency = 0; // https://developer.mozilla.org/en-US/docs/Web/API/AudioContext/baseLatency
+    this.usingWebAudio = false;
+    this.usingAudioTag = false;
+    this.noAudio = false;
+    this.connectToMaster = true;
+    this.touchLocked = false;
+    this.muteOnPause = true;
+    this._codeMuted = false;
+    this._muted = false;
+    this._unlockSource = null;
+    this._volume = 1;
+    this._sounds = [];
+    this._watchList = new ArraySet();
+    this._watching = false;
+    this._watchCallback = null;
+    this._watchContext = null;
+  }
+
+  boot() {
+    if (window.PhaserRegistry && window.PhaserRegistry.audioContext) {
+      this.context = window.PhaserRegistry.audioContext;
+    } else if (window.AudioContext) {
+      try {
+        this.context = new window.AudioContext();
+      } catch (error) {
+        this.context = null;
+        this.usingWebAudio = false;
+        this.touchLocked = false;
+      }
+    } else if (window.webkitAudioContext) {
+      try {
+        /* eslint-disable new-cap */
+        this.context = new window.webkitAudioContext();
+      } catch (error) {
+        this.context = null;
+        this.usingWebAudio = false;
+        this.touchLocked = false;
+      }
+    }
+    if (this.context === null || (this.context && this.context.createGain === undefined && this.context.createGainNode === undefined)) {
+      //  No Web Audio support - how about legacy Audio?
+      if (window.Audio === undefined) {
+        this.noAudio = true;
+        return;
+      }
+      this.usingAudioTag = true;
+    } else {
+      this.usingWebAudio = true;
+      this.baseLatency = this.context.baseLatency || (256 / (this.context.sampleRate || 44100));
+      if (this.context.createGain === undefined) {
+        this.masterGain = this.context.createGainNode();
+      } else {
+        this.masterGain = this.context.createGain();
+      }
+      this.masterGain.gain.value = 1;
+      this.masterGain.connect(this.context.destination);
+      if (this.context.state === 'suspended') {
+        this.game.input.onUp.addOnce(this.resumeWebAudio, this);
+      }
+    }
+    if (!this.noAudio && !this.game.device.cocoonJS && (this.game.device.iOS || this.game.device.android)) {
+      this.game.input.addTouchLockCallback(this.unlock, this, true);
+      this.touchLocked = true;
+    }
+  }
+
+  resumeWebAudio() {
+    if (this.usingWebAudio && this.context.state === 'suspended') {
+      this.context.resume();
+    }
+  }
+
+  unlock() {
+    if (this.noAudio || !this.touchLocked || this._unlockSource !== null) {
+      return true;
+    }
+    //  Global override (mostly for Audio Tag testing)
+    if (this.usingAudioTag) {
+      this.touchLocked = false;
+      this._unlockSource = null;
+    } else if (this.usingWebAudio) {
+      // Create empty buffer and play it
+      // The SoundManager.update loop captures the state of it and then resets touchLocked to false
+      const buffer = this.context.createBuffer(1, 1, 22050);
+      this._unlockSource = this.context.createBufferSource();
+      this._unlockSource.buffer = buffer;
+      this._unlockSource.connect(this.context.destination);
+      if (this._unlockSource.start === undefined) {
+        this._unlockSource.noteOn(0);
+      } else {
+        this._unlockSource.start(0);
+      }
+      this.resumeWebAudio();
+    }
+    //  We can remove the event because we've done what we needed (started the unlock sound playing)
+    return true;
+  }
+
+  stopAll() {
+    if (this.noAudio) {
+      return;
+    }
+    for (let i = 0; i < this._sounds.length; i += 1) {
+      if (this._sounds[i]) {
+        this._sounds[i].stop();
+      }
+    }
+  }
+
+  pauseAll() {
+    if (this.noAudio) {
+      return;
+    }
+    for (let i = 0; i < this._sounds.length; i += 1) {
+      if (this._sounds[i]) {
+        this._sounds[i].pause();
+      }
+    }
+  }
+
+  resumeAll() {
+    if (this.noAudio) {
+      return;
+    }
+    for (let i = 0; i < this._sounds.length; i += 1) {
+      if (this._sounds[i]) {
+        this._sounds[i].resume();
+      }
+    }
+  }
+
+  decode(key, sound = null) {
+    const soundData = this.game.cache.getSoundData(key);
+    if (soundData) {
+      if (this.game.cache.isSoundDecoded(key) === false) {
+        this.game.cache.updateSound(key, 'isDecoding', true);
+        const scope = this;
+        try {
+          this.context.decodeAudioData(soundData, (buffer) => {
+            if (buffer) {
+              scope.game.cache.decodedSound(key, buffer);
+              scope.onSoundDecode.dispatch(key, sound);
+            }
+          });
+        } catch (e) {
+          // pass
+        }
+      }
+    }
+  }
+
+  setDecodedCallback(files, callback, callbackContext) {
+    if (typeof files === 'string') {
+      files = [files];
+    }
+    this._watchList.reset();
+    for (let i = 0; i < files.length; i += 1) {
+      if (files[i] instanceof Sound) {
+        if (!this.game.cache.isSoundDecoded(files[i].key)) {
+          this._watchList.add(files[i].key);
+        }
+      } else if (!this.game.cache.isSoundDecoded(files[i])) {
+        this._watchList.add(files[i]);
+      }
+    }
+    //  All decoded already?
+    if (this._watchList.total === 0) {
+      this._watching = false;
+      callback.call(callbackContext);
+    } else {
+      this._watching = true;
+      this._watchCallback = callback;
+      this._watchContext = callbackContext;
+    }
+  }
+
+  update() {
+    if (this.noAudio) {
+      return;
+    }
+    if (this.touchLocked && this._unlockSource !== null && (this._unlockSource.playbackState === this._unlockSource.PLAYING_STATE || this._unlockSource.playbackState === this._unlockSource.FINISHED_STATE)) {
+      this.touchLocked = false;
+      this._unlockSource = null;
+      this.resumeWebAudio();
+    } else if (this.usingWebAudio && this.context.state === 'interrupted') {
+      this.context.resume();
+    }
+    for (let i = 0; i < this._sounds.length; i += 1) {
+      this._sounds[i].update();
+    }
+    if (this._watching) {
+      let key = this._watchList.first;
+      while (key) {
+        if (this.game.cache.isSoundDecoded(key)) {
+          this._watchList.remove(key);
+        }
+        key = this._watchList.next;
+      }
+      if (this._watchList.total === 0) {
+        this._watching = false;
+        this._watchCallback.call(this._watchContext);
+      }
+    }
+  }
+
+  add(key, volume = 1, loop = false, connect = this.connectToMaster) {
+    const sound = new Sound(this.game, key, volume, loop, connect);
+    this._sounds.push(sound);
+    return sound;
+  }
+
+  remove(sound) {
+    let i = this._sounds.length;
+    while (i) {
+      i -= 1;
+      if (this._sounds[i] === sound) {
+        this._sounds[i].destroy(false);
+        this._sounds.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  removeByKey(key) {
+    let i = this._sounds.length;
+    let removed = 0;
+    while (i) {
+      i -= 1;
+      if (this._sounds[i].key === key) {
+        this._sounds[i].destroy(false);
+        this._sounds.splice(i, 1);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+
+  play(key, volume = 1, loop = false) {
+    if (this.noAudio) {
+      return null;
+    }
+    const sound = this.add(key, volume, loop);
+    sound.play();
+    return sound;
+  }
+
+  setMute() {
+    if (this._muted) {
+      return;
+    }
+    this._muted = true;
+    if (this.usingWebAudio) {
+      this._muteVolume = this.masterGain.gain.value;
+      this.masterGain.gain.value = 0;
+    }
+    // Loop through sounds
+    for (let i = 0; i < this._sounds.length; i += 1) {
+      if (this._sounds[i].usingAudioTag) {
+        this._sounds[i].mute = true;
+      }
+    }
+    this.onMute.dispatch();
+  }
+
+  unsetMute() {
+    if (!this._muted || this._codeMuted) {
+      return;
+    }
+    this._muted = false;
+    if (this.usingWebAudio) {
+      this.masterGain.gain.value = this._muteVolume;
+    }
+    // Loop through sounds
+    for (let i = 0; i < this._sounds.length; i += 1) {
+      if (this._sounds[i].usingAudioTag) {
+        this._sounds[i].mute = false;
+      }
+    }
+    this.onUnMute.dispatch();
+  }
+
+  destroy() {
+    this.stopAll();
+    for (let i = 0; i < this._sounds.length; i += 1) {
+      if (this._sounds[i]) {
+        this._sounds[i].destroy();
+      }
+    }
+    this._sounds = [];
+    this.onSoundDecode.dispose();
+    if (this.context) {
+      if (window.PhaserRegistry) {
+        window.PhaserRegistry.audioContext = this.context;
+      } else if (this.context.close) {
+        this.context.close();
+      }
+    }
+  }
+
+  get mute() {
+    return this._muted;
+  }
+
+  set mute(value) {
+    if (value || false) {
+      if (this._muted) {
+        return;
+      }
+      this._codeMuted = true;
+      this.setMute();
+    } else {
+      if (!this._muted) {
+        return;
+      }
+      this._codeMuted = false;
+      this.unsetMute();
+    }
+  }
+
+  get volume() {
+    return this._volume;
+  }
+
+  set volume(value) {
+    if (value < 0) {
+      value = 0;
+    } else if (value > 1) {
+      value = 1;
+    }
+    if (this._volume !== value) {
+      this._volume = value;
+      if (this.usingWebAudio) {
+        this.masterGain.gain.value = value;
+      } else {
+        //  Loop through the sound cache and change the volume of all html audio tags
+        for (let i = 0; i < this._sounds.length; i += 1) {
+          if (this._sounds[i].usingAudioTag) {
+            this._sounds[i].updateGlobalVolume(value);
+          }
+        }
+      }
+      this.onVolumeChange.dispatch(value);
+    }
+  }
+
+}

package/src/phaser/core/stage.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)
+ */
+import Matrix from '../geom/matrix';
+import DisplayObject from '../display/display_object';
+import { setUserSelect, setTouchAction } from '../display/canvas/util';
+import { valueToColor } from '../util/math';
+import { SCALE_LINEAR, SCALE_NEAREST } from './const';
+
+export default class extends DisplayObject {
+
+  constructor(game) {
+    super();
+    this.game = game;
+    this.name = '_stage_root';
+    this.worldTransform = new Matrix();
+    this.currentRenderOrderID = 0;
+    this._bgColor = {
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      color: 0,
+      rgba: '#000000',
+    };
+    if (!game.config.transparent) {
+      // transparent = 0,0,0,0 - otherwise r,g,b,1
+      this._bgColor.a = 1;
+    }
+    if (game.config.backgroundColor && !this.game.config.transparent) {
+      this.setBackgroundColor(game.config.backgroundColor);
+    }
+  }
+
+  setBackgroundColor(color) {
+    if (this.game.config.transparent) {
+      return;
+    }
+    valueToColor(color, this._bgColor);
+    //  For gl.clearColor (canvas uses _bgColor.rgba)
+    this._bgColor.r /= 255;
+    this._bgColor.g /= 255;
+    this._bgColor.b /= 255;
+    this._bgColor.a = 1;
+  }
+
+  boot() {
+    setUserSelect(this.game.canvas, 'none');
+    setTouchAction(this.game.canvas, 'none');
+  }
+
+  preUpdate() {
+    this.currentRenderOrderID = 0;
+    //  This can't loop in reverse, we need the renderOrderID to be in sequence
+    for (let i = 0; i < this.children.length; i += 1) {
+      this.children[i].preUpdate();
+    }
+  }
+
+  update() {
+    let i = this.children.length;
+    while (i) {
+      i -= 1;
+      this.children[i].update();
+    }
+  }
+
+  postUpdate() {
+    for (let i = 0; i < this.children.length; i += 1) {
+      this.children[i].postUpdate();
+    }
+    this.updateTransform();
+  }
+
+  updateTransform() {
+    this.worldAlpha = 1;
+    for (let i = 0; i < this.children.length; i += 1) {
+      this.children[i].updateTransform();
+    }
+  }
+
+  destroy() {
+    this.exists = false;
+    this.game = null;
+    this.worldTransform = null;
+    this._bgColor = null;
+  }
+
+  get backgroundColor() {
+    return this._bgColor.color;
+  }
+
+  set backgroundColor(value) {
+    this.setBackgroundColor(value);
+  }
+
+  get smoothed() {
+    return window.PhaserRegistry.TEXTURE_SCALE_MODE === SCALE_LINEAR;
+  }
+
+  set smoothed(value) {
+    window.PhaserRegistry.TEXTURE_SCALE_MODE = value ? SCALE_LINEAR : SCALE_NEAREST;
+  }
+
+
+}

package/src/phaser/core/time.js

@@ -0,0 +1,203 @@
+/**
+ * @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 Timer from './timer';
+
+export default class {
+
+  constructor(game) {
+    this.game = game;
+    this.time = 0;
+    this.prevTime = 0;
+    this.now = 0;
+    this.elapsed = 0;
+    this.elapsedMS = 0;
+    this.physicsElapsed = 1 / 60;
+    this.physicsElapsedMS = (1 / 60) * 1000;
+    this.desiredFpsMult = 1.0 / 60;
+    this._desiredFps = 60;
+    this.suggestedFps = this.desiredFps;
+    this.slowMotion = 1.0;
+    this.advancedTiming = false;
+    this.frames = 0;
+    this.fps = 0;
+    this.fpsMin = 1000;
+    this.fpsMax = 0;
+    this.msMin = 1000;
+    this.msMax = 0;
+    this.pauseDuration = 0;
+    this.timeToCall = 0;
+    this.timeExpected = 0;
+    this.events = new Timer(this.game, false);
+    this._frameCount = 0;
+    this._elapsedAccumulator = 0;
+    this._started = 0;
+    this._timeLastSecond = 0;
+    this._pauseStarted = 0;
+    this._justResumed = false;
+    this._timers = [];
+  }
+
+  boot() {
+    this._started = Date.now();
+    this.time = Date.now();
+    this.events.start();
+    this.timeExpected = this.time;
+  }
+
+  add(timer) {
+    this._timers.push(timer);
+    return timer;
+  }
+
+  create(autoDestroy = true) {
+    const timer = new Timer(this.game, autoDestroy);
+    this._timers.push(timer);
+    return timer;
+  }
+
+  removeAll() {
+    for (let i = 0; i < this._timers.length; i += 1) {
+      this._timers[i].destroy();
+    }
+    this._timers = [];
+    this.events.removeAll();
+  }
+
+  refresh() {
+    const previousDateNow = this.time;
+    // this.time always holds a Date.now value
+    this.time = Date.now();
+    //  Adjust accordingly.
+    this.elapsedMS = this.time - previousDateNow;
+  }
+
+  update(time) {
+    const previousDateNow = this.time;
+    // this.time always holds a Date.now value
+    this.time = Date.now();
+    //  Adjust accordingly.
+    this.elapsedMS = this.time - previousDateNow;
+    // 'now' is currently still holding the time of the last call, move it into prevTime
+    this.prevTime = this.now;
+    // update 'now' to hold the current time
+    // this.now may hold the RAF high resolution time value if RAF is available (otherwise it also holds Date.now)
+    this.now = time;
+    // elapsed time between previous call and now - this could be a high resolution value
+    this.elapsed = this.now - this.prevTime;
+    if (this.game.raf._isSetTimeOut) {
+      // console.log('Time isSet', this._desiredFps, 'te', this.timeExpected, 'time', time);
+      // time to call this function again in ms in case we're using timers instead of RequestAnimationFrame to update the game
+      this.timeToCall = Math.floor(Math.max(0, (1000.0 / this._desiredFps) - (this.timeExpected - time)));
+      // time when the next call is expected if using timers
+      this.timeExpected = time + this.timeToCall;
+      // console.log('Time expect', this.timeExpected);
+    }
+    if (this.advancedTiming) {
+      this.updateAdvancedTiming();
+    }
+    //  Paused but still running?
+    if (!this.game.paused) {
+      //  Our internal Phaser.Timer
+      this.events.update(this.time);
+      if (this._timers.length) {
+        this.updateTimers();
+      }
+    }
+  }
+
+  updateTimers() {
+    let i = 0;
+    let len = this._timers.length;
+    while (i < len) {
+      if (this._timers[i].update(this.time)) {
+        i += 1;
+      } else {
+        //  Timer requests to be removed
+        this._timers.splice(i, 1);
+        len -= 1;
+      }
+    }
+  }
+
+  updateAdvancedTiming() {
+    // count the number of time.update calls
+    this._frameCount += 1;
+    this._elapsedAccumulator += this.elapsed;
+    // occasionally recalculate the suggestedFps based on the accumulated elapsed time
+    if (this._frameCount >= this._desiredFps * 2) {
+      // this formula calculates suggestedFps in multiples of 5 fps
+      this.suggestedFps = Math.floor(200 / (this._elapsedAccumulator / this._frameCount)) * 5;
+      this._frameCount = 0;
+      this._elapsedAccumulator = 0;
+    }
+    this.msMin = Math.min(this.msMin, this.elapsed);
+    this.msMax = Math.max(this.msMax, this.elapsed);
+    this.frames += 1;
+    if (this.now > this._timeLastSecond + 1000) {
+      this.fps = Math.round((this.frames * 1000) / (this.now - this._timeLastSecond));
+      this.fpsMin = Math.min(this.fpsMin, this.fps);
+      this.fpsMax = Math.max(this.fpsMax, this.fps);
+      this._timeLastSecond = this.now;
+      this.frames = 0;
+    }
+  }
+
+  gamePaused() {
+    this._pauseStarted = Date.now();
+    this.events.pause();
+    let i = this._timers.length;
+    while (i) {
+      i -= 1;
+      this._timers[i]._pause();
+    }
+  }
+
+  gameResumed() {
+    this.time = Date.now();
+    this.pauseDuration = this.time - this._pauseStarted;
+    this.events.resume();
+    let i = this._timers.length;
+    while (i) {
+      i -= 1;
+      this._timers[i]._resume();
+    }
+  }
+
+  totalElapsedSeconds() {
+    return (this.time - this._started) * 0.001;
+  }
+
+  elapsedSince(since) {
+    return this.time - since;
+  }
+
+  elapsedSecondsSince(since) {
+    return (this.time - since) * 0.001;
+  }
+
+  reset() {
+    this._started = this.time;
+    this.removeAll();
+  }
+
+  destroy() {
+    this.reset();
+  }
+
+  get desiredFps() {
+    return this._desiredFps;
+  }
+
+  set desiredFps(value) {
+    this._desiredFps = value;
+    //  Set the physics elapsed time... this will always be 1 / this.desiredFps
+    //  because we're using fixed time steps in game.update
+    this.physicsElapsed = 1 / value;
+    this.physicsElapsedMS = this.physicsElapsed * 1000;
+    this.desiredFpsMult = 1.0 / value;
+  }
+
+}