Added Spring class. Fixed reason why World wasn't pre and post updating (Stage didn't have an exists property).

Author: photonstorm

Gruntfile.js

@@ -136,6 +136,7 @@ module.exports = function (grunt) {
         'src/physics/World.js',
         'src/physics/PointProxy.js',
         'src/physics/Body.js',
+        'src/physics/Spring.js',
 
         'src/particles/Particles.js',
         'src/particles/arcade/ArcadeParticles.js',

build/config.php

@@ -182,6 +182,7 @@
     <script src="$path/src/physics/World.js"></script>
     <script src="$path/src/physics/PointProxy.js"></script>
     <script src="$path/src/physics/Body.js"></script>
+    <script src="$path/src/physics/Spring.js"></script>
 
     <script src="$path/src/particles/Particles.js"></script>
     <script src="$path/src/particles/arcade/ArcadeParticles.js"></script>

examples/wip/tilesprite fixed to cam.js

@@ -21,6 +21,7 @@ function create() {
     sprite = game.add.tileSprite(100, 100, 200, 200, 'starfield');
     sprite.autoScroll(0, 100);
     sprite.fixedToCamera = true;
+    console.log(sprite.parent);
 
     mushroom = game.add.sprite(400, 400, 'mushroom');
 

src/core/Group.js

@@ -734,7 +734,9 @@ Phaser.Group.prototype.preUpdate = function () {
         return false;
     }
 
-    for (var i = this.children.length - 1; i >= 0; i--)
+   var i = this.children.length;
+
+    while (i--)
     {
         this.children[i].preUpdate();
     }
@@ -750,7 +752,9 @@ Phaser.Group.prototype.preUpdate = function () {
 */
 Phaser.Group.prototype.update = function () {
 
-    for (var i = this.children.length - 1; i >= 0; i--)
+    var i = this.children.length;
+
+    while (i--)
     {
         this.children[i].update();
     }
@@ -771,7 +775,9 @@ Phaser.Group.prototype.postUpdate = function () {
         this.y = this.game.camera.view.y + this.cameraOffset.y;
     }
 
-    for (var i = this.children.length - 1; i >= 0; i--)
+    var i = this.children.length;
+
+    while (i--)
     {
         this.children[i].postUpdate();
     }

src/core/Stage.js

@@ -49,6 +49,12 @@ Phaser.Stage = function (game, width, height) {
     */
     this.checkOffsetInterval = 2500;
 
+    /**
+    * @property {boolean} exists - If exists is true the Stage and all children are updated, otherwise it is skipped.
+    * @default
+    */
+    this.exists = true;
+
     /**
     * @property {number} _nextOffsetCheck - The time to run the next offset check.
     * @private

src/core/World.js

@@ -95,81 +95,6 @@ Phaser.World.prototype.setBounds = function (x, y, width, height) {
 
 }
 
-/**
-* This is called automatically after the plugins preUpdate and before the State.update.
-* Most objects have preUpdate methods and it's where initial movement and positioning is done.
-* 
-* @method Phaser.World#preUpdate
-*/
-Phaser.World.prototype.preUpdate = function () {
-    
-    this.currentRenderOrderID = 0;
-
-    var i = this.children.length;
-
-    while (i--)
-    {
-        this.children[i].preUpdate();
-    }
-
-}
-
-/**
-* This is called automatically after the State.update, but before particles or plugins update.
-* 
-* @method Phaser.World#update
-*/
-Phaser.World.prototype.update = function () {
-
-    var i = this.children.length;
-
-    while (i--)
-    {
-        this.children[i].update();
-    }
-
-}
-
-/**
-* This is called automatically before the renderer runs and after the plugins have updated.
-* In postUpdate this is where all the final physics calculatations and object positioning happens.
-* The objects are processed in the order of the display list.
-* The only exception to this is if the camera is following an object, in which case that is updated first.
-* 
-* @method Phaser.World#postUpdate
-*/
-Phaser.World.prototype.postUpdate = function () {
-
-    if (this.game.world.camera.target)
-    {
-        this.game.world.camera.target.postUpdate();
-
-        this.game.world.camera.update();
-
-        var i = this.children.length;
-
-        while (i--)
-        {
-            if (this.children[i] !== this.game.world.camera.target)
-            {
-                this.children[i].postUpdate();
-            }
-        }
-    }
-    else
-    {
-        this.game.world.camera.update();
-
-        var i = this.children.length;
-
-        while (i--)
-        {
-            this.children[i].postUpdate();
-        }
-    }
-
-}
-
 /**
 * Destroyer of worlds.
 * @method Phaser.World#destroy

src/physics/Spring.js

@@ -0,0 +1,66 @@
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2014 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
+
+/**
+* Creates a spring, connecting two bodies.
+*
+* @class Phaser.Physics.Spring
+* @classdesc Physics Spring Constructor
+* @constructor
+* @param {Phaser.Game} game - A reference to the current game.
+* @param {p2.Body} bodyA - First connected body.
+* @param {p2.Body} bodyB - Second connected body.
+* @param {number} [restLength=1] - Rest length of the spring. A number > 0.
+* @param {number} [stiffness=100] - Stiffness of the spring. A number >= 0.
+* @param {number} [damping=1] - Damping of the spring. A number >= 0.
+* @param {Array} [worldA] - Where to hook the spring to body A, in world coordinates, i.e. [32, 32].
+* @param {Array} [worldB] - Where to hook the spring to body B, in world coordinates, i.e. [32, 32].
+* @param {Array} [localA] - Where to hook the spring to body A, in local body coordinates.
+* @param {Array} [localB] - Where to hook the spring to body B, in local body coordinates.
+*/
+Phaser.Physics.Spring = function (game, bodyA, bodyB, restLength, stiffness, damping, worldA, worldB, localA, localB) {
+
+    /**
+    * @property {Phaser.Game} game - Local reference to game.
+    */
+    this.game = game;
+
+    if (typeof restLength === 'undefined') { restLength = 1; }
+    if (typeof stiffness === 'undefined') { stiffness = 100; }
+    if (typeof damping === 'undefined') { damping = 1; }
+
+    var options = {
+        restLength: restLength,
+        stiffness: stiffness,
+        damping: damping
+    };
+
+    if (typeof worldA !== 'undefined')
+    {
+        options.worldAnchorA = [ game.math.px2p(worldA[0]), game.math.px2p(worldA[1]) ];
+    }
+
+    if (typeof worldB !== 'undefined')
+    {
+        options.worldAnchorB = [ game.math.px2p(worldB[0]), game.math.px2p(worldB[1]) ];
+    }
+
+    if (typeof localA !== 'undefined')
+    {
+        options.localAnchorA = [ game.math.px2p(localA[0]), game.math.px2p(localA[1]) ];
+    }
+
+    if (typeof localB !== 'undefined')
+    {
+        options.localAnchorB = [ game.math.px2p(localB[0]), game.math.px2p(localB[1]) ];
+    }
+
+    p2.Spring.call(this, bodyA, bodyB, options);
+
+}
+
+Phaser.Physics.Spring.prototype = Object.create(p2.Spring.prototype);
+Phaser.Physics.Spring.prototype.constructor = Phaser.Physics.Spring;

src/physics/World.js

@@ -221,3 +221,14 @@ Phaser.Physics.World.prototype.update = function () {
 	this.step(1 / 60);
 
 };
+
+/**
+* @method Phaser.Physics.World.prototype.destroy
+*/
+Phaser.Physics.World.prototype.destroy = function () {
+
+    this.clear();
+
+    this.game = null;
+
+};