* Returns true or false based on the chance value (default 50%). For example if you wanted a player to have a 30% chance * of getting a bonus, call chanceRoll(30) - true means the chance passed, false means it failed. *
* @param chance The chance of receiving the value. A number between 0 and 100 (effectively 0% to 100%) * @return true if the roll passed, or false */ function (chance) { if (typeof chance === "undefined") { chance = 50; } if(chance <= 0) { return false; } else if(chance >= 100) { return true; } else { if(Math.random() * 100 >= chance) { return false; } else { return true; } } }; GameMath.prototype.maxAdd = /** * Adds the given amount to the value, but never lets the value go over the specified maximum * * @param value The value to add the amount to * @param amount The amount to add to the value * @param max The maximum the value is allowed to be * @return The new value */ function (value, amount, max) { value += amount; if(value > max) { value = max; } return value; }; GameMath.prototype.minSub = /** * Subtracts the given amount from the value, but never lets the value go below the specified minimum * * @param value The base value * @param amount The amount to subtract from the base value * @param min The minimum the value is allowed to be * @return The new value */ function (value, amount, min) { value -= amount; if(value < min) { value = min; } return value; }; GameMath.prototype.wrapValue = /** * Adds value to amount and ensures that the result always stays between 0 and max, by wrapping the value around. *Values must be positive integers, and are passed through Math.abs
* * @param value The value to add the amount to * @param amount The amount to add to the value * @param max The maximum the value is allowed to be * @return The wrapped value */ function (value, amount, max) { var diff; value = Math.abs(value); amount = Math.abs(amount); max = Math.abs(max); diff = (value + amount) % max; return diff; }; GameMath.prototype.randomSign = /** * Randomly returns either a 1 or -1 * * @return 1 or -1 */ function () { return (Math.random() > 0.5) ? 1 : -1; }; GameMath.prototype.isOdd = /** * Returns true if the number given is odd. * * @param n The number to check * * @return True if the given number is odd. False if the given number is even. */ function (n) { if(n & 1) { return true; } else { return false; } }; GameMath.prototype.isEven = /** * Returns true if the number given is even. * * @param n The number to check * * @return True if the given number is even. False if the given number is odd. */ function (n) { if(n & 1) { return false; } else { return true; } }; GameMath.prototype.wrapAngle = /** * Keeps an angle value between -180 and +180Number between 0 and 1.
*/
function () {
return this.globalSeed = this.srand(this.globalSeed);
};
GameMath.prototype.srand = /**
* Generates a random number based on the seed provided.
*
* @param Seed A number between 0 and 1, used to generate a predictable random number (very optional).
*
* @return A Number between 0 and 1.
*/
function (Seed) {
return ((69621 * (Seed * 0x7FFFFFFF)) % 0x7FFFFFFF) / 0x7FFFFFFF;
};
GameMath.prototype.getRandom = /**
* Fetch a random entry from the given array.
* Will return null if random selection is missing, or array has no entries.
*
* @param objects An array of objects.
* @param startIndex Optional offset off the front of the array. Default value is 0, or the beginning of the array.
* @param length Optional restriction on the number of values you want to randomly select from.
*
* @return The random object that was selected.
*/
function (objects, startIndex, length) {
if (typeof startIndex === "undefined") { startIndex = 0; }
if (typeof length === "undefined") { length = 0; }
if(objects != null) {
var l = length;
if((l == 0) || (l > objects.length - startIndex)) {
l = objects.length - startIndex;
}
if(l > 0) {
return objects[startIndex + Math.floor(Math.random() * l)];
}
}
return null;
};
GameMath.prototype.floor = /**
* Round down to the next whole number. E.g. floor(1.7) == 1, and floor(-2.7) == -2.
*
* @param Value Any number.
*
* @return The rounded value of that number.
*/
function (Value) {
var n = Value | 0;
return (Value > 0) ? (n) : ((n != Value) ? (n - 1) : (n));
};
GameMath.prototype.ceil = /**
* Round up to the next whole number. E.g. ceil(1.3) == 2, and ceil(-2.3) == -3.
*
* @param Value Any number.
*
* @return The rounded value of that number.
*/
function (Value) {
var n = Value | 0;
return (Value > 0) ? ((n != Value) ? (n + 1) : (n)) : (n);
};
GameMath.prototype.sinCosGenerator = /**
* Generate a sine and cosine table simultaneously and extremely quickly. Based on research by Franky of scene.at
* * The parameters allow you to specify the length, amplitude and frequency of the wave. Once you have called this function * you should get the results via getSinTable() and getCosTable(). This generator is fast enough to be used in real-time. *
* @param length The length of the wave * @param sinAmplitude The amplitude to apply to the sine table (default 1.0) if you need values between say -+ 125 then give 125 as the value * @param cosAmplitude The amplitude to apply to the cosine table (default 1.0) if you need values between say -+ 125 then give 125 as the value * @param frequency The frequency of the sine and cosine table data * @return Returns the sine table * @see getSinTable * @see getCosTable */ function (length, sinAmplitude, cosAmplitude, frequency) { if (typeof sinAmplitude === "undefined") { sinAmplitude = 1.0; } if (typeof cosAmplitude === "undefined") { cosAmplitude = 1.0; } if (typeof frequency === "undefined") { frequency = 1.0; } var sin = sinAmplitude; var cos = cosAmplitude; var frq = frequency * Math.PI / length; this.cosTable = []; this.sinTable = []; for(var c = 0; c < length; c++) { cos -= sin * frq; sin += cos * frq; this.cosTable[c] = cos; this.sinTable[c] = sin; } return this.sinTable; }; GameMath.prototype.shiftSinTable = /** * Shifts through the sin table data by one value and returns it. * This effectively moves the position of the data from the start to the end of the table. * @return The sin value. */ function () { if(this.sinTable) { var s = this.sinTable.shift(); this.sinTable.push(s); return s; } }; GameMath.prototype.shiftCosTable = /** * Shifts through the cos table data by one value and returns it. * This effectively moves the position of the data from the start to the end of the table. * @return The cos value. */ function () { if(this.cosTable) { var s = this.cosTable.shift(); this.cosTable.push(s); return s; } }; GameMath.prototype.vectorLength = /** * Finds the length of the given vector * * @param dx * @param dy * * @return */ function (dx, dy) { return Math.sqrt(dx * dx + dy * dy); }; GameMath.prototype.dotProduct = /** * Finds the dot product value of two vectors * * @param ax Vector X * @param ay Vector Y * @param bx Vector X * @param by Vector Y * * @return Dot product */ function (ax, ay, bx, by) { return ax * bx + ay * by; }; GameMath.prototype.shuffleArray = /** * Shuffles the data in the given array into a new order * @param array The array to shuffle * @return The array */ function (array) { for(var i = array.length - 1; i > 0; i--) { var j = Math.floor(Math.random() * (i + 1)); var temp = array[i]; array[i] = array[j]; array[j] = temp; } return array; }; GameMath.distanceBetween = /** * Returns the distance from this Point object to the given Point object. * @method distanceFrom * @param {Point} target - The destination Point object. * @param {Boolean} round - Round the distance to the nearest integer (default false) * @return {Number} The distance between this Point object and the destination Point object. **/ function distanceBetween(x1, y1, x2, y2) { var dx = x1 - x2; var dy = y1 - y2; return Math.sqrt(dx * dx + dy * dy); }; GameMath.prototype.rotatePoint = /** * Rotates the point around the x/y coordinates given to the desired angle and distance * @param point {Object} Any object with exposed x and y properties * @param x {number} The x coordinate of the anchor point * @param y {number} The y coordinate of the anchor point * @param {Number} angle The angle in radians (unless asDegrees is true) to return the point from. * @param {Boolean} asDegrees Is the given angle in radians (false) or degrees (true)? * @param {Number} distance An optional distance constraint between the point and the anchor * @return The modified point object */ function (point, x1, y1, angle, asDegrees, distance) { if (typeof asDegrees === "undefined") { asDegrees = false; } if (typeof distance === "undefined") { distance = null; } if(asDegrees) { angle = angle * GameMath.DEG_TO_RAD; } // Get distance from origin to the point if(distance === null) { distance = Math.sqrt(((x1 - point.x) * (x1 - point.x)) + ((y1 - point.y) * (y1 - point.y))); } point.x = x1 + distance * Math.cos(angle); point.y = y1 + distance * Math.sin(angle); return point; }; return GameMath; })(); Phaser.GameMath = GameMath; })(Phaser || (Phaser = {})); ///Animation.
*
* @param parent {Sprite} Owner sprite of this animation.
* @param frameData {FrameData} The FrameData object contains animation data.
* @param name {string} Unique name of this animation.
* @param frames {number[]/string[]} An array of numbers or strings indicating what frames to play in what order.
* @param delay {number} Time between frames in ms.
* @param looped {boolean} Whether or not the animation is looped or just plays once.
*/
function Animation(game, parent, frameData, name, frames, delay, looped) {
this._game = game;
this._parent = parent;
this._frames = frames;
this._frameData = frameData;
this.name = name;
this.delay = 1000 / delay;
this.looped = looped;
this.isFinished = false;
this.isPlaying = false;
this._frameIndex = 0;
this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
}
Object.defineProperty(Animation.prototype, "frameTotal", {
get: function () {
return this._frames.length;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Animation.prototype, "frame", {
get: function () {
if(this.currentFrame !== null) {
return this.currentFrame.index;
} else {
return this._frameIndex;
}
},
set: function (value) {
this.currentFrame = this._frameData.getFrame(value);
if(this.currentFrame !== null) {
this._parent.frameBounds.width = this.currentFrame.width;
this._parent.frameBounds.height = this.currentFrame.height;
this._frameIndex = value;
}
},
enumerable: true,
configurable: true
});
Animation.prototype.play = /**
* Play this animation.
* @param frameRate {number} FrameRate you want to specify instead of using default.
* @param loop {boolean} Whether or not the animation is looped or just plays once.
*/
function (frameRate, loop) {
if (typeof frameRate === "undefined") { frameRate = null; }
if(frameRate !== null) {
this.delay = 1000 / frameRate;
}
if(loop !== undefined) {
this.looped = loop;
}
this.isPlaying = true;
this.isFinished = false;
this._timeLastFrame = this._game.time.now;
this._timeNextFrame = this._game.time.now + this.delay;
this._frameIndex = 0;
this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
};
Animation.prototype.restart = /**
* Play this animation from the first frame.
*/
function () {
this.isPlaying = true;
this.isFinished = false;
this._timeLastFrame = this._game.time.now;
this._timeNextFrame = this._game.time.now + this.delay;
this._frameIndex = 0;
this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
};
Animation.prototype.stop = /**
* Stop playing animation and set it finished.
*/
function () {
this.isPlaying = false;
this.isFinished = true;
};
Animation.prototype.update = /**
* Update animation frames.
*/
function () {
if(this.isPlaying == true && this._game.time.now >= this._timeNextFrame) {
this._frameIndex++;
if(this._frameIndex == this._frames.length) {
if(this.looped) {
this._frameIndex = 0;
this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
} else {
this.onComplete();
}
} else {
this.currentFrame = this._frameData.getFrame(this._frames[this._frameIndex]);
}
this._timeLastFrame = this._game.time.now;
this._timeNextFrame = this._game.time.now + this.delay;
return true;
}
return false;
};
Animation.prototype.destroy = /**
* Clean up animation memory.
*/
function () {
this._game = null;
this._parent = null;
this._frames = null;
this._frameData = null;
this.currentFrame = null;
this.isPlaying = false;
};
Animation.prototype.onComplete = /**
* Animation complete callback method.
*/
function () {
this.isPlaying = false;
this.isFinished = true;
// callback goes here
};
return Animation;
})();
Phaser.Animation = Animation;
})(Phaser || (Phaser = {}));
/// Frame with specific position, size and name.
*
* @param x {number} X position within the image to cut from.
* @param y {number} Y position within the image to cut from.
* @param width {number} Width of the frame.
* @param height {number} Height of the frame.
* @param name {string} Name of this frame.
*/
function Frame(x, y, width, height, name) {
/**
* Useful for Texture Atlas files. (is set to the filename value)
*/
this.name = '';
/**
* Rotated? (not yet implemented)
*/
this.rotated = false;
/**
* Either cw or ccw, rotation is always 90 degrees.
*/
this.rotationDirection = 'cw';
this.x = x;
this.y = y;
this.width = width;
this.height = height;
this.name = name;
this.rotated = false;
this.trimmed = false;
}
Frame.prototype.setRotation = /**
* Set rotation of this frame. (Not yet supported!)
*/
function (rotated, rotationDirection) {
// Not yet supported
};
Frame.prototype.setTrim = /**
* Set trim of the frame.
* @param trimmed {boolean} Whether this frame trimmed or not.
* @param actualWidth {number} Actual width of this frame.
* @param actualHeight {number} Actual height of this frame.
* @param destX {number} Destiny x position.
* @param destY {number} Destiny y position.
* @param destWidth {number} Destiny draw width.
* @param destHeight {number} Destiny draw height.
*/
function (trimmed, actualWidth, actualHeight, destX, destY, destWidth, destHeight) {
this.trimmed = trimmed;
this.sourceSizeW = actualWidth;
this.sourceSizeH = actualHeight;
this.spriteSourceSizeX = destX;
this.spriteSourceSizeY = destY;
this.spriteSourceSizeW = destWidth;
this.spriteSourceSizeH = destHeight;
};
return Frame;
})();
Phaser.Frame = Frame;
})(Phaser || (Phaser = {}));
/// AnimationManager.
*
* @param parent {Sprite} Owner sprite of this manager.
*/
function AnimationManager(parent) {
/**
* Data contains animation frames.
* @type {FrameData}
*/
this._frameData = null;
/**
* Keeps track of the current frame of animation.
*/
this.currentFrame = null;
this._parent = parent;
this._game = parent.game;
this._anims = {
};
}
AnimationManager.prototype.loadFrameData = /**
* Load animation frame data.
* @param frameData Data to be loaded.
*/
function (frameData) {
this._frameData = frameData;
this.frame = 0;
};
AnimationManager.prototype.add = /**
* Add a new animation.
* @param name {string} What this animation should be called (e.g. "run").
* @param frames {any[]} An array of numbers/strings indicating what frames to play in what order (e.g. [1, 2, 3] or ['run0', 'run1', run2]).
* @param frameRate {number} The speed in frames per second that the animation should play at (e.g. 60 fps).
* @param loop {boolean} Whether or not the animation is looped or just plays once.
* @param useNumericIndex {boolean} Use number indexes instead of string indexes?
* @return {Animation} The Animation that was created
*/
function (name, frames, frameRate, loop, useNumericIndex) {
if (typeof frames === "undefined") { frames = null; }
if (typeof frameRate === "undefined") { frameRate = 60; }
if (typeof loop === "undefined") { loop = false; }
if (typeof useNumericIndex === "undefined") { useNumericIndex = true; }
if(this._frameData == null) {
return;
}
if(frames == null) {
frames = this._frameData.getFrameIndexes();
} else {
if(this.validateFrames(frames, useNumericIndex) == false) {
throw Error('Invalid frames given to Animation ' + name);
return;
}
}
if(useNumericIndex == false) {
frames = this._frameData.getFrameIndexesByName(frames);
}
this._anims[name] = new Phaser.Animation(this._game, this._parent, this._frameData, name, frames, frameRate, loop);
this.currentAnim = this._anims[name];
this.currentFrame = this.currentAnim.currentFrame;
return this._anims[name];
};
AnimationManager.prototype.validateFrames = /**
* Check whether the frames is valid.
* @param frames {any[]} Frames to be validated.
* @param useNumericIndex {boolean} Does these frames use number indexes or string indexes?
* @return {boolean} True if they're valid, otherwise return false.
*/
function (frames, useNumericIndex) {
for(var i = 0; i < frames.length; i++) {
if(useNumericIndex == true) {
if(frames[i] > this._frameData.total) {
return false;
}
} else {
if(this._frameData.checkFrameName(frames[i]) == false) {
return false;
}
}
}
return true;
};
AnimationManager.prototype.play = /**
* Play animation with specific name.
* @param name {string} The string name of the animation you want to play.
* @param frameRate {number} FrameRate you want to specify instead of using default.
* @param loop {boolean} Whether or not the animation is looped or just plays once.
*/
function (name, frameRate, loop) {
if (typeof frameRate === "undefined") { frameRate = null; }
if(this._anims[name]) {
if(this.currentAnim == this._anims[name]) {
if(this.currentAnim.isPlaying == false) {
this.currentAnim.play(frameRate, loop);
}
} else {
this.currentAnim = this._anims[name];
this.currentAnim.play(frameRate, loop);
}
}
};
AnimationManager.prototype.stop = /**
* Stop animation by name.
* Current animation will be automatically set to the stopped one.
*/
function (name) {
if(this._anims[name]) {
this.currentAnim = this._anims[name];
this.currentAnim.stop();
}
};
AnimationManager.prototype.update = /**
* Update animation and parent sprite's bounds.
*/
function () {
if(this.currentAnim && this.currentAnim.update() == true) {
this.currentFrame = this.currentAnim.currentFrame;
this._parent.frameBounds.width = this.currentFrame.width;
this._parent.frameBounds.height = this.currentFrame.height;
}
};
Object.defineProperty(AnimationManager.prototype, "frameData", {
get: function () {
return this._frameData;
},
enumerable: true,
configurable: true
});
Object.defineProperty(AnimationManager.prototype, "frameTotal", {
get: function () {
if(this._frameData) {
return this._frameData.total;
} else {
return -1;
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(AnimationManager.prototype, "frame", {
get: function () {
return this._frameIndex;
},
set: function (value) {
if(this._frameData.getFrame(value) !== null) {
this.currentFrame = this._frameData.getFrame(value);
this._parent.frameBounds.width = this.currentFrame.width;
this._parent.frameBounds.height = this.currentFrame.height;
this._frameIndex = value;
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(AnimationManager.prototype, "frameName", {
get: function () {
return this.currentFrame.name;
},
set: function (value) {
if(this._frameData.getFrameByName(value) !== null) {
this.currentFrame = this._frameData.getFrameByName(value);
this._parent.frameBounds.width = this.currentFrame.width;
this._parent.frameBounds.height = this.currentFrame.height;
this._frameIndex = this.currentFrame.index;
}
},
enumerable: true,
configurable: true
});
AnimationManager.prototype.destroy = /**
* Removes all related references
*/
function () {
this._anims = {
};
this._frameData = null;
this._frameIndex = 0;
this.currentAnim = null;
this.currentFrame = null;
};
return AnimationManager;
})();
Components.AnimationManager = AnimationManager;
})(Phaser.Components || (Phaser.Components = {}));
var Components = Phaser.Components;
})(Phaser || (Phaser = {}));
/// DynamicTexture.
*
* @param game {Phaser.Game} Current game instance.
* @param width {number} Init width of this texture.
* @param height {number} Init height of this texture.
*/
function DynamicTexture(game, width, height) {
this._sx = 0;
this._sy = 0;
this._sw = 0;
this._sh = 0;
this._dx = 0;
this._dy = 0;
this._dw = 0;
this._dh = 0;
this.game = game;
this.type = Phaser.Types.GEOMSPRITE;
this.canvas = document.createElement('canvas');
this.canvas.width = width;
this.canvas.height = height;
this.context = this.canvas.getContext('2d');
this.bounds = new Phaser.Rectangle(0, 0, width, height);
}
DynamicTexture.prototype.getPixel = /**
* Get a color of a specific pixel.
* @param x {number} X position of the pixel in this texture.
* @param y {number} Y position of the pixel in this texture.
* @return {number} A native color value integer (format: 0xRRGGBB)
*/
function (x, y) {
//r = imageData.data[0];
//g = imageData.data[1];
//b = imageData.data[2];
//a = imageData.data[3];
var imageData = this.context.getImageData(x, y, 1, 1);
return this.getColor(imageData.data[0], imageData.data[1], imageData.data[2]);
};
DynamicTexture.prototype.getPixel32 = /**
* Get a color of a specific pixel (including alpha value).
* @param x {number} X position of the pixel in this texture.
* @param y {number} Y position of the pixel in this texture.
* @return A native color value integer (format: 0xAARRGGBB)
*/
function (x, y) {
var imageData = this.context.getImageData(x, y, 1, 1);
return this.getColor32(imageData.data[3], imageData.data[0], imageData.data[1], imageData.data[2]);
};
DynamicTexture.prototype.getPixels = /**
* Get pixels in array in a specific rectangle.
* @param rect {Rectangle} The specific rectangle.
* @returns {array} CanvasPixelArray.
*/
function (rect) {
return this.context.getImageData(rect.x, rect.y, rect.width, rect.height);
};
DynamicTexture.prototype.setPixel = /**
* Set color of a specific pixel.
* @param x {number} X position of the target pixel.
* @param y {number} Y position of the target pixel.
* @param color {number} Native integer with color value. (format: 0xRRGGBB)
*/
function (x, y, color) {
this.context.fillStyle = color;
this.context.fillRect(x, y, 1, 1);
};
DynamicTexture.prototype.setPixel32 = /**
* Set color (with alpha) of a specific pixel.
* @param x {number} X position of the target pixel.
* @param y {number} Y position of the target pixel.
* @param color {number} Native integer with color value. (format: 0xAARRGGBB)
*/
function (x, y, color) {
this.context.fillStyle = color;
this.context.fillRect(x, y, 1, 1);
};
DynamicTexture.prototype.setPixels = /**
* Set image data to a specific rectangle.
* @param rect {Rectangle} Target rectangle.
* @param input {object} Source image data.
*/
function (rect, input) {
this.context.putImageData(input, rect.x, rect.y);
};
DynamicTexture.prototype.fillRect = /**
* Fill a given rectangle with specific color.
* @param rect {Rectangle} Target rectangle you want to fill.
* @param color {number} A native number with color value. (format: 0xRRGGBB)
*/
function (rect, color) {
this.context.fillStyle = color;
this.context.fillRect(rect.x, rect.y, rect.width, rect.height);
};
DynamicTexture.prototype.pasteImage = /**
*
*/
function (key, frame, destX, destY, destWidth, destHeight) {
if (typeof frame === "undefined") { frame = -1; }
if (typeof destX === "undefined") { destX = 0; }
if (typeof destY === "undefined") { destY = 0; }
if (typeof destWidth === "undefined") { destWidth = null; }
if (typeof destHeight === "undefined") { destHeight = null; }
var texture = null;
var frameData;
this._sx = 0;
this._sy = 0;
this._dx = destX;
this._dy = destY;
// TODO - Load a frame from a sprite sheet, otherwise we'll draw the whole lot
if(frame > -1) {
//if (this.game.cache.isSpriteSheet(key))
//{
// texture = this.game.cache.getImage(key);
//this.animations.loadFrameData(this.game.cache.getFrameData(key));
//}
} else {
texture = this.game.cache.getImage(key);
this._sw = texture.width;
this._sh = texture.height;
this._dw = texture.width;
this._dh = texture.height;
}
if(destWidth !== null) {
this._dw = destWidth;
}
if(destHeight !== null) {
this._dh = destHeight;
}
if(texture != null) {
this.context.drawImage(texture, // Source Image
this._sx, // Source X (location within the source image)
this._sy, // Source Y
this._sw, // Source Width
this._sh, // Source Height
this._dx, // Destination X (where on the canvas it'll be drawn)
this._dy, // Destination Y
this._dw, // Destination Width (always same as Source Width unless scaled)
this._dh);
// Destination Height (always same as Source Height unless scaled)
}
};
DynamicTexture.prototype.copyPixels = // TODO - Add in support for: alphaBitmapData: BitmapData = null, alphaPoint: Point = null, mergeAlpha: bool = false
/**
* Copy pixel from another DynamicTexture to this texture.
* @param sourceTexture {DynamicTexture} Source texture object.
* @param sourceRect {Rectangle} The specific region rectangle to be copied to this in the source.
* @param destPoint {Point} Top-left point the target image data will be paste at.
*/
function (sourceTexture, sourceRect, destPoint) {
// Swap for drawImage if the sourceRect is the same size as the sourceTexture to avoid a costly getImageData call
if(Phaser.RectangleUtils.equals(sourceRect, this.bounds) == true) {
this.context.drawImage(sourceTexture.canvas, destPoint.x, destPoint.y);
} else {
this.context.putImageData(sourceTexture.getPixels(sourceRect), destPoint.x, destPoint.y);
}
};
DynamicTexture.prototype.assignCanvasToGameObjects = /**
* Given an array of Sprites it will update each of them so that their canvas/contexts reference this DynamicTexture
* @param objects {Array} An array of GameObjects, or objects that inherit from it such as Sprites
*/
function (objects) {
for(var i = 0; i < objects.length; i++) {
objects[i].texture.canvas = this.canvas;
objects[i].texture.context = this.context;
}
};
DynamicTexture.prototype.clear = /**
* Clear the whole canvas.
*/
function () {
this.context.clearRect(0, 0, this.bounds.width, this.bounds.height);
};
DynamicTexture.prototype.render = /**
* Renders this DynamicTexture to the Stage at the given x/y coordinates
*
* @param x {number} The X coordinate to render on the stage to (given in screen coordinates, not world)
* @param y {number} The Y coordinate to render on the stage to (given in screen coordinates, not world)
*/
function (x, y) {
if (typeof x === "undefined") { x = 0; }
if (typeof y === "undefined") { y = 0; }
this.game.stage.context.drawImage(this.canvas, x, y);
};
Object.defineProperty(DynamicTexture.prototype, "width", {
get: function () {
return this.bounds.width;
},
enumerable: true,
configurable: true
});
Object.defineProperty(DynamicTexture.prototype, "height", {
get: function () {
return this.bounds.height;
},
enumerable: true,
configurable: true
});
DynamicTexture.prototype.getColor32 = /**
* Given an alpha and 3 color values this will return an integer representation of it
*
* @param alpha {number} The Alpha value (between 0 and 255)
* @param red {number} The Red channel value (between 0 and 255)
* @param green {number} The Green channel value (between 0 and 255)
* @param blue {number} The Blue channel value (between 0 and 255)
*
* @return A native color value integer (format: 0xAARRGGBB)
*/
function (alpha, red, green, blue) {
return alpha << 24 | red << 16 | green << 8 | blue;
};
DynamicTexture.prototype.getColor = /**
* Given 3 color values this will return an integer representation of it
*
* @param red {number} The Red channel value (between 0 and 255)
* @param green {number} The Green channel value (between 0 and 255)
* @param blue {number} The Blue channel value (between 0 and 255)
*
* @return A native color value integer (format: 0xRRGGBB)
*/
function (red, green, blue) {
return red << 16 | green << 8 | blue;
};
return DynamicTexture;
})();
Phaser.DynamicTexture = DynamicTexture;
})(Phaser || (Phaser = {}));
/// GameObject overlaps this GameObject or Group.
* If the group has a LOT of things in it, it might be faster to use Collision.overlaps().
* WARNING: Currently tilemaps do NOT support screen space overlap checks!
*
* @param objectOrGroup {object} The object or group being tested.
* @param inScreenSpace {boolean} Whether to take scroll factors numbero account when checking for overlap. Default is false, or "only compare in world space."
* @param camera {Camera} Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
*
* @return {boolean} Whether or not the objects overlap this.
*/
/*
static overlaps(objectOrGroup, inScreenSpace: bool = false, camera: Camera = null): bool {
if (objectOrGroup.isGroup)
{
var results: bool = false;
var i: number = 0;
var members = GameObject were located at the given position, would it overlap the GameObject or Group?
* This is distinct from overlapsPoint(), which just checks that point, rather than taking the object's size numbero account.
* WARNING: Currently tilemaps do NOT support screen space overlap checks!
*
* @param X {number} The X position you want to check. Pretends this object (the caller, not the parameter) is located here.
* @param Y {number} The Y position you want to check. Pretends this object (the caller, not the parameter) is located here.
* @param objectOrGroup {object} The object or group being tested.
* @param inScreenSpace {boolean} Whether to take scroll factors numbero account when checking for overlap. Default is false, or "only compare in world space."
* @param camera {Camera} Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
*
* @return {boolean} Whether or not the two objects overlap.
*/
/*
static overlapsAt(X: number, Y: number, objectOrGroup, inScreenSpace: bool = false, camera: Camera = null): bool {
if (objectOrGroup.isGroup)
{
var results: bool = false;
var basic;
var i: number = 0;
var members = objectOrGroup.members;
while (i < length)
{
if (this.overlapsAt(X, Y, members[i++], inScreenSpace, camera))
{
results = true;
}
}
return results;
}
if (!inScreenSpace)
{
return (objectOrGroup.x + objectOrGroup.width > X) && (objectOrGroup.x < X + this.width) &&
(objectOrGroup.y + objectOrGroup.height > Y) && (objectOrGroup.y < Y + this.height);
}
if (camera == null)
{
camera = this._game.camera;
}
var objectScreenPos: Point = objectOrGroup.getScreenXY(null, Camera);
this._point.x = X - camera.scroll.x * this.scrollFactor.x; //copied from getScreenXY()
this._point.y = Y - camera.scroll.y * this.scrollFactor.y;
this._point.x += (this._point.x > 0) ? 0.0000001 : -0.0000001;
this._point.y += (this._point.y > 0) ? 0.0000001 : -0.0000001;
return (objectScreenPos.x + objectOrGroup.width > this._point.x) && (objectScreenPos.x < this._point.x + this.width) &&
(objectScreenPos.y + objectOrGroup.height > this._point.y) && (objectScreenPos.y < this._point.y + this.height);
}
*/
/**
* Checks to see if a point in 2D world space overlaps this GameObject.
*
* @param point {Point} The point in world space you want to check.
* @param inScreenSpace {boolean} Whether to take scroll factors into account when checking for overlap.
* @param camera {Camera} Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
*
* @return Whether or not the point overlaps this object.
*/
/*
static overlapsPoint(point: Point, inScreenSpace: bool = false, camera: Camera = null): bool {
if (!inScreenSpace)
{
return (point.x > this.x) && (point.x < this.x + this.width) && (point.y > this.y) && (point.y < this.y + this.height);
}
if (camera == null)
{
camera = this._game.camera;
}
var X: number = point.x - camera.scroll.x;
var Y: number = point.y - camera.scroll.y;
this.getScreenXY(this._point, camera);
return (X > this._point.x) && (X < this._point.x + this.width) && (Y > this._point.y) && (Y < this._point.y + this.height);
}
*/
/**
* Check and see if this object is currently on screen.
*
* @param camera {Camera} Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
*
* @return {boolean} Whether the object is on screen or not.
*/
/*
static onScreen(camera: Camera = null): bool {
if (camera == null)
{
camera = this._game.camera;
}
this.getScreenXY(this._point, camera);
return (this._point.x + this.width > 0) && (this._point.x < camera.width) && (this._point.y + this.height > 0) && (this._point.y < camera.height);
}
*/
/**
* Call this to figure out the on-screen position of the object.
*
* @param point {Point} Takes a MicroPoint object and assigns the post-scrolled X and Y values of this object to it.
* @param camera {Camera} Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
*
* @return {MicroPoint} The MicroPoint you passed in, or a new Point if you didn't pass one, containing the screen X and Y position of this object.
*/
/*
static getScreenXY(point: MicroPoint = null, camera: Camera = null): MicroPoint {
if (point == null)
{
point = new MicroPoint();
}
if (camera == null)
{
camera = this._game.camera;
}
point.x = this.x - camera.scroll.x * this.scrollFactor.x;
point.y = this.y - camera.scroll.y * this.scrollFactor.y;
point.x += (point.x > 0) ? 0.0000001 : -0.0000001;
point.y += (point.y > 0) ? 0.0000001 : -0.0000001;
return point;
}
*/
/**
* Set the world bounds that this GameObject can exist within based on the size of the current game world.
*
* @param action {number} The action to take if the object hits the world bounds, either OUT_OF_BOUNDS_KILL or OUT_OF_BOUNDS_STOP
*/
/*
static setBoundsFromWorld(action?: number = GameObject.OUT_OF_BOUNDS_STOP) {
this.setBounds(this._game.world.bounds.x, this._game.world.bounds.y, this._game.world.bounds.width, this._game.world.bounds.height);
this.outOfBoundsAction = action;
}
*/
/**
* Check whether this object is visible in a specific camera rectangle.
* @param camera {Rectangle} The rectangle you want to check.
* @return {boolean} Return true if bounds of this sprite intersects the given rectangle, otherwise return false.
*/
/*
static inCamera(camera: Rectangle, cameraOffsetX: number, cameraOffsetY: number): bool {
// Object fixed in place regardless of the camera scrolling? Then it's always visible
if (this.scrollFactor.x == 0 && this.scrollFactor.y == 0)
{
return true;
}
this._dx = (this.frameBounds.x - camera.x);
this._dy = (this.frameBounds.y - camera.y);
this._dw = this.frameBounds.width * this.scale.x;
this._dh = this.frameBounds.height * this.scale.y;
return (camera.right > this._dx) && (camera.x < this._dx + this._dw) && (camera.bottom > this._dy) && (camera.y < this._dy + this._dh);
}
*/
/**
* Handy for reviving game objects.
* Resets their existence flags and position.
*
* @param x {number} The new X position of this object.
* @param y {number} The new Y position of this object.
*/
/*
static reset(x: number, y: number) {
this.revive();
this.touching = Collision.NONE;
this.wasTouching = Collision.NONE;
this.x = x;
this.y = y;
this.last.x = x;
this.last.y = y;
this.velocity.x = 0;
this.velocity.y = 0;
}
*/
/**
* Set the world bounds that this GameObject can exist within. By default a GameObject can exist anywhere
* in the world. But by setting the bounds (which are given in world dimensions, not screen dimensions)
* it can be stopped from leaving the world, or a section of it.
*
* @param x {number} x position of the bound
* @param y {number} y position of the bound
* @param width {number} width of its bound
* @param height {number} height of its bound
*/
function setBounds(x, y, width, height) {
//this.worldBounds = new Quad(x, y, width, height);
};
return SpriteUtils;
})();
Phaser.SpriteUtils = SpriteUtils;
/**
* This function creates a flat colored square image dynamically.
* @param width {number} The width of the sprite you want to generate.
* @param height {number} The height of the sprite you want to generate.
* @param [color] {number} specifies the color of the generated block. (format is 0xAARRGGBB)
* @return {Sprite} Sprite instance itself.
*/
/*
static makeGraphic(width: number, height: number, color: string = 'rgb(255,255,255)'): Sprite {
this._texture = null;
this.width = width;
this.height = height;
this.fillColor = color;
this._dynamicTexture = false;
return this;
}
*/
})(Phaser || (Phaser = {}));
var Phaser;
(function (Phaser) {
/// Sprite.
*
* @param game {Phaser.Game} Current game instance.
* @param [x] {number} the initial x position of the sprite.
* @param [y] {number} the initial y position of the sprite.
* @param [key] {string} Key of the graphic you want to load for this sprite.
* @param [width] {number} The width of the object.
* @param [height] {number} The height of the object.
*/
function Sprite(game, x, y, key, width, height) {
if (typeof x === "undefined") { x = 0; }
if (typeof y === "undefined") { y = 0; }
if (typeof key === "undefined") { key = null; }
if (typeof width === "undefined") { width = 16; }
if (typeof height === "undefined") { height = 16; }
/**
* Rotation angle of this object.
* @type {number}
*/
this._rotation = 0;
/**
* A boolean representing if the Sprite has been modified in any way via a scale, rotate, flip or skew.
*/
this.modified = false;
/**
* x value of the object.
*/
this.x = 0;
/**
* y value of the object.
*/
this.y = 0;
/**
* z order value of the object.
*/
this.z = 0;
/**
* This value is added to the rotation of the Sprite.
* For example if you had a sprite graphic drawn facing straight up then you could set
* rotationOffset to 90 and it would correspond correctly with Phasers right-handed coordinate system.
* @type {number}
*/
this.rotationOffset = 0;
this.game = game;
this.type = Phaser.Types.SPRITE;
this.render = game.renderer.renderSprite;
this.exists = true;
this.active = true;
this.visible = true;
this.alive = true;
this.frameBounds = new Phaser.Rectangle(x, y, width, height);
this.scrollFactor = new Phaser.Vec2(1, 1);
this.x = x;
this.y = y;
this.z = 0// not used yet
;
this.animations = new Phaser.Components.AnimationManager(this);
this.texture = new Phaser.Components.Texture(this, key);
// Transform related (if we add any more then move to a component)
this.origin = new Phaser.Vec2(0, 0);
this.scale = new Phaser.Vec2(1, 1);
this.skew = new Phaser.Vec2(0, 0);
this.physics = new Phaser.Components.Physics(this);
this.physics.shape.physics = this.physics;
}
Object.defineProperty(Sprite.prototype, "rotation", {
get: /**
* The rotation of the sprite in degrees. Phaser uses a right-handed coordinate system, where 0 points to the right.
*/
function () {
return this._rotation;
},
set: /**
* Set the rotation of the sprite in degrees. Phaser uses a right-handed coordinate system, where 0 points to the right.
* The value is automatically wrapped to be between 0 and 360.
*/
function (value) {
this._rotation = this.game.math.wrap(value, 360, 0);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Sprite.prototype, "frame", {
get: /**
* Get the animation frame number.
*/
function () {
return this.animations.frame;
},
set: /**
* Set the animation frame by frame number.
*/
function (value) {
this.animations.frame = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Sprite.prototype, "frameName", {
get: /**
* Get the animation frame name.
*/
function () {
return this.animations.frameName;
},
set: /**
* Set the animation frame by frame name.
*/
function (value) {
this.animations.frameName = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Sprite.prototype, "width", {
get: function () {
return this.frameBounds.width;
},
set: function (value) {
this.frameBounds.width = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Sprite.prototype, "height", {
get: function () {
return this.frameBounds.height;
},
set: function (value) {
this.frameBounds.height = value;
},
enumerable: true,
configurable: true
});
Sprite.prototype.preUpdate = /**
* Pre-update is called right before update() on each object in the game loop.
*/
function () {
this.frameBounds.x = this.x;
this.frameBounds.y = this.y;
if(this.modified == false && (!this.scale.equals(1) || !this.skew.equals(0) || this.rotation != 0 || this.rotationOffset != 0 || this.texture.flippedX || this.texture.flippedY)) {
this.modified = true;
}
};
Sprite.prototype.update = /**
* Override this function to update your class's position and appearance.
*/
function () {
};
Sprite.prototype.postUpdate = /**
* Automatically called after update() by the game loop.
*/
function () {
this.animations.update();
this.physics.update();
/*
if (this.worldBounds != null)
{
if (this.outOfBoundsAction == GameObject.OUT_OF_BOUNDS_KILL)
{
if (this.x < this.worldBounds.x || this.x > this.worldBounds.right || this.y < this.worldBounds.y || this.y > this.worldBounds.bottom)
{
this.kill();
}
}
else
{
if (this.x < this.worldBounds.x)
{
this.x = this.worldBounds.x;
}
else if (this.x > this.worldBounds.right)
{
this.x = this.worldBounds.right;
}
if (this.y < this.worldBounds.y)
{
this.y = this.worldBounds.y;
}
else if (this.y > this.worldBounds.bottom)
{
this.y = this.worldBounds.bottom;
}
}
}
this.collisionMask.update();
if (this.inputEnabled)
{
this.updateInput();
}
this.wasTouching = this.touching;
this.touching = Collision.NONE;
*/
if(this.modified == true && this.scale.equals(1) && this.skew.equals(0) && this.rotation == 0 && this.rotationOffset == 0 && this.texture.flippedX == false && this.texture.flippedY == false) {
this.modified = false;
}
};
Sprite.prototype.destroy = /**
* Clean up memory.
*/
function () {
};
return Sprite;
})();
Phaser.Sprite = Sprite;
})(Phaser || (Phaser = {}));
/// Camera with position and size.
*
* @param x {number} X Position of the created camera.
* @param y {number} y Position of the created camera.
* @param width {number} Width of the created camera.
* @param height {number} Height of the created camera.
*/
function CameraManager(game, x, y, width, height) {
/**
* Local helper stores index of next created camera.
*/
this._cameraInstance = 0;
this._game = game;
this._cameras = [];
this.current = this.addCamera(x, y, width, height);
}
CameraManager.CAMERA_TYPE_ORTHOGRAPHIC = 0;
CameraManager.CAMERA_TYPE_ISOMETRIC = 1;
CameraManager.prototype.getAll = /**
* Get all the cameras.
*
* @returns {Camera[]} An array contains all the cameras.
*/
function () {
return this._cameras;
};
CameraManager.prototype.update = /**
* Update cameras.
*/
function () {
this._cameras.forEach(function (camera) {
return camera.update();
});
};
CameraManager.prototype.addCamera = /**
* Create a new camera with specific position and size.
*
* @param x {number} X position of the new camera.
* @param y {number} Y position of the new camera.
* @param width {number} Width of the new camera.
* @param height {number} Height of the new camera.
* @returns {Camera} The newly created camera object.
*/
function (x, y, width, height, type) {
if (typeof type === "undefined") { type = CameraManager.CAMERA_TYPE_ORTHOGRAPHIC; }
var newCam = new Phaser.Camera(this._game, this._cameraInstance, x, y, width, height);
this._cameras.push(newCam);
this._cameraInstance++;
return newCam;
};
CameraManager.prototype.removeCamera = /**
* Remove a new camera with its id.
*
* @param id {number} ID of the camera you want to remove.
* @returns {boolean} True if successfully removed the camera, otherwise return false.
*/
function (id) {
for(var c = 0; c < this._cameras.length; c++) {
if(this._cameras[c].ID == id) {
if(this.current.ID === this._cameras[c].ID) {
this.current = null;
}
this._cameras.splice(c, 1);
return true;
}
}
return false;
};
CameraManager.prototype.destroy = /**
* Clean up memory.
*/
function () {
this._cameras.length = 0;
this.current = this.addCamera(0, 0, this._game.stage.width, this._game.stage.height);
};
return CameraManager;
})();
Phaser.CameraManager = CameraManager;
})(Phaser || (Phaser = {}));
var Phaser;
(function (Phaser) {
/// Tween.
*
* @param object {object} Target object will be affected by this tween.
* @param game {Phaser.Game} Current game instance.
*/
function Tween(object, game) {
/**
* Reference to the target object.
* @type {object}
*/
this._object = null;
this._pausedTime = 0;
/**
* Start values container.
* @type {object}
*/
this._valuesStart = {
};
/**
* End values container.
* @type {object}
*/
this._valuesEnd = {
};
/**
* How long this tween will perform.
* @type {number}
*/
this._duration = 1000;
this._delayTime = 0;
this._startTime = null;
/**
* Will this tween automatically restart when it completes?
* @type {boolean}
*/
this._loop = false;
/**
* A yoyo tween is one that plays once fully, then reverses back to the original tween values before completing.
* @type {boolean}
*/
this._yoyo = false;
this._yoyoCount = 0;
/**
* Contains chained tweens.
* @type {Tweens[]}
*/
this._chainedTweens = [];
this._object = object;
this._game = game;
this._manager = this._game.tweens;
this._interpolationFunction = this._game.math.linearInterpolation;
this._easingFunction = Phaser.Easing.Linear.None;
this._chainedTweens = [];
this.onStart = new Phaser.Signal();
this.onUpdate = new Phaser.Signal();
this.onComplete = new Phaser.Signal();
}
Tween.prototype.to = /**
* Configure the Tween
* @param properties {object} Propertis you want to tween.
* @param [duration] {number} duration of this tween.
* @param [ease] {any} Easing function.
* @param [autoStart] {boolean} Whether this tween will start automatically or not.
* @param [delay] {number} delay before this tween will start, defaults to 0 (no delay)
* @param [loop] {boolean} Should the tween automatically restart once complete? (ignores any chained tweens)
* @return {Tween} Itself.
*/
function (properties, duration, ease, autoStart, delay, loop, yoyo) {
if (typeof duration === "undefined") { duration = 1000; }
if (typeof ease === "undefined") { ease = null; }
if (typeof autoStart === "undefined") { autoStart = false; }
if (typeof delay === "undefined") { delay = 0; }
if (typeof loop === "undefined") { loop = false; }
if (typeof yoyo === "undefined") { yoyo = false; }
this._duration = duration;
// If properties isn't an object this will fail, sanity check it here somehow?
this._valuesEnd = properties;
if(ease !== null) {
this._easingFunction = ease;
}
if(delay > 0) {
this._delayTime = delay;
}
this._loop = loop;
this._yoyo = yoyo;
this._yoyoCount = 0;
if(autoStart === true) {
return this.start();
} else {
return this;
}
};
Tween.prototype.loop = function (value) {
this._loop = value;
return this;
};
Tween.prototype.yoyo = function (value) {
this._yoyo = value;
this._yoyoCount = 0;
return this;
};
Tween.prototype.start = /**
* Start to tween.
*/
function (looped) {
if (typeof looped === "undefined") { looped = false; }
if(this._game === null || this._object === null) {
return;
}
if(looped == false) {
this._manager.add(this);
this.onStart.dispatch(this._object);
}
this._startTime = this._game.time.now + this._delayTime;
for(var property in this._valuesEnd) {
// This prevents the interpolation of null values or of non-existing properties
if(this._object[property] === null || !(property in this._object)) {
throw Error('Phaser.Tween interpolation of null value of non-existing property');
continue;
}
// check if an Array was provided as property value
if(this._valuesEnd[property] instanceof Array) {
if(this._valuesEnd[property].length === 0) {
continue;
}
// create a local copy of the Array with the start value at the front
this._valuesEnd[property] = [
this._object[property]
].concat(this._valuesEnd[property]);
}
if(looped == false) {
this._valuesStart[property] = this._object[property];
}
}
return this;
};
Tween.prototype.reverse = function () {
var tempObj = {
};
for(var property in this._valuesStart) {
tempObj[property] = this._valuesStart[property];
this._valuesStart[property] = this._valuesEnd[property];
this._valuesEnd[property] = tempObj[property];
}
this._yoyoCount++;
return this.start(true);
};
Tween.prototype.reset = function () {
// Reset the properties back to what they were before
for(var property in this._valuesStart) {
this._object[property] = this._valuesStart[property];
}
return this.start(true);
};
Tween.prototype.clear = function () {
this._chainedTweens = [];
this.onStart.removeAll();
this.onUpdate.removeAll();
this.onComplete.removeAll();
return this;
};
Tween.prototype.stop = /**
* Stop tweening.
*/
function () {
if(this._manager !== null) {
this._manager.remove(this);
}
this.onComplete.dispose();
return this;
};
Object.defineProperty(Tween.prototype, "parent", {
set: function (value) {
this._game = value;
this._manager = this._game.tweens;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Tween.prototype, "delay", {
get: function () {
return this._delayTime;
},
set: function (amount) {
this._delayTime = amount;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Tween.prototype, "easing", {
get: function () {
return this._easingFunction;
},
set: function (easing) {
this._easingFunction = easing;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Tween.prototype, "interpolation", {
get: function () {
return this._interpolationFunction;
},
set: function (interpolation) {
this._interpolationFunction = interpolation;
},
enumerable: true,
configurable: true
});
Tween.prototype.chain = /**
* Add another chained tween, which will start automatically when the one before it completes.
* @param tween {Phaser.Tween} Tween object you want to chain with this.
* @return {Phaser.Tween} Itselfe.
*/
function (tween) {
this._chainedTweens.push(tween);
return this;
};
Tween.prototype.update = /**
* Update tweening.
* @param time {number} Current time from game clock.
* @return {boolean} Return false if this completed and no need to update, otherwise return true.
*/
function (time) {
if(this._game.paused == true) {
if(this._pausedTime == 0) {
this._pausedTime = time;
}
} else {
// Ok we aren't paused, but was there some time gained?
if(this._pausedTime > 0) {
this._startTime += (time - this._pausedTime);
this._pausedTime = 0;
}
}
if(time < this._startTime) {
return true;
}
this._tempElapsed = (time - this._startTime) / this._duration;
this._tempElapsed = this._tempElapsed > 1 ? 1 : this._tempElapsed;
this._tempValue = this._easingFunction(this._tempElapsed);
for(var property in this._valuesStart) {
// Add checks for object, array, numeric up front
if(this._valuesEnd[property] instanceof Array) {
this._object[property] = this._interpolationFunction(this._valuesEnd[property], this._tempValue);
} else {
this._object[property] = this._valuesStart[property] + (this._valuesEnd[property] - this._valuesStart[property]) * this._tempValue;
}
}
this.onUpdate.dispatch(this._object, this._tempValue);
if(this._tempElapsed == 1) {
// Yoyo?
if(this._yoyo) {
if(this._yoyoCount == 0) {
// Reverse the tween
this.reverse();
return true;
} else {
// We've yoyo'd once already, quit?
if(this._loop == false) {
this.onComplete.dispatch(this._object);
for(var i = 0; i < this._chainedTweens.length; i++) {
this._chainedTweens[i].start();
}
return false;
}
}
}
// Loop?
if(this._loop) {
this._yoyoCount = 0;
this.reset();
return true;
} else {
this.onComplete.dispatch(this._object);
for(var i = 0; i < this._chainedTweens.length; i++) {
this._chainedTweens[i].start();
}
return false;
}
}
return true;
};
return Tween;
})();
Phaser.Tween = Tween;
})(Phaser || (Phaser = {}));
/// Basic subclass (Basic, GameObject, Sprite, etc) to the group.
* Group will try to replace a null member of the array first.
* Failing that, Group will add it to the end of the member array,
* assuming there is room for it, and doubling the size of the array if necessary.
*
* WARNING: If the group has a maxSize that has already been met, * the object will NOT be added to the group!
* * @param {Basic} Object The object you want to add to the group. * @return {Basic} The sameBasic object that was passed in.
*/
function (object) {
//Don't bother adding an object twice.
if(this.members.indexOf(Object) >= 0) {
return object;
}
//First, look for a null entry where we can add the object.
this._i = 0;
this._length = this.members.length;
while(this._i < this._length) {
if(this.members[this._i] == null) {
this.members[this._i] = object;
if(this._i >= this.length) {
this.length = this._i + 1;
}
return object;
}
this._i++;
}
//Failing that, expand the array (if we can) and add the object.
if(this._maxSize > 0) {
if(this.members.length >= this._maxSize) {
return object;
} else if(this.members.length * 2 <= this._maxSize) {
this.members.length *= 2;
} else {
this.members.length = this._maxSize;
}
} else {
this.members.length *= 2;
}
//If we made it this far, then we successfully grew the group,
//and we can go ahead and add the object at the first open slot.
this.members[this._i] = object;
this.length = this._i + 1;
return object;
};
Group.prototype.recycle = /**
* Recycling is designed to help you reuse game objects without always re-allocating or "newing" them.
*
* If you specified a maximum size for this group (like in Emitter), * then recycle will employ what we're calling "rotating" recycling. * Recycle() will first check to see if the group is at capacity yet. * If group is not yet at capacity, recycle() returns a new object. * If the group IS at capacity, then recycle() just returns the next object in line.
* *If you did NOT specify a maximum size for this group, * then recycle() will employ what we're calling "grow-style" recycling. * Recycle() will return either the first object with exists == false, * or, finding none, add a new object to the array, * doubling the size of the array if necessary.
* *WARNING: If this function needs to create a new object, * and no object class was provided, it will return null * instead of a valid object!
* * @param {class} ObjectClass The class type you want to recycle (e.g. Basic, EvilRobot, etc). Do NOT "new" the class in the parameter! * * @return {any} A reference to the object that was created. Don't forget to cast it back to the Class you want (e.g. myObject = myGroup.recycle(myObjectClass) as myObjectClass;). */ function (objectClass) { if (typeof objectClass === "undefined") { objectClass = null; } if(this._maxSize > 0) { if(this.length < this._maxSize) { if(objectClass == null) { return null; } return this.add(new objectClass(this.game)); } else { this._member = this.members[this._marker++]; if(this._marker >= this._maxSize) { this._marker = 0; } return this._member; } } else { this._member = this.getFirstAvailable(objectClass); if(this._member != null) { return this._member; } if(objectClass == null) { return null; } return this.add(new objectClass(this.game)); } }; Group.prototype.remove = /** * Removes an object from the group. * * @param {Basic} object TheBasic you want to remove.
* @param {boolean} splice Whether the object should be cut from the array entirely or not.
*
* @return {Basic} The removed object.
*/
function (object, splice) {
if (typeof splice === "undefined") { splice = false; }
this._i = this.members.indexOf(object);
if(this._i < 0 || (this._i >= this.members.length)) {
return null;
}
if(splice) {
this.members.splice(this._i, 1);
this.length--;
} else {
this.members[this._i] = null;
}
return object;
};
Group.prototype.replace = /**
* Replaces an existing Basic with a new one.
*
* @param {Basic} oldObject The object you want to replace.
* @param {Basic} newObject The new object you want to use instead.
*
* @return {Basic} The new object.
*/
function (oldObject, newObject) {
this._i = this.members.indexOf(oldObject);
if(this._i < 0 || (this._i >= this.members.length)) {
return null;
}
this.members[this._i] = newObject;
return newObject;
};
Group.prototype.sort = /**
* Call this function to sort the group according to a particular value and order.
* For example, to sort game objects for Zelda-style overlaps you might call
* myGroup.sort("y",Group.ASCENDING) at the bottom of your
* State.update() override. To sort all existing objects after
* a big explosion or bomb attack, you might call myGroup.sort("exists",Group.DESCENDING).
*
* @param {string} index The string name of the member variable you want to sort on. Default value is "y".
* @param {number} order A Group constant that defines the sort order. Possible values are Group.ASCENDING and Group.DESCENDING. Default value is Group.ASCENDING.
*/
function (index, order) {
if (typeof index === "undefined") { index = "y"; }
if (typeof order === "undefined") { order = Group.ASCENDING; }
this._sortIndex = index;
this._sortOrder = order;
this.members.sort(this.sortHandler);
};
Group.prototype.setAll = /**
* Go through and set the specified variable to the specified value on all members of the group.
*
* @param {string} VariableName The string representation of the variable name you want to modify, for example "visible" or "scrollFactor".
* @param {Object} Value The value you want to assign to that variable.
* @param {boolean} Recurse Default value is true, meaning if setAll() encounters a member that is a group, it will call setAll() on that group rather than modifying its variable.
*/
function (variableName, value, recurse) {
if (typeof recurse === "undefined") { recurse = true; }
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if(this._member != null) {
if(recurse && this._member.type == Phaser.Types.GROUP) {
this._member.setAll(variableName, value, recurse);
} else {
this._member[variableName] = value;
}
}
}
};
Group.prototype.callAll = /**
* Go through and call the specified function on all members of the group.
* Currently only works on functions that have no required parameters.
*
* @param {string} FunctionName The string representation of the function you want to call on each object, for example "kill()" or "init()".
* @param {boolean} Recurse Default value is true, meaning if callAll() encounters a member that is a group, it will call callAll() on that group rather than calling the group's function.
*/
function (functionName, recurse) {
if (typeof recurse === "undefined") { recurse = true; }
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if(this._member != null) {
if(recurse && this._member.type == Phaser.Types.GROUP) {
this._member.callAll(functionName, recurse);
} else {
this._member[functionName]();
}
}
}
};
Group.prototype.forEach = /**
* @param {function} callback
* @param {boolean} recursive
*/
function (callback, recursive) {
if (typeof recursive === "undefined") { recursive = false; }
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if(this._member != null) {
if(recursive && this._member.type == Phaser.Types.GROUP) {
this._member.forEach(callback, true);
} else {
callback.call(this, this._member);
}
}
}
};
Group.prototype.forEachAlive = /**
* @param {any} context
* @param {function} callback
* @param {boolean} recursive
*/
function (context, callback, recursive) {
if (typeof recursive === "undefined") { recursive = false; }
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if(this._member != null && this._member.alive) {
if(recursive && this._member.type == Phaser.Types.GROUP) {
this._member.forEachAlive(context, callback, true);
} else {
callback.call(context, this._member);
}
}
}
};
Group.prototype.getFirstAvailable = /**
* Call this function to retrieve the first object with exists == false in the group.
* This is handy for recycling in general, e.g. respawning enemies.
*
* @param {any} [ObjectClass] An optional parameter that lets you narrow the results to instances of this particular class.
*
* @return {any} A Basic currently flagged as not existing.
*/
function (objectClass) {
if (typeof objectClass === "undefined") { objectClass = null; }
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if((this._member != null) && !this._member.exists && ((objectClass == null) || (typeof this._member === objectClass))) {
return this._member;
}
}
return null;
};
Group.prototype.getFirstNull = /**
* Call this function to retrieve the first index set to 'null'.
* Returns -1 if no index stores a null object.
*
* @return {number} An int indicating the first null slot in the group.
*/
function () {
this._i = 0;
while(this._i < this.length) {
if(this.members[this._i] == null) {
return this._i;
} else {
this._i++;
}
}
return -1;
};
Group.prototype.getFirstExtant = /**
* Call this function to retrieve the first object with exists == true in the group.
* This is handy for checking if everything's wiped out, or choosing a squad leader, etc.
*
* @return {Basic} A Basic currently flagged as existing.
*/
function () {
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if(this._member != null && this._member.exists) {
return this._member;
}
}
return null;
};
Group.prototype.getFirstAlive = /**
* Call this function to retrieve the first object with dead == false in the group.
* This is handy for checking if everything's wiped out, or choosing a squad leader, etc.
*
* @return {Basic} A Basic currently flagged as not dead.
*/
function () {
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if((this._member != null) && this._member.exists && this._member.alive) {
return this._member;
}
}
return null;
};
Group.prototype.getFirstDead = /**
* Call this function to retrieve the first object with dead == true in the group.
* This is handy for checking if everything's wiped out, or choosing a squad leader, etc.
*
* @return {Basic} A Basic currently flagged as dead.
*/
function () {
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if((this._member != null) && !this._member.alive) {
return this._member;
}
}
return null;
};
Group.prototype.countLiving = /**
* Call this function to find out how many members of the group are not dead.
*
* @return {number} The number of Basics flagged as not dead. Returns -1 if group is empty.
*/
function () {
this._count = -1;
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if(this._member != null) {
if(this._count < 0) {
this._count = 0;
}
if(this._member.exists && this._member.alive) {
this._count++;
}
}
}
return this._count;
};
Group.prototype.countDead = /**
* Call this function to find out how many members of the group are dead.
*
* @return {number} The number of Basics flagged as dead. Returns -1 if group is empty.
*/
function () {
this._count = -1;
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if(this._member != null) {
if(this._count < 0) {
this._count = 0;
}
if(!this._member.alive) {
this._count++;
}
}
}
return this._count;
};
Group.prototype.getRandom = /**
* Returns a member at random from the group.
*
* @param {number} StartIndex Optional offset off the front of the array. Default value is 0, or the beginning of the array.
* @param {number} Length Optional restriction on the number of values you want to randomly select from.
*
* @return {Basic} A Basic from the members list.
*/
function (startIndex, length) {
if (typeof startIndex === "undefined") { startIndex = 0; }
if (typeof length === "undefined") { length = 0; }
if(length == 0) {
length = this.length;
}
return this.game.math.getRandom(this.members, startIndex, length);
};
Group.prototype.clear = /**
* Remove all instances of Basic subclass (Basic, Block, etc) from the list.
* WARNING: does not destroy() or kill() any of these objects!
*/
function () {
this.length = this.members.length = 0;
};
Group.prototype.kill = /**
* Calls kill on the group's members and then on the group itself.
*/
function () {
this._i = 0;
while(this._i < this.length) {
this._member = this.members[this._i++];
if((this._member != null) && this._member.exists) {
this._member.kill();
}
}
};
Group.prototype.sortHandler = /**
* Helper function for the sort process.
*
* @param {Basic} Obj1 The first object being sorted.
* @param {Basic} Obj2 The second object being sorted.
*
* @return {number} An integer value: -1 (Obj1 before Obj2), 0 (same), or 1 (Obj1 after Obj2).
*/
function (obj1, obj2) {
if(obj1[this._sortIndex] < obj2[this._sortIndex]) {
return this._sortOrder;
} else if(obj1[this._sortIndex] > obj2[this._sortIndex]) {
return -this._sortOrder;
}
return 0;
};
return Group;
})();
Phaser.Group = Group;
})(Phaser || (Phaser = {}));
/// If binding was added using `Signal.addOnce()` it will be automatically removed from signal dispatch queue, this method is used internally for the signal dispatch.
* @param {Array} [paramsArr] Array of parameters that should be passed to the listener * @return {*} Value returned by the listener. */ function (paramsArr) { var handlerReturn; var params; if(this.active && !!this._listener) { params = this.params ? this.params.concat(paramsArr) : paramsArr; handlerReturn = this._listener.apply(this.context, params); if(this._isOnce) { this.detach(); } } return handlerReturn; }; SignalBinding.prototype.detach = /** * Detach binding from signal. * - alias to: mySignal.remove(myBinding.getListener()); * @return {Function|null} Handler function bound to the signal or `null` if binding was previously detached. */ function () { return this.isBound() ? this._signal.remove(this._listener, this.context) : null; }; SignalBinding.prototype.isBound = /** * @return {Boolean} `true` if binding is still bound to the signal and have a listener. */ function () { return (!!this._signal && !!this._listener); }; SignalBinding.prototype.isOnce = /** * @return {boolean} If SignalBinding will only be executed once. */ function () { return this._isOnce; }; SignalBinding.prototype.getListener = /** * @return {Function} Handler function bound to the signal. */ function () { return this._listener; }; SignalBinding.prototype.getSignal = /** * @return {Signal} Signal that listener is currently bound to. */ function () { return this._signal; }; SignalBinding.prototype._destroy = /** * Delete instance properties * @private */ function () { delete this._signal; delete this._listener; delete this.context; }; SignalBinding.prototype.toString = /** * @return {string} String representation of the object. */ function () { return '[SignalBinding isOnce:' + this._isOnce + ', isBound:' + this.isBound() + ', active:' + this.active + ']'; }; return SignalBinding; })(); Phaser.SignalBinding = SignalBinding; })(Phaser || (Phaser = {})); ///IMPORTANT: Setting this property during a dispatch will only affect the next dispatch, if you want to stop the propagation of a signal use `halt()` instead.
* @type boolean */ this.active = true; } Signal.VERSION = '1.0.0'; Signal.prototype.validateListener = /** * * @method validateListener * @param {Any} listener * @param {Any} fnName */ function (listener, fnName) { if(typeof listener !== 'function') { throw new Error('listener is a required param of {fn}() and should be a Function.'.replace('{fn}', fnName)); } }; Signal.prototype._registerListener = /** * @param {Function} listener * @param {boolean} isOnce * @param {Object} [listenerContext] * @param {Number} [priority] * @return {SignalBinding} * @private */ function (listener, isOnce, listenerContext, priority) { var prevIndex = this._indexOfListener(listener, listenerContext); var 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 Phaser.SignalBinding(this, listener, isOnce, listenerContext, priority); this._addBinding(binding); } if(this.memorize && this._prevParams) { binding.execute(this._prevParams); } return binding; }; Signal.prototype._addBinding = /** * * @method _addBinding * @param {SignalBinding} binding * @private */ function (binding) { //simplified insertion sort var n = this._bindings.length; do { --n; }while(this._bindings[n] && binding.priority <= this._bindings[n].priority); this._bindings.splice(n + 1, 0, binding); }; Signal.prototype._indexOfListener = /** * * @method _indexOfListener * @param {Function} listener * @return {number} * @private */ function (listener, context) { var n = this._bindings.length; var cur; while(n--) { cur = this._bindings[n]; if(cur.getListener() === listener && cur.context === context) { return n; } } return -1; }; Signal.prototype.has = /** * Check if listener was attached to Signal. * @param {Function} listener * @param {Object} [context] * @return {boolean} if Signal has the specified listener. */ function (listener, context) { if (typeof context === "undefined") { context = null; } return this._indexOfListener(listener, context) !== -1; }; Signal.prototype.add = /** * Add a listener to the signal. * @param {Function} listener Signal handler function. * @param {Object} [listenerContext] Context on which listener will be executed (object that should represent the `this` variable inside listener function). * @param {Number} [priority] The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added. (default = 0) * @return {SignalBinding} An Object representing the binding between the Signal and listener. */ function (listener, listenerContext, priority) { if (typeof listenerContext === "undefined") { listenerContext = null; } if (typeof priority === "undefined") { priority = 0; } this.validateListener(listener, 'add'); return this._registerListener(listener, false, listenerContext, priority); }; Signal.prototype.addOnce = /** * Add listener to the signal that should be removed after first execution (will be executed only once). * @param {Function} listener Signal handler function. * @param {Object} [listenerContext] Context on which listener will be executed (object that should represent the `this` variable inside listener function). * @param {Number} [priority] The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added. (default = 0) * @return {SignalBinding} An Object representing the binding between the Signal and listener. */ function (listener, listenerContext, priority) { if (typeof listenerContext === "undefined") { listenerContext = null; } if (typeof priority === "undefined") { priority = 0; } this.validateListener(listener, 'addOnce'); return this._registerListener(listener, true, listenerContext, priority); }; Signal.prototype.remove = /** * Remove a single listener from the dispatch queue. * @param {Function} listener Handler function that should be removed. * @param {Object} [context] Execution context (since you can add the same handler multiple times if executing in a different context). * @return {Function} Listener handler function. */ function (listener, context) { if (typeof context === "undefined") { context = null; } this.validateListener(listener, 'remove'); var i = this._indexOfListener(listener, context); if(i !== -1) { this._bindings[i]._destroy(); this._bindings.splice(i, 1); } return listener; }; Signal.prototype.removeAll = /** * Remove all listeners from the Signal. */ function () { if(this._bindings) { var n = this._bindings.length; while(n--) { this._bindings[n]._destroy(); } this._bindings.length = 0; } }; Signal.prototype.getNumListeners = /** * @return {number} Number of listeners attached to the Signal. */ function () { return this._bindings.length; }; Signal.prototype.halt = /** * Stop propagation of the event, blocking the dispatch to next listeners on the queue. *IMPORTANT: should be called only during signal dispatch, calling it before/after dispatch won't affect signal broadcast.
* @see Signal.prototype.disable */ function () { this._shouldPropagate = false; }; Signal.prototype.dispatch = /** * Dispatch/Broadcast Signal to all listeners added to the queue. * @param {...*} [params] Parameters that should be passed to each handler. */ function () { var paramsArr = []; for (var _i = 0; _i < (arguments.length - 0); _i++) { paramsArr[_i] = arguments[_i + 0]; } if(!this.active) { return; } var n = this._bindings.length; var bindings; if(this.memorize) { this._prevParams = paramsArr; } if(!n) { //should come after memorize return; } bindings = this._bindings.slice(0)//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--; }while(bindings[n] && this._shouldPropagate && bindings[n].execute(paramsArr) !== false); }; Signal.prototype.forget = /** * Forget memorized arguments. * @see Signal.memorize */ function () { this._prevParams = null; }; Signal.prototype.dispose = /** * Remove all bindings from signal and destroy any reference to external objects (destroy Signal object). *IMPORTANT: calling any method on the signal instance after calling dispose will throw errors.
*/ function () { this.removeAll(); delete this._bindings; delete this._prevParams; }; Signal.prototype.toString = /** * @return {string} String representation of the object. */ function () { return '[Signal active:' + this.active + ' numListeners:' + this.getNumListeners() + ']'; }; return Signal; })(); Phaser.Signal = Signal; })(Phaser || (Phaser = {})); ///SoundManager.
*/
function SoundManager(game) {
/**
* Reference to AudioContext instance.
*/
this._context = null;
this._game = game;
if(game.device.webaudio == true) {
if(!!window['AudioContext']) {
this._context = new window['AudioContext']();
} else if(!!window['webkitAudioContext']) {
this._context = new window['webkitAudioContext']();
}
if(this._context !== null) {
this._gainNode = this._context.createGainNode();
this._gainNode.connect(this._context.destination);
this._volume = 1;
}
}
}
SoundManager.prototype.mute = /**
* Mute sounds.
*/
function () {
this._gainNode.gain.value = 0;
};
SoundManager.prototype.unmute = /**
* Enable sounds.
*/
function () {
this._gainNode.gain.value = this._volume;
};
Object.defineProperty(SoundManager.prototype, "volume", {
get: function () {
return this._volume;
},
set: function (value) {
this._volume = value;
this._gainNode.gain.value = this._volume;
},
enumerable: true,
configurable: true
});
SoundManager.prototype.decode = /**
* Decode a sound with its assets key.
* @param key {string} Assets key of the sound to be decoded.
* @param callback {function} This will be invoked when finished decoding.
* @param [sound] {Sound} its bufer will be set to decoded data.
*/
function (key, callback, sound) {
if (typeof callback === "undefined") { callback = null; }
if (typeof sound === "undefined") { sound = null; }
var soundData = this._game.cache.getSound(key);
if(soundData) {
if(this._game.cache.isSoundDecoded(key) === false) {
var that = this;
this._context.decodeAudioData(soundData, function (buffer) {
that._game.cache.decodedSound(key, buffer);
if(sound) {
sound.setDecodedBuffer(buffer);
}
callback();
});
}
}
};
SoundManager.prototype.play = /**
* Play a sound with its assets key.
* @param key {string} Assets key of the sound you want to play.
* @param [volume] {number} volume of the sound you want to play.
* @param [loop] {boolean} loop when it finished playing? (Default to false)
* @return {Sound} The playing sound object.
*/
function (key, volume, loop) {
if (typeof volume === "undefined") { volume = 1; }
if (typeof loop === "undefined") { loop = false; }
if(this._context === null) {
return;
}
var soundData = this._game.cache.getSound(key);
if(soundData) {
// Does the sound need decoding?
if(this._game.cache.isSoundDecoded(key) === true) {
return new Phaser.Sound(this._context, this._gainNode, soundData, volume, loop);
} else {
var tempSound = new Phaser.Sound(this._context, this._gainNode, null, volume, loop);
// this is an async process, so we can return the Sound object anyway, it just won't be playing yet
this.decode(key, function () {
return tempSound.play();
}, tempSound);
return tempSound;
}
}
};
return SoundManager;
})();
Phaser.SoundManager = SoundManager;
})(Phaser || (Phaser = {}));
/**
* Phaser
*
* v1.0.0 - June XX 2013
*
* A small and feature-packed 2D canvas game framework born from the firey pits of Flixel and Kiwi.
*
* Richard Davey (@photonstorm)
*
* Many thanks to Adam Saltsman (@ADAMATOMIC) for releasing Flixel, from both which Phaser
* and my love of game development took a lot of inspiration.
*
* "If you want your children to be intelligent, read them fairy tales."
* "If you want them to be more intelligent, read them more fairy tales."
* -- Albert Einstein
*/
var Phaser;
(function (Phaser) {
Phaser.VERSION = 'Phaser version 1.0.0';
})(Phaser || (Phaser = {}));
/// BootScreen with specific width and height.
*
* @param width {number} Screen canvas width.
* @param height {number} Screen canvas height.
*/
function BootScreen(game) {
/**
* Engine logo image data.
*/
this._logoData = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGgAAAAZCAYAAADdYmvFAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAstJREFUeNrsWlFuwjAMbavdZGcAcRm4AXzvCPuGG8BlEJxhZ+l4TJ48z3actGGthqUI1MaO/V6cmIT2/fW10eTt46NvKshtvDZlG31yfOL9a/ldU6x4IZ0GQs0gS217enMkJYr5ixXkYrFoVqtV1kDn8/n+KfXw/Hq9Nin7h8MhScB2u3Xtav2ivsNWrh7XLcWMYqA4eUZ1kj0MAifHJEeKFojWzyIH+rL/0Cwif2AX9nN1oQOgrTg8XcTFx+ScdEOJ4WBxXQ1EjRyrn0cOzzQLzFyQSQcgw/5Qkkr0JVEQpNIdhL4vm4DL5fLulNTHcy6Uxl4/6iMLiePx2KzX6/v30+n0aynUlrnSeNq2/VN9bgM4dFPdNPmsJnIg/PuQbJmLdFN3UNu0SzbyJ0GOWJVWZE/QMkY+owrqXxGEdZA37BVyX6lJTipT6J1lf7fbqc+xh8nYeIvikatP+PGW0nEJ4jOydHYOIcfKnmgWoZDQSIIeio4Sf1IthYWskCO4vqQ6lFYjl8tl9L1H67PZbMz3VO3t93uVXHofmUjReLyMwHi5eCb3ICwJj5ZU9nCg+SzUgPYyif+2epTk4pkkyDp+eXTlZu2BkUybEkklePZfK9lPuTnc07vbmt1bYulHBeNQgx18SsH4ni/cV2rSLtqNDNUH2JQ2SsXS57Y9PHlfumkwCdICt5rnkNdPjpMiIEWgRlAJSdF4SvCQMWj+VyfI0h8D/EgWSYKiJKXi8VrOhJUxaFiFCOKKUJAtR78k9eX4USLHXqLGXOIiWUT4Vj9JiP4W0io3VDz8AJXblNWQrOimLjIGy/9uLICH6mrVmFbxEFHauzmc0fGJJmPg/v+6D0oB7N2bj0FsNHtSWTQniWTR931QlHXvasDTHXLjqY0/1/8hSDxACD+lAGH8dKQbQk5N3TFtzDmLWutvV0+pL5FVoHvCNG35FGAAayS4KUoKC9QAAAAASUVORK5CYII=";
/**
* Background gradient effect color 1.
*/
this._color1 = {
r: 20,
g: 20,
b: 20
};
/**
* Background gradient effect color 2.
*/
this._color2 = {
r: 200,
g: 200,
b: 200
};
/**
* Fade effect tween.
* @type {Phaser.Tween}
*/
this._fade = null;
this._game = game;
this._logo = new Image();
this._logo.src = this._logoData;
}
BootScreen.prototype.update = /**
* Update color and fade.
*/
function () {
if(this._fade == null) {
this.colorCycle();
}
this._color1.r = Math.round(this._color1.r);
this._color1.g = Math.round(this._color1.g);
this._color1.b = Math.round(this._color1.b);
this._color2.r = Math.round(this._color2.r);
this._color2.g = Math.round(this._color2.g);
this._color2.b = Math.round(this._color2.b);
};
BootScreen.prototype.render = /**
* Render BootScreen.
*/
function () {
var grd = this._game.stage.context.createLinearGradient(0, 0, 0, this._game.stage.height);
grd.addColorStop(0, 'rgb(' + this._color1.r + ', ' + this._color1.g + ', ' + this._color1.b + ')');
grd.addColorStop(0.5, 'rgb(' + this._color2.r + ', ' + this._color2.g + ', ' + this._color2.b + ')');
grd.addColorStop(1, 'rgb(' + this._color1.r + ', ' + this._color1.g + ', ' + this._color1.b + ')');
this._game.stage.context.fillStyle = grd;
this._game.stage.context.fillRect(0, 0, this._game.stage.width, this._game.stage.height);
this._game.stage.context.shadowOffsetX = 0;
this._game.stage.context.shadowOffsetY = 0;
if(this._logo) {
this._game.stage.context.drawImage(this._logo, 32, 32);
}
this._game.stage.context.shadowColor = 'rgb(0,0,0)';
this._game.stage.context.shadowOffsetX = 1;
this._game.stage.context.shadowOffsetY = 1;
this._game.stage.context.shadowBlur = 0;
this._game.stage.context.fillStyle = 'rgb(255,255,255)';
this._game.stage.context.font = 'bold 18px Arial';
this._game.stage.context.textBaseline = 'top';
this._game.stage.context.fillText(Phaser.VERSION, 32, 64 + 32);
this._game.stage.context.fillText('Game Size: ' + this._game.stage.width + ' x ' + this._game.stage.height, 32, 64 + 64);
this._game.stage.context.fillText('www.photonstorm.com', 32, 64 + 96);
this._game.stage.context.font = '16px Arial';
this._game.stage.context.fillText('You are seeing this screen because you didn\'t specify any default', 32, 64 + 160);
this._game.stage.context.fillText('functions in the Game constructor or use Game.switchState()', 32, 64 + 184);
};
BootScreen.prototype.colorCycle = /**
* Start color fading cycle.
*/
function () {
this._fade = this._game.add.tween(this._color2);
this._fade.to({
r: Math.random() * 250,
g: Math.random() * 250,
b: Math.random() * 250
}, 3000, Phaser.Easing.Linear.None);
this._fade.onComplete.add(this.colorCycle, this);
this._fade.start();
};
return BootScreen;
})();
Phaser.BootScreen = BootScreen;
})(Phaser || (Phaser = {}));
/// PauseScreen with specific width and height.
*
* @param width {number} Screen canvas width.
* @param height {number} Screen canvas height.
*/
function PauseScreen(game, width, height) {
this._game = game;
this._canvas = document.createElement('canvas');
this._canvas.width = width;
this._canvas.height = height;
this._context = this._canvas.getContext('2d');
}
PauseScreen.prototype.onPaused = /**
* Called when the game enters pause mode.
*/
function () {
// Take a grab of the current canvas to our temporary one
this._context.clearRect(0, 0, this._canvas.width, this._canvas.height);
this._context.drawImage(this._game.stage.canvas, 0, 0);
this._color = {
r: 255,
g: 255,
b: 255
};
this.fadeOut();
};
PauseScreen.prototype.onResume = /**
* Called when the game resume from pause mode.
*/
function () {
this._fade.stop();
this._game.tweens.remove(this._fade);
};
PauseScreen.prototype.update = /**
* Update background color.
*/
function () {
this._color.r = Math.round(this._color.r);
this._color.g = Math.round(this._color.g);
this._color.b = Math.round(this._color.b);
};
PauseScreen.prototype.render = /**
* Render PauseScreen.
*/
function () {
this._game.stage.context.drawImage(this._canvas, 0, 0);
this._game.stage.context.fillStyle = 'rgba(0, 0, 0, 0.4)';
this._game.stage.context.fillRect(0, 0, this._game.stage.width, this._game.stage.height);
// Draw a 'play' arrow
var arrowWidth = Math.round(this._game.stage.width / 2);
var arrowHeight = Math.round(this._game.stage.height / 2);
var sx = this._game.stage.centerX - arrowWidth / 2;
var sy = this._game.stage.centerY - arrowHeight / 2;
this._game.stage.context.beginPath();
this._game.stage.context.moveTo(sx, sy);
this._game.stage.context.lineTo(sx, sy + arrowHeight);
this._game.stage.context.lineTo(sx + arrowWidth, this._game.stage.centerY);
this._game.stage.context.fillStyle = 'rgba(' + this._color.r + ', ' + this._color.g + ', ' + this._color.b + ', 0.8)';
this._game.stage.context.fill();
this._game.stage.context.closePath();
};
PauseScreen.prototype.fadeOut = /**
* Start fadeOut effect.
*/
function () {
this._fade = this._game.add.tween(this._color);
this._fade.to({
r: 50,
g: 50,
b: 50
}, 1000, Phaser.Easing.Linear.None);
this._fade.onComplete.add(this.fadeIn, this);
this._fade.start();
};
PauseScreen.prototype.fadeIn = /**
* Start fadeIn effect.
*/
function () {
this._fade = this._game.add.tween(this._color);
this._fade.to({
r: 255,
g: 255,
b: 255
}, 1000, Phaser.Easing.Linear.None);
this._fade.onComplete.add(this.fadeOut, this);
this._fade.start();
};
return PauseScreen;
})();
Phaser.PauseScreen = PauseScreen;
})(Phaser || (Phaser = {}));
/// Stage with specific width and height.
*
* @param parent {number} ID of parent DOM element.
* @param width {number} Width of the stage.
* @param height {number} Height of the stage.
*/
function Stage(game, parent, width, height) {
var _this = this;
/**
* Background color of the stage (defaults to black)
* @type {string}
*/
this._bgColor = 'rgb(0,0,0)';
/**
* Clear the whole stage every frame? (Default to true)
* @type {boolean}
*/
this.clear = true;
/**
* Do not use pause screen when game is paused?
* (Default to false, aka always use PauseScreen)
* @type {boolean}
*/
this.disablePauseScreen = false;
/**
* Do not use boot screen when engine starts?
* (Default to false, aka always use BootScreen)
* @type {boolean}
*/
this.disableBootScreen = false;
this._game = game;
this.canvas = document.createElement('canvas');
this.canvas.width = width;
this.canvas.height = height;
if(document.getElementById(parent)) {
document.getElementById(parent).appendChild(this.canvas);
document.getElementById(parent).style.overflow = 'hidden';
} else {
document.body.appendChild(this.canvas);
}
// Consume default actions on the canvas
this.canvas.style.msTouchAction = 'none';
this.canvas.style['ms-touch-action'] = 'none';
this.canvas.style['touch-action'] = 'none';
this.canvas.style.backgroundColor = 'rgb(0,0,0)';
this.canvas.oncontextmenu = function (event) {
event.preventDefault();
};
this.context = this.canvas.getContext('2d');
this.offset = this.getOffset(this.canvas);
this.bounds = new Phaser.Rectangle(this.offset.x, this.offset.y, width, height);
this.aspectRatio = width / height;
this.scaleMode = Phaser.StageScaleMode.NO_SCALE;
this.scale = new Phaser.StageScaleMode(this._game);
this._bootScreen = new Phaser.BootScreen(this._game);
this._pauseScreen = new Phaser.PauseScreen(this._game, width, height);
document.addEventListener('visibilitychange', function (event) {
return _this.visibilityChange(event);
}, false);
document.addEventListener('webkitvisibilitychange', function (event) {
return _this.visibilityChange(event);
}, false);
window.onblur = function (event) {
return _this.visibilityChange(event);
};
window.onfocus = function (event) {
return _this.visibilityChange(event);
};
}
Stage.prototype.update = /**
* Update stage for rendering. This will handle scaling, clearing
* and PauseScreen/BootScreen updating and rendering.
*/
function () {
this.scale.update();
if(this.clear) {
// implement dirty rect? could take up more cpu time than it saves. needs benching.
this.context.clearRect(0, 0, this.width, this.height);
}
if(this._game.isRunning == false && this.disableBootScreen == false) {
this._bootScreen.update();
this._bootScreen.render();
}
if(this._game.paused == true && this.disablePauseScreen == false) {
this._pauseScreen.update();
this._pauseScreen.render();
}
};
Stage.prototype.visibilityChange = /**
* This method is called when the canvas elements visibility is changed.
*/
function (event) {
if(this.disablePauseScreen) {
return;
}
if(event.type == 'blur' || document['hidden'] == true || document['webkitHidden'] == true) {
if(this._game.paused == false) {
this.pauseGame();
}
} else {
if(this._game.paused == true) {
this.resumeGame();
}
}
};
Stage.prototype.pauseGame = function () {
this._pauseScreen.onPaused();
this.saveCanvasValues();
this._game.paused = true;
};
Stage.prototype.resumeGame = function () {
this._pauseScreen.onResume();
this.restoreCanvasValues();
this._game.paused = false;
};
Stage.prototype.getOffset = /**
* Get the DOM offset values of the given element
*/
function (element) {
var box = element.getBoundingClientRect();
var clientTop = element.clientTop || document.body.clientTop || 0;
var clientLeft = element.clientLeft || document.body.clientLeft || 0;
var scrollTop = window.pageYOffset || element.scrollTop || document.body.scrollTop;
var scrollLeft = window.pageXOffset || element.scrollLeft || document.body.scrollLeft;
return new Phaser.Point(box.left + scrollLeft - clientLeft, box.top + scrollTop - clientTop);
};
Stage.prototype.saveCanvasValues = /**
* Save current canvas properties (strokeStyle, lineWidth and fillStyle) for later using.
*/
function () {
this.strokeStyle = this.context.strokeStyle;
this.lineWidth = this.context.lineWidth;
this.fillStyle = this.context.fillStyle;
};
Stage.prototype.restoreCanvasValues = /**
* Restore current canvas values (strokeStyle, lineWidth and fillStyle) with saved values.
*/
function () {
this.context.strokeStyle = this.strokeStyle;
this.context.lineWidth = this.lineWidth;
this.context.fillStyle = this.fillStyle;
};
Object.defineProperty(Stage.prototype, "backgroundColor", {
get: function () {
return this._bgColor;
},
set: function (color) {
this.canvas.style.backgroundColor = color;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Stage.prototype, "x", {
get: function () {
return this.bounds.x;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Stage.prototype, "y", {
get: function () {
return this.bounds.y;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Stage.prototype, "width", {
get: function () {
return this.bounds.width;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Stage.prototype, "height", {
get: function () {
return this.bounds.height;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Stage.prototype, "centerX", {
get: function () {
return this.bounds.halfWidth;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Stage.prototype, "centerY", {
get: function () {
return this.bounds.halfHeight;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Stage.prototype, "randomX", {
get: function () {
return Math.round(Math.random() * this.bounds.width);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Stage.prototype, "randomY", {
get: function () {
return Math.round(Math.random() * this.bounds.height);
},
enumerable: true,
configurable: true
});
return Stage;
})();
Phaser.Stage = Stage;
})(Phaser || (Phaser = {}));
/// Time.
*
* @param game {Phaser.Game} Current game instance.
*/
function Time(game) {
/**
* Time scale factor.
* Set it to 0.5 for slow motion, to 2.0 makes game twice faster.
* @type {number}
*/
this.timeScale = 1.0;
/**
* Elapsed since last frame.
* @type {number}
*/
this.elapsed = 0;
/**
* Game time counter.
* @property time
* @type {number}
*/
this.time = 0;
/**
* Time of current frame.
* @property now
* @type {number}
*/
this.now = 0;
/**
* Elapsed time since last frame.
* @property delta
* @type {number}
*/
this.delta = 0;
/**
* Frames per second.
* @type {number}
*/
this.fps = 0;
/**
* Minimal fps.
* @type {number}
*/
this.fpsMin = 1000;
/**
* Maximal fps.
* @type {number}
*/
this.fpsMax = 0;
/**
* Mininal duration between 2 frames.
* @type {number}
*/
this.msMin = 1000;
/**
* Maximal duration between 2 frames.
* @type {number}
*/
this.msMax = 0;
/**
* How many frames in last second.
* @type {number}
*/
this.frames = 0;
/**
* Time of last second.
* @type {number}
*/
this._timeLastSecond = 0;
this._started = 0;
this._timeLastSecond = this._started;
this.time = this._started;
this._game = game;
}
Object.defineProperty(Time.prototype, "totalElapsedSeconds", {
get: /**
*
* @method totalElapsedSeconds
* @return {Number}
*/
function () {
return (this.now - this._started) * 0.001;
},
enumerable: true,
configurable: true
});
Time.prototype.update = /**
* Update clock and calculate the fps.
* This is called automatically by Game._raf
* @method update
* @param {number} raf The current timestamp, either performance.now or Date.now
*/
function (raf) {
this.now = raf// mark
;
//this.now = Date.now(); // mark
this.delta = this.now - this.time// elapsedMS
;
this.msMin = Math.min(this.msMin, this.delta);
this.msMax = Math.max(this.msMax, this.delta);
this.frames++;
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;
}
this.time = this.now// _total
;
};
Time.prototype.elapsedSince = /**
* How long has passed since given time.
* @method elapsedSince
* @param {number} since The time you want to measure.
* @return {number} Duration between given time and now.
*/
function (since) {
return this.now - since;
};
Time.prototype.elapsedSecondsSince = /**
* How long has passed since give time (in seconds).
* @method elapsedSecondsSince
* @param {number} since The time you want to measure (in seconds).
* @return {number} Duration between given time and now (in seconds).
*/
function (since) {
return (this.now - since) * 0.001;
};
Time.prototype.reset = /**
* Set the start time to now.
* @method reset
*/
function () {
this._started = this.now;
};
return Time;
})();
Phaser.Time = Time;
})(Phaser || (Phaser = {}));
/// World with specific width and height.
*
* @param width {number} Width of the world bound.
* @param height {number} Height of the world bound.
*/
function World(game, width, height) {
this._game = game;
this.cameras = new Phaser.CameraManager(this._game, 0, 0, width, height);
this.group = new Phaser.Group(this._game, 0);
this.bounds = new Phaser.Rectangle(0, 0, width, height);
this.physics = new Phaser.Physics.PhysicsManager(this._game, width, height);
this.worldDivisions = 6;
}
World.prototype.update = /**
* This is called automatically every frame, and is where main logic happens.
*/
function () {
this.physics.update();
this.group.update();
this.cameras.update();
};
World.prototype.destroy = /**
* Clean up memory.
*/
function () {
//this.physics.destroy();
this.group.destroy();
this.cameras.destroy();
};
World.prototype.setSize = /**
* Updates the size of this world.
*
* @param width {number} New width of the world.
* @param height {number} New height of the world.
* @param [updateCameraBounds] {boolean} Update camera bounds automatically or not. Default to true.
*/
function (width, height, updateCameraBounds, updatePhysicsBounds) {
if (typeof updateCameraBounds === "undefined") { updateCameraBounds = true; }
if (typeof updatePhysicsBounds === "undefined") { updatePhysicsBounds = true; }
this.bounds.width = width;
this.bounds.height = height;
if(updateCameraBounds == true) {
this._game.camera.setBounds(0, 0, width, height);
}
if(updatePhysicsBounds == true) {
//this.physics.bounds.copyFrom(this.bounds);
}
// dispatch world resize event
};
Object.defineProperty(World.prototype, "width", {
get: function () {
return this.bounds.width;
},
set: function (value) {
this.bounds.width = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(World.prototype, "height", {
get: function () {
return this.bounds.height;
},
set: function (value) {
this.bounds.height = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(World.prototype, "centerX", {
get: function () {
return this.bounds.halfWidth;
},
enumerable: true,
configurable: true
});
Object.defineProperty(World.prototype, "centerY", {
get: function () {
return this.bounds.halfHeight;
},
enumerable: true,
configurable: true
});
Object.defineProperty(World.prototype, "randomX", {
get: function () {
return Math.round(Math.random() * this.bounds.width);
},
enumerable: true,
configurable: true
});
Object.defineProperty(World.prototype, "randomY", {
get: function () {
return Math.round(Math.random() * this.bounds.height);
},
enumerable: true,
configurable: true
});
World.prototype.getAllCameras = /**
* Get all the cameras.
*
* @returns {array} An array contains all the cameras.
*/
function () {
return this.cameras.getAll();
};
return World;
})();
Phaser.World = World;
})(Phaser || (Phaser = {}));
/// ScrollRegion.
*
* @param x {number} X position in world coordinate.
* @param y {number} Y position in world coordinate.
* @param width {number} Width of this object.
* @param height {number} Height of this object.
* @param speedX {number} X-axis scrolling speed.
* @param speedY {number} Y-axis scrolling speed.
*/
function ScrollRegion(x, y, width, height, speedX, speedY) {
this._anchorWidth = 0;
this._anchorHeight = 0;
this._inverseWidth = 0;
this._inverseHeight = 0;
/**
* Will this region be rendered? (default to true)
* @type {boolean}
*/
this.visible = true;
// Our seamless scrolling quads
this._A = new Phaser.Rectangle(x, y, width, height);
this._B = new Phaser.Rectangle(x, y, width, height);
this._C = new Phaser.Rectangle(x, y, width, height);
this._D = new Phaser.Rectangle(x, y, width, height);
this._scroll = new Phaser.Vec2();
this._bounds = new Phaser.Rectangle(x, y, width, height);
this.scrollSpeed = new Phaser.Vec2(speedX, speedY);
}
ScrollRegion.prototype.update = /**
* Update region scrolling with tick time.
* @param delta {number} Elapsed time since last update.
*/
function (delta) {
this._scroll.x += this.scrollSpeed.x;
this._scroll.y += this.scrollSpeed.y;
if(this._scroll.x > this._bounds.right) {
this._scroll.x = this._bounds.x;
}
if(this._scroll.x < this._bounds.x) {
this._scroll.x = this._bounds.right;
}
if(this._scroll.y > this._bounds.bottom) {
this._scroll.y = this._bounds.y;
}
if(this._scroll.y < this._bounds.y) {
this._scroll.y = this._bounds.bottom;
}
// Anchor Dimensions
this._anchorWidth = (this._bounds.width - this._scroll.x) + this._bounds.x;
this._anchorHeight = (this._bounds.height - this._scroll.y) + this._bounds.y;
if(this._anchorWidth > this._bounds.width) {
this._anchorWidth = this._bounds.width;
}
if(this._anchorHeight > this._bounds.height) {
this._anchorHeight = this._bounds.height;
}
this._inverseWidth = this._bounds.width - this._anchorWidth;
this._inverseHeight = this._bounds.height - this._anchorHeight;
// Rectangle A
this._A.setTo(this._scroll.x, this._scroll.y, this._anchorWidth, this._anchorHeight);
// Rectangle B
this._B.y = this._scroll.y;
this._B.width = this._inverseWidth;
this._B.height = this._anchorHeight;
// Rectangle C
this._C.x = this._scroll.x;
this._C.width = this._anchorWidth;
this._C.height = this._inverseHeight;
// Rectangle D
this._D.width = this._inverseWidth;
this._D.height = this._inverseHeight;
};
ScrollRegion.prototype.render = /**
* Render this region to specific context.
* @param context {CanvasRenderingContext2D} Canvas context this region will be rendered to.
* @param texture {object} The texture to be rendered.
* @param dx {number} X position in world coordinate.
* @param dy {number} Y position in world coordinate.
* @param width {number} Width of this region to be rendered.
* @param height {number} Height of this region to be rendered.
*/
function (context, texture, dx, dy, dw, dh) {
if(this.visible == false) {
return;
}
// dx/dy are the world coordinates to render the FULL ScrollZone into.
// This ScrollRegion may be smaller than that and offset from the dx/dy coordinates.
this.crop(context, texture, this._A.x, this._A.y, this._A.width, this._A.height, dx, dy, dw, dh, 0, 0);
this.crop(context, texture, this._B.x, this._B.y, this._B.width, this._B.height, dx, dy, dw, dh, this._A.width, 0);
this.crop(context, texture, this._C.x, this._C.y, this._C.width, this._C.height, dx, dy, dw, dh, 0, this._A.height);
this.crop(context, texture, this._D.x, this._D.y, this._D.width, this._D.height, dx, dy, dw, dh, this._C.width, this._A.height);
//context.fillStyle = 'rgb(255,255,255)';
//context.font = '18px Arial';
//context.fillText('RectangleA: ' + this._A.toString(), 32, 450);
//context.fillText('RectangleB: ' + this._B.toString(), 32, 480);
//context.fillText('RectangleC: ' + this._C.toString(), 32, 510);
//context.fillText('RectangleD: ' + this._D.toString(), 32, 540);
};
ScrollRegion.prototype.crop = /**
* Crop part of the texture and render it to the given context.
* @param context {CanvasRenderingContext2D} Canvas context the texture will be rendered to.
* @param texture {object} Texture to be rendered.
* @param srcX {number} Target region top-left x coordinate in the texture.
* @param srcX {number} Target region top-left y coordinate in the texture.
* @param srcW {number} Target region width in the texture.
* @param srcH {number} Target region height in the texture.
* @param destX {number} Render region top-left x coordinate in the context.
* @param destX {number} Render region top-left y coordinate in the context.
* @param destW {number} Target region width in the context.
* @param destH {number} Target region height in the context.
* @param offsetX {number} X offset to the context.
* @param offsetY {number} Y offset to the context.
*/
function (context, texture, srcX, srcY, srcW, srcH, destX, destY, destW, destH, offsetX, offsetY) {
offsetX += destX;
offsetY += destY;
if(srcW > (destX + destW) - offsetX) {
srcW = (destX + destW) - offsetX;
}
if(srcH > (destY + destH) - offsetY) {
srcH = (destY + destH) - offsetY;
}
srcX = Math.floor(srcX);
srcY = Math.floor(srcY);
srcW = Math.floor(srcW);
srcH = Math.floor(srcH);
offsetX = Math.floor(offsetX + this._bounds.x);
offsetY = Math.floor(offsetY + this._bounds.y);
if(srcW > 0 && srcH > 0) {
context.drawImage(texture, srcX, srcY, srcW, srcH, offsetX, offsetY, srcW, srcH);
}
};
return ScrollRegion;
})();
Phaser.ScrollRegion = ScrollRegion;
})(Phaser || (Phaser = {}));
var __extends = this.__extends || function (d, b) {
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
/// ScrollZone.
*
* @param game {Phaser.Game} Current game instance.
* @param key {string} Asset key for image texture of this object.
* @param x {number} X position in world coordinate.
* @param y {number} Y position in world coordinate.
* @param [width] {number} width of this object.
* @param [height] {number} height of this object.
*/
function ScrollZone(game, key, x, y, width, height) {
if (typeof x === "undefined") { x = 0; }
if (typeof y === "undefined") { y = 0; }
if (typeof width === "undefined") { width = 0; }
if (typeof height === "undefined") { height = 0; }
_super.call(this, game, x, y, key, width, height);
this.type = Phaser.Types.SCROLLZONE;
this.render = game.renderer.renderScrollZone;
this.physics.moves = false;
this.regions = [];
if(this.texture.loaded) {
if(width > this.width || height > this.height) {
// Create our repeating texture (as the source image wasn't large enough for the requested size)
this.createRepeatingTexture(width, height);
this.width = width;
this.height = height;
}
// Create a default ScrollRegion at the requested size
this.addRegion(0, 0, this.width, this.height);
// If the zone is smaller than the image itself then shrink the bounds
if((width < this.width || height < this.height) && width !== 0 && height !== 0) {
this.width = width;
this.height = height;
}
}
}
ScrollZone.prototype.addRegion = /**
* Add a new region to this zone.
* @param x {number} X position of the new region.
* @param y {number} Y position of the new region.
* @param width {number} Width of the new region.
* @param height {number} Height of the new region.
* @param [speedX] {number} x-axis scrolling speed.
* @param [speedY] {number} y-axis scrolling speed.
* @return {ScrollRegion} The newly added region.
*/
function (x, y, width, height, speedX, speedY) {
if (typeof speedX === "undefined") { speedX = 0; }
if (typeof speedY === "undefined") { speedY = 0; }
if(x > this.width || y > this.height || x < 0 || y < 0 || (x + width) > this.width || (y + height) > this.height) {
throw Error('Invalid ScrollRegion defined. Cannot be larger than parent ScrollZone');
return;
}
this.currentRegion = new Phaser.ScrollRegion(x, y, width, height, speedX, speedY);
this.regions.push(this.currentRegion);
return this.currentRegion;
};
ScrollZone.prototype.setSpeed = /**
* Set scrolling speed of current region.
* @param x {number} X speed of current region.
* @param y {number} Y speed of current region.
*/
function (x, y) {
if(this.currentRegion) {
this.currentRegion.scrollSpeed.setTo(x, y);
}
return this;
};
ScrollZone.prototype.update = /**
* Update regions.
*/
function () {
for(var i = 0; i < this.regions.length; i++) {
this.regions[i].update(this.game.time.delta);
}
};
ScrollZone.prototype.createRepeatingTexture = /**
* Create repeating texture with _texture, and store it into the _dynamicTexture.
* Used to create texture when texture image is small than size of the zone.
*/
function (regionWidth, regionHeight) {
// Work out how many we'll need of the source image to make it tile properly
var tileWidth = Math.ceil(this.width / regionWidth) * regionWidth;
var tileHeight = Math.ceil(this.height / regionHeight) * regionHeight;
var dt = new Phaser.DynamicTexture(this.game, tileWidth, tileHeight);
dt.context.rect(0, 0, tileWidth, tileHeight);
dt.context.fillStyle = dt.context.createPattern(this.texture.imageTexture, "repeat");
dt.context.fill();
this.texture.loadDynamicTexture(dt);
};
return ScrollZone;
})(Phaser.Sprite);
Phaser.ScrollZone = ScrollZone;
})(Phaser || (Phaser = {}));
/// Phaser.Game object.
*
* @param callbackContext Which context will the callbacks be called with.
* @param parent {string} ID of its parent DOM element.
* @param width {number} The width of your game in game pixels.
* @param height {number} The height of your game in game pixels.
* @param initCallback {function} Init callback invoked when init default screen.
* @param createCallback {function} Create callback invoked when create default screen.
* @param updateCallback {function} Update callback invoked when update default screen.
* @param renderCallback {function} Render callback invoked when render default screen.
* @param destroyCallback {function} Destroy callback invoked when state is destroyed.
*/
function Game(callbackContext, parent, width, height, initCallback, createCallback, updateCallback, renderCallback, destroyCallback) {
if (typeof parent === "undefined") { parent = ''; }
if (typeof width === "undefined") { width = 800; }
if (typeof height === "undefined") { height = 600; }
if (typeof initCallback === "undefined") { initCallback = null; }
if (typeof createCallback === "undefined") { createCallback = null; }
if (typeof updateCallback === "undefined") { updateCallback = null; }
if (typeof renderCallback === "undefined") { renderCallback = null; }
if (typeof destroyCallback === "undefined") { destroyCallback = null; }
var _this = this;
/**
* Max allowable accumulation.
* @type {number}
*/
this._maxAccumulation = 32;
/**
* Total number of milliseconds elapsed since last update loop.
* @type {number}
*/
this._accumulator = 0;
/**
* Milliseconds of time per step of the game loop.
* @type {number}
*/
this._step = 0;
/**
* Whether loader complete loading or not.
* @type {boolean}
*/
this._loadComplete = false;
/**
* Game is paused?
* @type {boolean}
*/
this._paused = false;
/**
* The state to be switched to in the next frame.
* @type {State}
*/
this._pendingState = null;
/**
* The current State object (defaults to null)
* @type {State}
*/
this.state = null;
/**
* This will be called when init states. (loading assets...)
* @type {function}
*/
this.onInitCallback = null;
/**
* This will be called when create states. (setup states...)
* @type {function}
*/
this.onCreateCallback = null;
/**
* This will be called when update states.
* @type {function}
*/
this.onUpdateCallback = null;
/**
* This will be called when render states.
* @type {function}
*/
this.onRenderCallback = null;
/**
* This will be called when states paused.
* @type {function}
*/
this.onPausedCallback = null;
/**
* This will be called when the state is destroyed (i.e. swapping to a new state)
* @type {function}
*/
this.onDestroyCallback = null;
/**
* Whether the game engine is booted, aka available.
* @type {boolean}
*/
this.isBooted = false;
/**
* Is game running or paused?
* @type {boolean}
*/
this.isRunning = false;
this.callbackContext = callbackContext;
this.onInitCallback = initCallback;
this.onCreateCallback = createCallback;
this.onUpdateCallback = updateCallback;
this.onRenderCallback = renderCallback;
this.onDestroyCallback = destroyCallback;
if(document.readyState === 'complete' || document.readyState === 'interactive') {
setTimeout(function () {
return _this.boot(parent, width, height);
});
} else {
document.addEventListener('DOMContentLoaded', function () {
return _this.boot(parent, width, height);
}, false);
window.addEventListener('load', function () {
return _this.boot(parent, width, height);
}, false);
}
}
Game.prototype.boot = /**
* Initialize engine sub modules and start the game.
* @param parent {string} ID of parent Dom element.
* @param width {number} Width of the game screen.
* @param height {number} Height of the game screen.
*/
function (parent, width, height) {
var _this = this;
if(this.isBooted == true) {
return;
}
if(!document.body) {
window.setTimeout(function () {
return _this.boot(parent, width, height);
}, 13);
} else {
this.device = new Phaser.Device();
//this.motion = new Motion(this);
this.math = new Phaser.GameMath(this);
this.stage = new Phaser.Stage(this, parent, width, height);
this.world = new Phaser.World(this, width, height);
this.add = new Phaser.GameObjectFactory(this);
this.sound = new Phaser.SoundManager(this);
this.cache = new Phaser.Cache(this);
//this.collision = new Collision(this);
this.loader = new Phaser.Loader(this, this.loadComplete);
this.time = new Phaser.Time(this);
this.tweens = new Phaser.TweenManager(this);
this.input = new Phaser.Input(this);
this.rnd = new Phaser.RandomDataGenerator([
(Date.now() * Math.random()).toString()
]);
this.setRenderer(Phaser.Types.RENDERER_CANVAS);
this.framerate = 60;
this.isBooted = true;
this.input.start();
// Display the default game screen?
if(this.onInitCallback == null && this.onCreateCallback == null && this.onUpdateCallback == null && this.onRenderCallback == null && this._pendingState == null) {
this._raf = new Phaser.RequestAnimationFrame(this, this.bootLoop);
} else {
this.isRunning = true;
this._loadComplete = false;
this._raf = new Phaser.RequestAnimationFrame(this, this.loop);
if(this._pendingState) {
this.switchState(this._pendingState, false, false);
} else {
this.startState();
}
}
}
};
Game.prototype.setRenderer = function (type) {
switch(type) {
case Phaser.Types.RENDERER_AUTO_DETECT:
this.renderer = new Phaser.HeadlessRenderer(this);
break;
case Phaser.Types.RENDERER_AUTO_DETECT:
case Phaser.Types.RENDERER_CANVAS:
this.renderer = new Phaser.CanvasRenderer(this);
break;
// WebGL coming soon :)
}
};
Game.prototype.loadComplete = /**
* Called when the loader has finished after init was run.
*/
function () {
this._loadComplete = true;
};
Game.prototype.bootLoop = /**
* Game loop method will be called when it's booting.
*/
function () {
this.tweens.update();
this.input.update();
this.stage.update();
};
Game.prototype.pausedLoop = /**
* Game loop method will be called when it's paused.
*/
function () {
this.tweens.update();
this.input.update();
this.stage.update();
if(this.onPausedCallback !== null) {
this.onPausedCallback.call(this.callbackContext);
}
};
Game.prototype.loop = /**
* Game loop method will be called when it's running.
*/
function () {
this.tweens.update();
this.input.update();
this.stage.update();
this._accumulator += this.time.delta;
if(this._accumulator > this._maxAccumulation) {
this._accumulator = this._maxAccumulation;
}
while(this._accumulator >= this._step) {
this.time.elapsed = this.time.timeScale * (this._step / 1000);
this.world.update();
this._accumulator = this._accumulator - this._step;
}
if(this._loadComplete && this.onUpdateCallback) {
this.onUpdateCallback.call(this.callbackContext);
}
this.renderer.render();
if(this._loadComplete && this.onRenderCallback) {
this.onRenderCallback.call(this.callbackContext);
}
};
Game.prototype.startState = /**
* Start current state.
*/
function () {
if(this.onInitCallback !== null) {
this.loader.reset();
this.onInitCallback.call(this.callbackContext);
// Is the loader empty?
if(this.loader.queueSize == 0) {
if(this.onCreateCallback !== null) {
this.onCreateCallback.call(this.callbackContext);
}
this._loadComplete = true;
}
} else {
// No init? Then there was nothing to load either
if(this.onCreateCallback !== null) {
this.onCreateCallback.call(this.callbackContext);
}
this._loadComplete = true;
}
};
Game.prototype.setCallbacks = /**
* Set all state callbacks (init, create, update, render).
* @param initCallback {function} Init callback invoked when init state.
* @param createCallback {function} Create callback invoked when create state.
* @param updateCallback {function} Update callback invoked when update state.
* @param renderCallback {function} Render callback invoked when render state.
* @param destroyCallback {function} Destroy callback invoked when state is destroyed.
*/
function (initCallback, createCallback, updateCallback, renderCallback, destroyCallback) {
if (typeof initCallback === "undefined") { initCallback = null; }
if (typeof createCallback === "undefined") { createCallback = null; }
if (typeof updateCallback === "undefined") { updateCallback = null; }
if (typeof renderCallback === "undefined") { renderCallback = null; }
if (typeof destroyCallback === "undefined") { destroyCallback = null; }
this.onInitCallback = initCallback;
this.onCreateCallback = createCallback;
this.onUpdateCallback = updateCallback;
this.onRenderCallback = renderCallback;
this.onDestroyCallback = destroyCallback;
};
Game.prototype.switchState = /**
* Switch to a new State.
* @param state {State} The state you want to switch to.
* @param [clearWorld] {boolean} clear everything in the world? (Default to true)
* @param [clearCache] {boolean} clear asset cache? (Default to false and ONLY available when clearWorld=true)
*/
function (state, clearWorld, clearCache) {
if (typeof clearWorld === "undefined") { clearWorld = true; }
if (typeof clearCache === "undefined") { clearCache = false; }
if(this.isBooted == false) {
this._pendingState = state;
return;
}
// Destroy current state?
if(this.onDestroyCallback !== null) {
this.onDestroyCallback.call(this.callbackContext);
}
this.input.reset(true);
// Prototype?
if(typeof state === 'function') {
this.state = new state(this);
}
// Ok, have we got the right functions?
if(this.state['create'] || this.state['update']) {
this.callbackContext = this.state;
this.onInitCallback = null;
this.onCreateCallback = null;
this.onUpdateCallback = null;
this.onRenderCallback = null;
this.onPausedCallback = null;
this.onDestroyCallback = null;
// Bingo, let's set them up
if(this.state['init']) {
this.onInitCallback = this.state['init'];
}
if(this.state['create']) {
this.onCreateCallback = this.state['create'];
}
if(this.state['update']) {
this.onUpdateCallback = this.state['update'];
}
if(this.state['render']) {
this.onRenderCallback = this.state['render'];
}
if(this.state['paused']) {
this.onPausedCallback = this.state['paused'];
}
if(this.state['destroy']) {
this.onDestroyCallback = this.state['destroy'];
}
if(clearWorld) {
this.world.destroy();
if(clearCache == true) {
this.cache.destroy();
}
}
this._loadComplete = false;
this.startState();
} else {
throw new Error("Invalid State object given. Must contain at least a create or update function.");
}
};
Game.prototype.destroy = /**
* Nuke the whole game from orbit
*/
function () {
this.callbackContext = null;
this.onInitCallback = null;
this.onCreateCallback = null;
this.onUpdateCallback = null;
this.onRenderCallback = null;
this.onPausedCallback = null;
this.onDestroyCallback = null;
this.cache = null;
this.input = null;
this.loader = null;
this.sound = null;
this.stage = null;
this.time = null;
this.world = null;
this.isBooted = false;
};
Object.defineProperty(Game.prototype, "paused", {
get: function () {
return this._paused;
},
set: function (value) {
if(value == true && this._paused == false) {
this._paused = true;
this._raf.callback = this.pausedLoop;
} else if(value == false && this._paused == true) {
this._paused = false;
//this.time.time = window.performance.now ? (performance.now() + performance.timing.navigationStart) : Date.now();
this.input.reset();
if(this.isRunning == false) {
this._raf.callback = this.bootLoop;
} else {
this._raf.callback = this.loop;
}
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(Game.prototype, "framerate", {
get: function () {
return 1000 / this._step;
},
set: function (value) {
this._step = 1000 / value;
if(this._maxAccumulation < this._step) {
this._maxAccumulation = this._step;
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(Game.prototype, "camera", {
get: /**
* Checks for overlaps between two objects using the world QuadTree. Can be GameObject vs. GameObject, GameObject vs. Group or Group vs. Group.
* Note: Does not take the objects scrollFactor into account. All overlaps are check in world space.
* @param object1 The first GameObject or Group to check. If null the world.group is used.
* @param object2 The second GameObject or Group to check.
* @param notifyCallback A callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you passed them to Collision.overlap.
* @param processCallback A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then notifyCallback will only be called if processCallback returns true.
* @param context The context in which the callbacks will be called
* @returns {boolean} true if the objects overlap, otherwise false.
*/
//public collide(objectOrGroup1 = null, objectOrGroup2 = null, notifyCallback = null, context? = this.callbackContext): bool {
// return this.collision.overlap(objectOrGroup1, objectOrGroup2, notifyCallback, Collision.separate, context);
//}
function () {
return this.world.cameras.current;
},
enumerable: true,
configurable: true
});
return Game;
})();
Phaser.Game = Game;
})(Phaser || (Phaser = {}));
/// object and next to null.
*/
function LinkedList() {
this.object = null;
this.next = null;
}
LinkedList.prototype.destroy = /**
* Clean up memory.
*/
function () {
this.object = null;
if(this.next != null) {
this.next.destroy();
}
this.next = null;
};
return LinkedList;
})();
Phaser.LinkedList = LinkedList;
})(Phaser || (Phaser = {}));
/// myFunction(Object1:GameObject,Object2:GameObject) that is called whenever two objects are found to overlap in world space, and either no processCallback is specified, or the processCallback returns true.
* @param {Function} processCallback A function with the form myFunction(Object1:GameObject,Object2:GameObject):bool that is called whenever two objects are found to overlap in world space. The notifyCallback is only called if this function returns true. See GameObject.separate().
* @param context The context in which the callbacks will be called
*/
function (objectOrGroup1, objectOrGroup2, notifyCallback, processCallback, context) {
if (typeof objectOrGroup2 === "undefined") { objectOrGroup2 = null; }
if (typeof notifyCallback === "undefined") { notifyCallback = null; }
if (typeof processCallback === "undefined") { processCallback = null; }
if (typeof context === "undefined") { context = null; }
this.add(objectOrGroup1, QuadTree.A_LIST);
if(objectOrGroup2 != null) {
this.add(objectOrGroup2, QuadTree.B_LIST);
QuadTree._useBothLists = true;
} else {
QuadTree._useBothLists = false;
}
QuadTree._notifyCallback = notifyCallback;
QuadTree._processingCallback = processCallback;
QuadTree._callbackContext = context;
};
QuadTree.prototype.add = /**
* Call this function to add an object to the root of the tree.
* This function will recursively add all group members, but
* not the groups themselves.
*
* @param {} objectOrGroup GameObjects are just added, Groups are recursed and their applicable members added accordingly.
* @param {Number} list A uint flag indicating the list to which you want to add the objects. Options are QuadTree.A_LIST and QuadTree.B_LIST.
*/
function (objectOrGroup, list) {
QuadTree._list = list;
if(objectOrGroup.isGroup == true) {
this._i = 0;
this._members = objectOrGroup['members'];
this._l = objectOrGroup['length'];
while(this._i < this._l) {
this._basic = this._members[this._i++];
if(this._basic != null && this._basic.exists) {
if(this._basic.type == Phaser.Types.GROUP) {
this.add(this._basic, list);
} else {
QuadTree._object = this._basic;
if(QuadTree._object.exists && QuadTree._object.allowCollisions) {
this.addObject();
}
}
}
}
} else {
QuadTree._object = objectOrGroup;
if(QuadTree._object.exists && QuadTree._object.allowCollisions) {
this.addObject();
}
}
};
QuadTree.prototype.addObject = /**
* Internal function for recursively navigating and creating the tree
* while adding objects to the appropriate nodes.
*/
function () {
//If this quad (not its children) lies entirely inside this object, add it here
if(!this._canSubdivide || ((this._leftEdge >= QuadTree._object.collisionMask.x) && (this._rightEdge <= QuadTree._object.collisionMask.right) && (this._topEdge >= QuadTree._object.collisionMask.y) && (this._bottomEdge <= QuadTree._object.collisionMask.bottom))) {
this.addToList();
return;
}
//See if the selected object fits completely inside any of the quadrants
if((QuadTree._object.collisionMask.x > this._leftEdge) && (QuadTree._object.collisionMask.right < this._midpointX)) {
if((QuadTree._object.collisionMask.y > this._topEdge) && (QuadTree._object.collisionMask.bottom < this._midpointY)) {
if(this._northWestTree == null) {
this._northWestTree = new QuadTree(this._leftEdge, this._topEdge, this._halfWidth, this._halfHeight, this);
}
this._northWestTree.addObject();
return;
}
if((QuadTree._object.collisionMask.y > this._midpointY) && (QuadTree._object.collisionMask.bottom < this._bottomEdge)) {
if(this._southWestTree == null) {
this._southWestTree = new QuadTree(this._leftEdge, this._midpointY, this._halfWidth, this._halfHeight, this);
}
this._southWestTree.addObject();
return;
}
}
if((QuadTree._object.collisionMask.x > this._midpointX) && (QuadTree._object.collisionMask.right < this._rightEdge)) {
if((QuadTree._object.collisionMask.y > this._topEdge) && (QuadTree._object.collisionMask.bottom < this._midpointY)) {
if(this._northEastTree == null) {
this._northEastTree = new QuadTree(this._midpointX, this._topEdge, this._halfWidth, this._halfHeight, this);
}
this._northEastTree.addObject();
return;
}
if((QuadTree._object.collisionMask.y > this._midpointY) && (QuadTree._object.collisionMask.bottom < this._bottomEdge)) {
if(this._southEastTree == null) {
this._southEastTree = new QuadTree(this._midpointX, this._midpointY, this._halfWidth, this._halfHeight, this);
}
this._southEastTree.addObject();
return;
}
}
//If it wasn't completely contained we have to check out the partial overlaps
if((QuadTree._object.collisionMask.right > this._leftEdge) && (QuadTree._object.collisionMask.x < this._midpointX) && (QuadTree._object.collisionMask.bottom > this._topEdge) && (QuadTree._object.collisionMask.y < this._midpointY)) {
if(this._northWestTree == null) {
this._northWestTree = new QuadTree(this._leftEdge, this._topEdge, this._halfWidth, this._halfHeight, this);
}
this._northWestTree.addObject();
}
if((QuadTree._object.collisionMask.right > this._midpointX) && (QuadTree._object.collisionMask.x < this._rightEdge) && (QuadTree._object.collisionMask.bottom > this._topEdge) && (QuadTree._object.collisionMask.y < this._midpointY)) {
if(this._northEastTree == null) {
this._northEastTree = new QuadTree(this._midpointX, this._topEdge, this._halfWidth, this._halfHeight, this);
}
this._northEastTree.addObject();
}
if((QuadTree._object.collisionMask.right > this._midpointX) && (QuadTree._object.collisionMask.x < this._rightEdge) && (QuadTree._object.collisionMask.bottom > this._midpointY) && (QuadTree._object.collisionMask.y < this._bottomEdge)) {
if(this._southEastTree == null) {
this._southEastTree = new QuadTree(this._midpointX, this._midpointY, this._halfWidth, this._halfHeight, this);
}
this._southEastTree.addObject();
}
if((QuadTree._object.collisionMask.right > this._leftEdge) && (QuadTree._object.collisionMask.x < this._midpointX) && (QuadTree._object.collisionMask.bottom > this._midpointY) && (QuadTree._object.collisionMask.y < this._bottomEdge)) {
if(this._southWestTree == null) {
this._southWestTree = new QuadTree(this._leftEdge, this._midpointY, this._halfWidth, this._halfHeight, this);
}
this._southWestTree.addObject();
}
};
QuadTree.prototype.addToList = /**
* Internal function for recursively adding objects to leaf lists.
*/
function () {
if(QuadTree._list == QuadTree.A_LIST) {
if(this._tailA.object != null) {
this._ot = this._tailA;
this._tailA = new Phaser.LinkedList();
this._ot.next = this._tailA;
}
this._tailA.object = QuadTree._object;
} else {
if(this._tailB.object != null) {
this._ot = this._tailB;
this._tailB = new Phaser.LinkedList();
this._ot.next = this._tailB;
}
this._tailB.object = QuadTree._object;
}
if(!this._canSubdivide) {
return;
}
if(this._northWestTree != null) {
this._northWestTree.addToList();
}
if(this._northEastTree != null) {
this._northEastTree.addToList();
}
if(this._southEastTree != null) {
this._southEastTree.addToList();
}
if(this._southWestTree != null) {
this._southWestTree.addToList();
}
};
QuadTree.prototype.execute = /**
* QuadTree's other main function. Call this after adding objects
* using QuadTree.load() to compare the objects that you loaded.
*
* @return {Boolean} Whether or not any overlaps were found.
*/
function () {
this._overlapProcessed = false;
if(this._headA.object != null) {
this._iterator = this._headA;
while(this._iterator != null) {
QuadTree._object = this._iterator.object;
if(QuadTree._useBothLists) {
QuadTree._iterator = this._headB;
} else {
QuadTree._iterator = this._iterator.next;
}
if(QuadTree._object.exists && (QuadTree._object.allowCollisions > 0) && (QuadTree._iterator != null) && (QuadTree._iterator.object != null) && QuadTree._iterator.object.exists && this.overlapNode()) {
this._overlapProcessed = true;
}
this._iterator = this._iterator.next;
}
}
//Advance through the tree by calling overlap on each child
if((this._northWestTree != null) && this._northWestTree.execute()) {
this._overlapProcessed = true;
}
if((this._northEastTree != null) && this._northEastTree.execute()) {
this._overlapProcessed = true;
}
if((this._southEastTree != null) && this._southEastTree.execute()) {
this._overlapProcessed = true;
}
if((this._southWestTree != null) && this._southWestTree.execute()) {
this._overlapProcessed = true;
}
return this._overlapProcessed;
};
QuadTree.prototype.overlapNode = /**
* A private for comparing an object against the contents of a node.
*
* @return {Boolean} Whether or not any overlaps were found.
*/
function () {
//Walk the list and check for overlaps
this._overlapProcessed = false;
while(QuadTree._iterator != null) {
if(!QuadTree._object.exists || (QuadTree._object.allowCollisions <= 0)) {
break;
}
this._checkObject = QuadTree._iterator.object;
if((QuadTree._object === this._checkObject) || !this._checkObject.exists || (this._checkObject.allowCollisions <= 0)) {
QuadTree._iterator = QuadTree._iterator.next;
continue;
}
if(QuadTree._object.collisionMask.checkHullIntersection(this._checkObject.collisionMask)) {
//Execute callback functions if they exist
if((QuadTree._processingCallback == null) || QuadTree._processingCallback(QuadTree._object, this._checkObject)) {
this._overlapProcessed = true;
}
if(this._overlapProcessed && (QuadTree._notifyCallback != null)) {
if(QuadTree._callbackContext !== null) {
QuadTree._notifyCallback.call(QuadTree._callbackContext, QuadTree._object, this._checkObject);
} else {
QuadTree._notifyCallback(QuadTree._object, this._checkObject);
}
}
}
QuadTree._iterator = QuadTree._iterator.next;
}
return this._overlapProcessed;
};
return QuadTree;
})(Phaser.Rectangle);
Phaser.QuadTree = QuadTree;
})(Phaser || (Phaser = {}));
/// State.
*/
function State(game) {
this.game = game;
this.add = game.add;
this.camera = game.camera;
this.cache = game.cache;
//this.collision = game.collision;
this.input = game.input;
this.loader = game.loader;
this.math = game.math;
//this.motion = game.motion;
this.sound = game.sound;
this.stage = game.stage;
this.time = game.time;
this.tweens = game.tweens;
this.world = game.world;
}
State.prototype.init = // Override these in your own States
/**
* Override this method to add some load operations.
* If you need to use the loader, you may need to use them here.
*/
function () {
};
State.prototype.create = /**
* This method is called after the game engine successfully switches states.
* Feel free to add any setup code here.(Do not load anything here, override init() instead)
*/
function () {
};
State.prototype.update = /**
* Put update logic here.
*/
function () {
};
State.prototype.render = /**
* Put render operations here.
*/
function () {
};
State.prototype.paused = /**
* This method will be called when game paused.
*/
function () {
};
State.prototype.destroy = /**
* This method will be called when the state is destroyed
*/
function () {
};
return State;
})();
Phaser.State = State;
/**
* Checks for overlaps between two objects using the world QuadTree. Can be GameObject vs. GameObject, GameObject vs. Group or Group vs. Group.
* Note: Does not take the objects scrollFactor into account. All overlaps are check in world space.
* @param object1 The first GameObject or Group to check. If null the world.group is used.
* @param object2 The second GameObject or Group to check.
* @param notifyCallback A callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you passed them to Collision.overlap.
* @param processCallback A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then notifyCallback will only be called if processCallback returns true.
* @param context The context in which the callbacks will be called
* @returns {boolean} true if the objects overlap, otherwise false.
*/
//public collide(objectOrGroup1 = null, objectOrGroup2 = null, notifyCallback = null, context? = this.game.callbackContext): bool {
// return this.collision.overlap(objectOrGroup1, objectOrGroup2, notifyCallback, Collision.separate, context);
//}
})(Phaser || (Phaser = {}));