Revolute Constraint done.

Author: photonstorm

Gruntfile.js

@@ -207,7 +207,12 @@ module.exports = function (grunt) {
             'src/physics/p2/Spring.js',
             'src/physics/p2/Material.js',
             'src/physics/p2/ContactMaterial.js',
-            'src/physics/p2/CollisionGroup.js'
+            'src/physics/p2/CollisionGroup.js',
+            '/src/physics/p2/DistanceConstraint.js',
+            '/src/physics/p2/GearConstraint.js',
+            '/src/physics/p2/LockConstraint.js',
+            '/src/physics/p2/PrismaticConstraint.js',
+            '/src/physics/p2/RevoluteConstraint.js'
         ],
 
         ninja: [

build/config.php

@@ -158,6 +158,9 @@
     <script src="$path/src/physics/p2/CollisionGroup.js"></script>
     <script src="$path/src/physics/p2/DistanceConstraint.js"></script>
     <script src="$path/src/physics/p2/GearConstraint.js"></script>
+    <script src="$path/src/physics/p2/LockConstraint.js"></script>
+    <script src="$path/src/physics/p2/PrismaticConstraint.js"></script>
+    <script src="$path/src/physics/p2/RevoluteConstraint.js"></script>
 
     <script src="$path/src/particles/Particles.js"></script>
     <script src="$path/src/particles/arcade/ArcadeParticles.js"></script>

examples/p2 physics/revolute constraint.js

@@ -0,0 +1,52 @@
+
+var game = new Phaser.Game(800, 600, Phaser.CANVAS, 'phaser-example', { preload: preload, create: create, update: update });
+
+function preload() {
+
+    game.load.image('vu', 'assets/sprites/vu.png');
+    game.load.image('ball', 'assets/sprites/arrow.png');
+	game.load.image('sky', 'assets/skies/cavern2.png');
+
+}
+
+var sprite;
+var cursors;
+
+function create() {
+
+    game.add.image(0, 0, 'sky');
+
+	//	Enable p2 physics
+	game.physics.startSystem(Phaser.Physics.P2JS);
+
+    //  Add 2 sprites which we'll join with a constraint
+    sprite = game.add.sprite(400, 300, 'ball');
+
+    var vu1 = game.add.sprite(400, 300, 'vu');
+
+	game.physics.p2.enable([sprite, vu1]);
+
+    //  So they don't collide with each other
+    sprite.body.clearCollision(true, true);
+    vu1.body.clearCollision(true, true);
+
+    var constraint = game.physics.p2.createRevoluteConstraint(sprite, [ 50, 100 ], vu1, [ 0, 0 ]);
+
+    text = game.add.text(20, 20, 'rotate with arrow keys', { fill: '#ffffff' });
+
+    cursors = game.input.keyboard.createCursorKeys();
+
+}
+
+function update() {
+
+    if (cursors.left.isDown)
+    {
+    	sprite.body.rotateLeft(50);
+    }
+    else if (cursors.right.isDown)
+    {
+    	sprite.body.rotateRight(50);
+    }
+
+}

src/physics/p2/DistanceConstraint.js

@@ -14,7 +14,7 @@
 * @param {p2.Body} bodyA - First connected body.
 * @param {p2.Body} bodyB - Second connected body.
 * @param {number} distance - The distance to keep between the bodies.
-* @param {number} [maxForce] - The maximum force to apply to the constraint
+* @param {number} [maxForce] - The maximum force that should be applied to constrain the bodies.
 */
 Phaser.Physics.P2.DistanceConstraint = function (world, bodyA, bodyB, distance, maxForce) {
 

src/physics/p2/LockConstraint.js

@@ -0,0 +1,41 @@
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2014 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
+
+/**
+* Connects two bodies at given offset points, letting them rotate relative to each other around this point.
+*
+* @class Phaser.Physics.P2.LockConstraint
+* @classdesc Physics LockConstraint Constructor
+* @constructor
+* @param {Phaser.Physics.P2} world - A reference to the P2 World.
+* @param {p2.Body} bodyA - First connected body.
+* @param {p2.Body} bodyB - Second connected body.
+* @param {number} [angle=0] - The relative angle
+* @param {number} [ratio=1] - The gear ratio.
+*/
+Phaser.Physics.P2.LockConstraint = function (world, bodyA, bodyB, angle, ratio) {
+
+    if (typeof angle === 'undefined') { angle = 0; }
+    if (typeof ratio === 'undefined') { ratio = 1; }
+
+    /**
+    * @property {Phaser.Game} game - Local reference to game.
+    */
+    this.game = world.game;
+
+    /**
+    * @property {Phaser.Physics.P2} world - Local reference to P2 World.
+    */
+    this.world = world;
+
+    var options = { angle: angle, ratio: ratio };
+
+    p2.LockConstraint.call(this, bodyA, bodyB, options);
+
+}
+
+Phaser.Physics.P2.LockConstraint.prototype = Object.create(p2.LockConstraint.prototype);
+Phaser.Physics.P2.LockConstraint.prototype.constructor = Phaser.Physics.P2.LockConstraint;

src/physics/p2/PrismaticConstraint.js

@@ -0,0 +1,41 @@
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2014 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
+
+/**
+* Connects two bodies at given offset points, letting them rotate relative to each other around this point.
+*
+* @class Phaser.Physics.P2.PrismaticConstraint
+* @classdesc Physics PrismaticConstraint Constructor
+* @constructor
+* @param {Phaser.Physics.P2} world - A reference to the P2 World.
+* @param {p2.Body} bodyA - First connected body.
+* @param {p2.Body} bodyB - Second connected body.
+* @param {number} [angle=0] - The relative angle
+* @param {number} [ratio=1] - The gear ratio.
+*/
+Phaser.Physics.P2.PrismaticConstraint = function (world, bodyA, bodyB, angle, ratio) {
+
+    if (typeof angle === 'undefined') { angle = 0; }
+    if (typeof ratio === 'undefined') { ratio = 1; }
+
+    /**
+    * @property {Phaser.Game} game - Local reference to game.
+    */
+    this.game = world.game;
+
+    /**
+    * @property {Phaser.Physics.P2} world - Local reference to P2 World.
+    */
+    this.world = world;
+
+    var options = { angle: angle, ratio: ratio };
+
+    p2.PrismaticConstraint.call(this, bodyA, bodyB, options);
+
+}
+
+Phaser.Physics.P2.PrismaticConstraint.prototype = Object.create(p2.PrismaticConstraint.prototype);
+Phaser.Physics.P2.PrismaticConstraint.prototype.constructor = Phaser.Physics.P2.PrismaticConstraint;

src/physics/p2/RevoluteConstraint.js

@@ -0,0 +1,43 @@
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2014 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
+
+/**
+* Connects two bodies at given offset points, letting them rotate relative to each other around this point.
+* The pivot points are given in world (pixel) coordinates.
+*
+* @class Phaser.Physics.P2.RevoluteConstraint
+* @classdesc Physics RevoluteConstraint Constructor
+* @constructor
+* @param {Phaser.Physics.P2} world - A reference to the P2 World.
+* @param {p2.Body} bodyA - First connected body.
+* @param {Float32Array} pivotA - The point relative to the center of mass of bodyA which bodyA is constrained to. The value is an array with 2 elements matching x and y, i.e: [32, 32].
+* @param {p2.Body} bodyB - Second connected body.
+* @param {Float32Array} pivotB - The point relative to the center of mass of bodyB which bodyB is constrained to. The value is an array with 2 elements matching x and y, i.e: [32, 32].
+* @param {number} [maxForce=0] - The maximum force that should be applied to constrain the bodies.
+*/
+Phaser.Physics.P2.RevoluteConstraint = function (world, bodyA, pivotA, bodyB, pivotB, maxForce) {
+
+    if (typeof maxForce === 'undefined') { maxForce = Number.MAX_VALUE; }
+
+    /**
+    * @property {Phaser.Game} game - Local reference to game.
+    */
+    this.game = world.game;
+
+    /**
+    * @property {Phaser.Physics.P2} world - Local reference to P2 World.
+    */
+    this.world = world;
+
+    pivotA = [ world.pxm(pivotA[0]), world.pxm(pivotA[1]) ];
+    pivotB = [ world.pxm(pivotB[0]), world.pxm(pivotB[1]) ];
+
+    p2.RevoluteConstraint.call(this, bodyA, pivotA, bodyB, pivotB, maxForce);
+
+}
+
+Phaser.Physics.P2.RevoluteConstraint.prototype = Object.create(p2.RevoluteConstraint.prototype);
+Phaser.Physics.P2.RevoluteConstraint.prototype.constructor = Phaser.Physics.P2.RevoluteConstraint;

src/physics/p2/Spring.js

@@ -16,10 +16,10 @@
 * @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. This value is an array by 2 elements, x and y, i.e: [32, 32].
-* @param {Array} [worldB] - Where to hook the spring to body B in world coordinates. This value is an array by 2 elements, x and y, i.e: [32, 32].
-* @param {Array} [localA] - Where to hook the spring to body A in local body coordinates. This value is an array by 2 elements, x and y, i.e: [32, 32].
-* @param {Array} [localB] - Where to hook the spring to body B in local body coordinates. This value is an array by 2 elements, x and y, i.e: [32, 32].
+* @param {Array} [worldA] - Where to hook the spring to body A in world coordinates. This value is an array with 2 elements matching x and y, i.e: [32, 32].
+* @param {Array} [worldB] - Where to hook the spring to body B in world coordinates. This value is an array with 2 elements matching x and y, i.e: [32, 32].
+* @param {Array} [localA] - Where to hook the spring to body A in local body coordinates. This value is an array with 2 elements matching x and y, i.e: [32, 32].
+* @param {Array} [localB] - Where to hook the spring to body B in local body coordinates. This value is an array with 2 elements matching x and y, i.e: [32, 32].
 */
 Phaser.Physics.P2.Spring = function (world, bodyA, bodyB, restLength, stiffness, damping, worldA, worldB, localA, localB) {
 

src/physics/p2/World.js

@@ -702,7 +702,7 @@ Phaser.Physics.P2.prototype = {
     * @param {Phaser.Sprite|Phaser.Physics.P2.Body|p2.Body} bodyA - First connected body.
     * @param {Phaser.Sprite|Phaser.Physics.P2.Body|p2.Body} bodyB - Second connected body.
     * @param {number} distance - The distance to keep between the bodies.
-    * @param {number} [maxForce] - The maximum force to apply to the constraint
+    * @param {number} [maxForce] - The maximum force that should be applied to constrain the bodies.
     * @return {Phaser.Physics.P2.DistanceConstraint} The constraint
     */
     createDistanceConstraint: function (bodyA, bodyB, distance, maxForce) {
@@ -747,6 +747,34 @@ Phaser.Physics.P2.prototype = {
 
     },
 
+    /**
+    * Connects two bodies at given offset points, letting them rotate relative to each other around this point.
+    * The pivot points are given in world (pixel) coordinates.
+    *
+    * @method Phaser.Physics.P2#createRevoluteConstraint
+    * @param {p2.Body} bodyA - First connected body.
+    * @param {Float32Array} pivotA - The point relative to the center of mass of bodyA which bodyA is constrained to. The value is an array with 2 elements matching x and y, i.e: [32, 32].
+    * @param {p2.Body} bodyB - Second connected body.
+    * @param {Float32Array} pivotB - The point relative to the center of mass of bodyB which bodyB is constrained to. The value is an array with 2 elements matching x and y, i.e: [32, 32].
+    * @param {number} [maxForce=0] - The maximum force that should be applied to constrain the bodies.
+    * @return {Phaser.Physics.P2.RevoluteConstraint} The constraint
+    */
+    createRevoluteConstraint: function (bodyA, pivotA, bodyB, pivotB, maxForce) {
+
+        bodyA = this.getBody(bodyA);
+        bodyB = this.getBody(bodyB);
+
+        if (!bodyA || !bodyB)
+        {
+            console.warn('Cannot create Constraint, invalid body objects given');
+        }
+        else
+        {
+            return this.addConstraint(new Phaser.Physics.P2.RevoluteConstraint(this, bodyA, pivotA, bodyB, pivotB, maxForce));
+        }
+
+    },
+
     /**
     * Adds a Constraint to the world.
     *