planck-js/test/CollisionTest.js

2D physics engine for JavaScript/HTML5 game development

var expect = require('./testutil/expect');
var sinon = require('sinon');

var Vec2 = require('../lib/common/Vec2');
var AABB = require('../lib/collision/AABB');
var DynamicTree = require('../lib/collision/DynamicTree');
var BroadPhase = require('../lib/collision/BroadPhase');

describe('Collision', function() {

  it('AABB', function() {
    var r, o = AABB();
    expect(o.IsValid()).be(true);

    o.upperBound.Set(10, 6);
    o.lowerBound.Set(6, 4);

    r = o.GetCenter();
    expect(r.x).be(8);
    expect(r.y).be(5);

    r = o.GetExtents();
    expect(r.x).be(2);
    expect(r.y).be(1);

    r = o.GetPerimeter();
    expect(r).be(12);

    o.Combine(AABB(Vec2(7, 4), Vec2(9, 6)));
    expect(o.upperBound.x).be(10);
    expect(o.upperBound.y).be(6);
    expect(o.lowerBound.x).be(6);
    expect(o.lowerBound.y).be(4);

    o.Combine(AABB(Vec2(5, 3), Vec2(11, 7)));
    expect(o.upperBound.x).be(11);
    expect(o.upperBound.y).be(7);
    expect(o.lowerBound.x).be(5);
    expect(o.lowerBound.y).be(3);

    expect(o.Contains(AABB(Vec2(5, 3), Vec2(11, 7)))).be(true);
    expect(o.Contains(AABB(Vec2(5, 2), Vec2(11, 7)))).be(false);
    expect(o.Contains(AABB(Vec2(4, 2), Vec2(11, 7)))).be(false);
    expect(o.Contains(AABB(Vec2(5, 3), Vec2(11, 8)))).be(false);
    expect(o.Contains(AABB(Vec2(5, 3), Vec2(12, 7)))).be(false);

    // RayCast
  });

  it('DynamicTree', function() {
    var tree = new DynamicTree();

    var foo = tree.CreateProxy(AABB(Vec2(0, 0), Vec2(1, 1)), 'foo');
    var bar = tree.CreateProxy(AABB(Vec2(1, 1), Vec2(2, 2)), 'bar');
    var baz = tree.CreateProxy(AABB(Vec2(2, 2), Vec2(3, 3)), 'baz');

    expect(tree.GetHeight()).be(2);

    expect(tree.GetUserData(foo)).be('foo');
    expect(tree.GetUserData(bar)).be('bar');
    expect(tree.GetUserData(baz)).be('baz');

    expect(tree.GetFatAABB(foo).upperBound.x).be.above(1);
    expect(tree.GetFatAABB(foo).upperBound.y).be.above(1);
    expect(tree.GetFatAABB(foo).lowerBound.x).be.below(0);
    expect(tree.GetFatAABB(foo).lowerBound.y).be.below(0);

    var QueryCallback = sinon.spy();
    var callback = {
      QueryCallback : QueryCallback
    };

    tree.Query(callback, AABB(Vec2(1, 1), Vec2(2, 2)));
    expect(QueryCallback.calledWith(foo)).be(true);
    expect(QueryCallback.calledWith(bar)).be(true);
    expect(QueryCallback.calledWith(baz)).be(true);

    tree.Query(callback, AABB(Vec2(0.3, 0.3), Vec2(0.7, 0.7)));
    expect(QueryCallback.lastCall.calledWith(foo)).be(true);

    tree.Query(callback, AABB(Vec2(1.3, 1.3), Vec2(1.7, 1.7)));
    expect(QueryCallback.lastCall.calledWith(bar)).be(true);

    tree.Query(callback, AABB(Vec2(2.3, 2.3), Vec2(2.7, 2.7)));
    expect(QueryCallback.lastCall.calledWith(baz)).be(true);

    expect(tree.MoveProxy(foo, AABB(Vec2(0, 0), Vec2(1, 1)), Vec2(0.01, 0.01)))
        .be(false);

    expect(tree.MoveProxy(baz, AABB(Vec2(3, 3), Vec2(4, 4)), Vec2(0, 0))).be(
        true);

    tree.Query(callback, AABB(Vec2(3.3, 3.3), Vec2(3.7, 3.7)));
    expect(QueryCallback.lastCall.calledWith(baz)).be(true);

    tree.DestroyProxy(foo);
    expect(tree.GetHeight()).be(1);

    tree.DestroyProxy(bar);
    expect(tree.GetHeight()).be(0);

    tree.DestroyProxy(baz);
    expect(tree.GetHeight()).be(0);

  });

  it('BroadPhase', function() {
    var bp = new BroadPhase();

    var AddPair = sinon.spy();
    var callback = {
      AddPair : AddPair
    };

    var foo = bp.CreateProxy(AABB(Vec2(0, 0), Vec2(1, 1)), 'foo');
    var bar = bp.CreateProxy(AABB(Vec2(2, 2), Vec2(3, 3)), 'bar');

    bp.UpdatePairs(callback);
    expect(AddPair.callCount).be(0);

    var baz = bp.CreateProxy(AABB(Vec2(1, 1), Vec2(2, 2)), 'baz');

    AddPair.reset();
    bp.UpdatePairs(callback);
    expect(AddPair.callCount).be(2);
    expect(AddPair.calledWith('bar', 'baz')).be(true);
    expect(AddPair.calledWith('foo', 'baz')).be(true);

    bp.MoveProxy(baz, AABB(Vec2(0.5, 0.5), Vec2(1.5, 1.5)), Vec2());

    AddPair.reset();
    bp.UpdatePairs(callback);
    expect(AddPair.callCount).be(1);
    expect(AddPair.calledWith('foo', 'baz')).be(true);

  });

});