2013-09-11 12:21:07 +00:00
|
|
|
/**
|
2013-09-19 11:17:49 +00:00
|
|
|
* @author Richard Davey <rich@photonstorm.com>
|
2014-02-05 05:54:25 +00:00
|
|
|
* @copyright 2014 Photon Storm Ltd.
|
2013-10-01 12:54:29 +00:00
|
|
|
* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
|
2013-09-19 11:17:49 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2013-10-04 13:41:15 +00:00
|
|
|
* "This world is but a canvas to our imagination." - Henry David Thoreau
|
|
|
|
*
|
|
|
|
* A game has only one world. The world is an abstract place in which all game objects live. It is not bound
|
|
|
|
* by stage limits and can be any size. You look into the world via cameras. All game objects live within
|
|
|
|
* the world at world-based coordinates. By default a world is created the same size as your Stage.
|
|
|
|
*
|
|
|
|
* @class Phaser.World
|
2013-12-03 02:13:57 +00:00
|
|
|
* @extends Phaser.Group
|
2013-10-04 13:41:15 +00:00
|
|
|
* @constructor
|
|
|
|
* @param {Phaser.Game} game - Reference to the current game instance.
|
|
|
|
*/
|
2013-08-29 20:57:36 +00:00
|
|
|
Phaser.World = function (game) {
|
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
Phaser.Group.call(this, game, null, '__world', false);
|
|
|
|
|
2013-09-11 12:21:07 +00:00
|
|
|
/**
|
2013-10-04 13:41:15 +00:00
|
|
|
* The World has no fixed size, but it does have a bounds outside of which objects are no longer considered as being "in world" and you should use this to clean-up the display list and purge dead objects.
|
|
|
|
* By default we set the Bounds to be from 0,0 to Game.width,Game.height. I.e. it will match the size given to the game constructor with 0,0 representing the top-left of the display.
|
|
|
|
* However 0,0 is actually the center of the world, and if you rotate or scale the world all of that will happen from 0,0.
|
|
|
|
* So if you want to make a game in which the world itself will rotate you should adjust the bounds so that 0,0 is the center point, i.e. set them to -1000,-1000,2000,2000 for a 2000x2000 sized world centered around 0,0.
|
2013-11-25 03:13:04 +00:00
|
|
|
* @property {Phaser.Rectangle} bounds - Bound of this world that objects can not escape from.
|
|
|
|
*/
|
|
|
|
this.bounds = new Phaser.Rectangle(0, 0, game.width, game.height);
|
2013-09-10 19:40:34 +00:00
|
|
|
|
2013-09-11 12:21:07 +00:00
|
|
|
/**
|
2013-11-25 03:13:04 +00:00
|
|
|
* @property {Phaser.Camera} camera - Camera instance.
|
|
|
|
*/
|
|
|
|
this.camera = null;
|
2014-03-23 07:59:28 +00:00
|
|
|
|
2014-03-23 08:29:04 +00:00
|
|
|
};
|
2013-08-29 20:57:36 +00:00
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
Phaser.World.prototype = Object.create(Phaser.Group.prototype);
|
|
|
|
Phaser.World.prototype.constructor = Phaser.World;
|
2013-08-29 20:57:36 +00:00
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
/**
|
|
|
|
* Initialises the game world.
|
|
|
|
*
|
|
|
|
* @method Phaser.World#boot
|
|
|
|
* @protected
|
|
|
|
*/
|
|
|
|
Phaser.World.prototype.boot = function () {
|
2013-08-31 12:54:59 +00:00
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
this.camera = new Phaser.Camera(this.game, 0, 0, 0, this.game.width, this.game.height);
|
2013-10-03 22:20:24 +00:00
|
|
|
|
2014-02-06 02:31:36 +00:00
|
|
|
this.camera.displayObject = this;
|
2013-09-06 19:20:58 +00:00
|
|
|
|
2014-03-06 17:12:00 +00:00
|
|
|
this.camera.scale = this.scale;
|
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
this.game.camera = this.camera;
|
2013-09-06 19:20:58 +00:00
|
|
|
|
2014-02-12 19:45:09 +00:00
|
|
|
this.game.stage.addChild(this);
|
2014-02-06 02:31:36 +00:00
|
|
|
|
2014-03-23 08:29:04 +00:00
|
|
|
};
|
2013-08-29 20:57:36 +00:00
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
/**
|
|
|
|
* Updates the size of this world. Note that this doesn't modify the world x/y coordinates, just the width and height.
|
2013-12-06 04:34:27 +00:00
|
|
|
*
|
2013-10-09 03:31:08 +00:00
|
|
|
* @method Phaser.World#setBounds
|
|
|
|
* @param {number} x - Top left most corner of the world.
|
|
|
|
* @param {number} y - Top left most corner of the world.
|
2014-01-31 03:32:12 +00:00
|
|
|
* @param {number} width - New width of the world. Can never be smaller than the Game.width.
|
|
|
|
* @param {number} height - New height of the world. Can never be smaller than the Game.height.
|
2013-10-04 15:51:24 +00:00
|
|
|
*/
|
|
|
|
Phaser.World.prototype.setBounds = function (x, y, width, height) {
|
2013-08-29 20:57:36 +00:00
|
|
|
|
2014-01-29 17:10:13 +00:00
|
|
|
if (width < this.game.width)
|
|
|
|
{
|
|
|
|
width = this.game.width;
|
|
|
|
}
|
2013-12-06 04:34:27 +00:00
|
|
|
|
2014-01-29 17:10:13 +00:00
|
|
|
if (height < this.game.height)
|
|
|
|
{
|
|
|
|
height = this.game.height;
|
|
|
|
}
|
2013-12-06 04:34:27 +00:00
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
this.bounds.setTo(x, y, width, height);
|
2013-08-29 20:57:36 +00:00
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
if (this.camera.bounds)
|
|
|
|
{
|
2013-12-06 04:34:27 +00:00
|
|
|
// The Camera can never be smaller than the game size
|
2013-10-04 15:51:24 +00:00
|
|
|
this.camera.bounds.setTo(x, y, width, height);
|
|
|
|
}
|
2013-09-13 04:44:04 +00:00
|
|
|
|
2014-03-11 15:02:59 +00:00
|
|
|
this.game.physics.setBoundsToWorld();
|
2014-02-05 05:54:25 +00:00
|
|
|
|
2014-03-23 08:29:04 +00:00
|
|
|
};
|
2013-09-13 04:44:04 +00:00
|
|
|
|
2013-10-04 15:51:24 +00:00
|
|
|
/**
|
|
|
|
* Destroyer of worlds.
|
2014-03-19 12:05:19 +00:00
|
|
|
*
|
2014-03-19 00:54:49 +00:00
|
|
|
* @method Phaser.World#shutdown
|
2013-10-04 15:51:24 +00:00
|
|
|
*/
|
2014-03-19 00:54:49 +00:00
|
|
|
Phaser.World.prototype.shutdown = function () {
|
2013-09-13 04:44:04 +00:00
|
|
|
|
2014-03-19 00:54:49 +00:00
|
|
|
// World is a Group, so run a soft destruction on this and all children.
|
|
|
|
this.destroy(true, true);
|
2013-10-04 15:51:24 +00:00
|
|
|
|
2014-03-23 08:29:04 +00:00
|
|
|
};
|
2013-08-29 20:57:36 +00:00
|
|
|
|
2014-04-16 21:59:19 +00:00
|
|
|
/**
|
|
|
|
* This will take the given game object and check if its x/y coordinates fall outside of the world bounds.
|
|
|
|
* If they do it will reposition the object to the opposite side of the world, creating a wrap-around effect.
|
|
|
|
*
|
|
|
|
* @method Phaser.World#wrap
|
|
|
|
* @param {Phaser.Sprite|Phaser.Image|Phaser.TileSprite|Phaser.Text} sprite - The object you wish to wrap around the world bounds.
|
|
|
|
* @param {number} [padding=0] - Extra padding added equally to the sprite.x and y coordinates before checking if within the world bounds. Ignored if useBounds is true.
|
|
|
|
* @param {boolean} [useBounds=false] - If useBounds is false wrap checks the object.x/y coordinates. If true it does a more accurate bounds check, which is more expensive.
|
2014-07-10 06:05:50 +00:00
|
|
|
* @param {boolean} [horizontal=true] - If horizontal is false, wrap will not wrap the object.x coordinates horizontally.
|
|
|
|
* @param {boolean} [vertical=true] - If vertical is false, wrap will not wrap the object.y coordinates vertically.
|
2014-04-16 21:59:19 +00:00
|
|
|
*/
|
2014-07-10 06:05:50 +00:00
|
|
|
Phaser.World.prototype.wrap = function (sprite, padding, useBounds, horizontal, vertical) {
|
2014-04-16 21:59:19 +00:00
|
|
|
|
|
|
|
if (typeof padding === 'undefined') { padding = 0; }
|
|
|
|
if (typeof useBounds === 'undefined') { useBounds = false; }
|
2014-07-10 06:05:50 +00:00
|
|
|
if (typeof horizontal === 'undefined') { horizontal = true; }
|
|
|
|
if (typeof vertical === 'undefined') { vertical = true; }
|
2014-04-16 21:59:19 +00:00
|
|
|
|
|
|
|
if (!useBounds)
|
|
|
|
{
|
2014-07-10 06:05:50 +00:00
|
|
|
if (horizontal && sprite.x + padding < this.bounds.x)
|
2014-04-16 21:59:19 +00:00
|
|
|
{
|
|
|
|
sprite.x = this.bounds.right + padding;
|
|
|
|
}
|
2014-07-10 06:05:50 +00:00
|
|
|
else if (horizontal && sprite.x - padding > this.bounds.right)
|
2014-04-16 21:59:19 +00:00
|
|
|
{
|
|
|
|
sprite.x = this.bounds.left - padding;
|
|
|
|
}
|
|
|
|
|
2014-07-10 06:05:50 +00:00
|
|
|
if (vertical && sprite.y + padding < this.bounds.top)
|
2014-04-16 21:59:19 +00:00
|
|
|
{
|
|
|
|
sprite.y = this.bounds.bottom + padding;
|
|
|
|
}
|
2014-07-10 06:05:50 +00:00
|
|
|
else if (vertical && sprite.y - padding > this.bounds.bottom)
|
2014-04-16 21:59:19 +00:00
|
|
|
{
|
|
|
|
sprite.y = this.bounds.top - padding;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sprite.getBounds();
|
|
|
|
|
2014-07-15 13:22:06 +00:00
|
|
|
if (horizontal)
|
2014-04-16 21:59:19 +00:00
|
|
|
{
|
2014-07-15 13:22:06 +00:00
|
|
|
if ((sprite.x + sprite._currentBounds.width) < this.bounds.x)
|
|
|
|
{
|
|
|
|
sprite.x = this.bounds.right;
|
|
|
|
}
|
|
|
|
else if (sprite.x > this.bounds.right)
|
|
|
|
{
|
|
|
|
sprite.x = this.bounds.left;
|
|
|
|
}
|
2014-04-16 21:59:19 +00:00
|
|
|
}
|
|
|
|
|
2014-07-15 13:22:06 +00:00
|
|
|
if (vertical)
|
2014-04-16 21:59:19 +00:00
|
|
|
{
|
2014-07-15 13:22:06 +00:00
|
|
|
if ((sprite.y + sprite._currentBounds.height) < this.bounds.top)
|
|
|
|
{
|
|
|
|
sprite.y = this.bounds.bottom;
|
|
|
|
}
|
|
|
|
else if (sprite.y > this.bounds.bottom)
|
|
|
|
{
|
|
|
|
sprite.y = this.bounds.top;
|
|
|
|
}
|
2014-04-16 21:59:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2013-10-01 12:54:29 +00:00
|
|
|
/**
|
2013-10-02 11:11:22 +00:00
|
|
|
* @name Phaser.World#width
|
|
|
|
* @property {number} width - Gets or sets the current width of the game world.
|
2013-10-01 12:54:29 +00:00
|
|
|
*/
|
2013-08-29 20:57:36 +00:00
|
|
|
Object.defineProperty(Phaser.World.prototype, "width", {
|
|
|
|
|
|
|
|
get: function () {
|
|
|
|
return this.bounds.width;
|
|
|
|
},
|
|
|
|
|
|
|
|
set: function (value) {
|
|
|
|
this.bounds.width = value;
|
2013-09-11 12:21:07 +00:00
|
|
|
}
|
2013-08-29 20:57:36 +00:00
|
|
|
|
|
|
|
});
|
|
|
|
|
2013-10-01 12:54:29 +00:00
|
|
|
/**
|
2013-10-02 11:11:22 +00:00
|
|
|
* @name Phaser.World#height
|
|
|
|
* @property {number} height - Gets or sets the current height of the game world.
|
2013-10-01 12:54:29 +00:00
|
|
|
*/
|
2013-08-29 20:57:36 +00:00
|
|
|
Object.defineProperty(Phaser.World.prototype, "height", {
|
|
|
|
|
|
|
|
get: function () {
|
|
|
|
return this.bounds.height;
|
|
|
|
},
|
|
|
|
|
|
|
|
set: function (value) {
|
|
|
|
this.bounds.height = value;
|
2013-09-11 12:21:07 +00:00
|
|
|
}
|
2013-08-29 20:57:36 +00:00
|
|
|
|
|
|
|
});
|
|
|
|
|
2013-10-01 12:54:29 +00:00
|
|
|
/**
|
2013-10-02 11:11:22 +00:00
|
|
|
* @name Phaser.World#centerX
|
|
|
|
* @property {number} centerX - Gets the X position corresponding to the center point of the world.
|
|
|
|
* @readonly
|
2013-10-01 12:54:29 +00:00
|
|
|
*/
|
2013-08-29 20:57:36 +00:00
|
|
|
Object.defineProperty(Phaser.World.prototype, "centerX", {
|
|
|
|
|
|
|
|
get: function () {
|
|
|
|
return this.bounds.halfWidth;
|
2013-09-11 12:21:07 +00:00
|
|
|
}
|
2013-08-29 20:57:36 +00:00
|
|
|
|
|
|
|
});
|
|
|
|
|
2013-10-01 12:54:29 +00:00
|
|
|
/**
|
2013-10-02 11:11:22 +00:00
|
|
|
* @name Phaser.World#centerY
|
|
|
|
* @property {number} centerY - Gets the Y position corresponding to the center point of the world.
|
|
|
|
* @readonly
|
2013-10-01 12:54:29 +00:00
|
|
|
*/
|
2013-08-29 20:57:36 +00:00
|
|
|
Object.defineProperty(Phaser.World.prototype, "centerY", {
|
|
|
|
|
|
|
|
get: function () {
|
|
|
|
return this.bounds.halfHeight;
|
2013-09-11 12:21:07 +00:00
|
|
|
}
|
2013-08-29 20:57:36 +00:00
|
|
|
|
|
|
|
});
|
|
|
|
|
2013-10-01 12:54:29 +00:00
|
|
|
/**
|
2013-10-02 11:11:22 +00:00
|
|
|
* @name Phaser.World#randomX
|
|
|
|
* @property {number} randomX - Gets a random integer which is lesser than or equal to the current width of the game world.
|
|
|
|
* @readonly
|
2013-10-01 12:54:29 +00:00
|
|
|
*/
|
2013-08-29 20:57:36 +00:00
|
|
|
Object.defineProperty(Phaser.World.prototype, "randomX", {
|
|
|
|
|
|
|
|
get: function () {
|
2013-10-09 06:11:36 +00:00
|
|
|
|
|
|
|
if (this.bounds.x < 0)
|
|
|
|
{
|
|
|
|
return this.game.rnd.integerInRange(this.bounds.x, (this.bounds.width - Math.abs(this.bounds.x)));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return this.game.rnd.integerInRange(this.bounds.x, this.bounds.width);
|
|
|
|
}
|
|
|
|
|
2013-09-11 12:21:07 +00:00
|
|
|
}
|
2013-08-29 20:57:36 +00:00
|
|
|
|
|
|
|
});
|
|
|
|
|
2013-10-01 12:54:29 +00:00
|
|
|
/**
|
2013-10-02 11:11:22 +00:00
|
|
|
* @name Phaser.World#randomY
|
|
|
|
* @property {number} randomY - Gets a random integer which is lesser than or equal to the current height of the game world.
|
|
|
|
* @readonly
|
2013-10-01 12:54:29 +00:00
|
|
|
*/
|
2013-08-29 20:57:36 +00:00
|
|
|
Object.defineProperty(Phaser.World.prototype, "randomY", {
|
|
|
|
|
|
|
|
get: function () {
|
2013-10-09 06:11:36 +00:00
|
|
|
|
|
|
|
if (this.bounds.y < 0)
|
|
|
|
{
|
|
|
|
return this.game.rnd.integerInRange(this.bounds.y, (this.bounds.height - Math.abs(this.bounds.y)));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return this.game.rnd.integerInRange(this.bounds.y, this.bounds.height);
|
|
|
|
}
|
|
|
|
|
2013-09-11 12:21:07 +00:00
|
|
|
}
|
2013-08-29 20:57:36 +00:00
|
|
|
|
|
|
|
});
|