Google Git
Sign in
webkit / WebKit / 8a553b8b6e6f8aa06723780a0354024d0cbde779 / . / JSTests / ChakraCore / test / benchmarks / Octane / box2d.js
blob: 3ac37a2e79a88e88d24a4f9910939ce37121a812 [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
// base.js
////////////////////////////////////////////////////////////////////////////////
// Copyright 2013 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
if(typeof(WScript) === "undefined")
{
var WScript = {
Echo: print
}
}
// Performance.now is used in latency benchmarks, the fallback is Date.now.
var performance = performance || {};
performance.now = (function() {
return performance.now ||
performance.mozNow ||
performance.msNow ||
performance.oNow ||
performance.webkitNow ||
Date.now;
})();
// Simple framework for running the benchmark suites and
// computing a score based on the timing measurements.
// A benchmark has a name (string) and a function that will be run to
// do the performance measurement. The optional setup and tearDown
// arguments are functions that will be invoked before and after
// running the benchmark, but the running time of these functions will
// not be accounted for in the benchmark score.
function Benchmark(name, doWarmup, doDeterministic, deterministicIterations,
run, setup, tearDown, rmsResult, minIterations) {
this.name = name;
this.doWarmup = doWarmup;
this.doDeterministic = doDeterministic;
this.deterministicIterations = deterministicIterations;
this.run = run;
this.Setup = setup ? setup : function() { };
this.TearDown = tearDown ? tearDown : function() { };
this.rmsResult = rmsResult ? rmsResult : null;
this.minIterations = minIterations ? minIterations : 32;
}
// Benchmark results hold the benchmark and the measured time used to
// run the benchmark. The benchmark score is computed later once a
// full benchmark suite has run to completion. If latency is set to 0
// then there is no latency score for this benchmark.
function BenchmarkResult(benchmark, time, latency) {
this.benchmark = benchmark;
this.time = time;
this.latency = latency;
}
// Automatically convert results to numbers. Used by the geometric
// mean computation.
BenchmarkResult.prototype.valueOf = function() {
return this.time;
}
// Suites of benchmarks consist of a name and the set of benchmarks in
// addition to the reference timing that the final score will be based
// on. This way, all scores are relative to a reference run and higher
// scores implies better performance.
function BenchmarkSuite(name, reference, benchmarks) {
this.name = name;
this.reference = reference;
this.benchmarks = benchmarks;
BenchmarkSuite.suites.push(this);
}
// Keep track of all declared benchmark suites.
BenchmarkSuite.suites = [];
// Scores are not comparable across versions. Bump the version if
// you're making changes that will affect that scores, e.g. if you add
// a new benchmark or change an existing one.
BenchmarkSuite.version = '9';
// Defines global benchsuite running mode that overrides benchmark suite
// behavior. Intended to be set by the benchmark driver. Undefined
// values here allow a benchmark to define behaviour itself.
BenchmarkSuite.config = {
doWarmup: undefined,
doDeterministic: undefined
};
// Override the alert function to throw an exception instead.
alert = function(s) {
throw "Alert called with argument: " + s;
};
// To make the benchmark results predictable, we replace Math.random
// with a 100% deterministic alternative.
BenchmarkSuite.ResetRNG = function() {
Math.random = (function() {
var seed = 49734321;
return function() {
// Robert Jenkins' 32 bit integer hash function.
seed = ((seed + 0x7ed55d16) + (seed << 12)) & 0xffffffff;
seed = ((seed ^ 0xc761c23c) ^ (seed >>> 19)) & 0xffffffff;
seed = ((seed + 0x165667b1) + (seed << 5)) & 0xffffffff;
seed = ((seed + 0xd3a2646c) ^ (seed << 9)) & 0xffffffff;
seed = ((seed + 0xfd7046c5) + (seed << 3)) & 0xffffffff;
seed = ((seed ^ 0xb55a4f09) ^ (seed >>> 16)) & 0xffffffff;
return (seed & 0xfffffff) / 0x10000000;
};
})();
}
// Runs all registered benchmark suites and optionally yields between
// each individual benchmark to avoid running for too long in the
// context of browsers. Once done, the final score is reported to the
// runner.
BenchmarkSuite.RunSuites = function(runner, skipBenchmarks) {
skipBenchmarks = typeof skipBenchmarks === 'undefined' ? [] : skipBenchmarks;
var continuation = null;
var suites = BenchmarkSuite.suites;
var length = suites.length;
BenchmarkSuite.scores = [];
var index = 0;
function RunStep() {
while (continuation || index < length) {
if (continuation) {
continuation = continuation();
} else {
var suite = suites[index++];
if (runner.NotifyStart) runner.NotifyStart(suite.name);
if (skipBenchmarks.indexOf(suite.name) > -1) {
suite.NotifySkipped(runner);
} else {
continuation = suite.RunStep(runner);
}
}
if (continuation && typeof window != 'undefined' && window.setTimeout) {
window.setTimeout(RunStep, 25);
return;
}
}
// show final result
if (runner.NotifyScore) {
var score = BenchmarkSuite.GeometricMean(BenchmarkSuite.scores);
var formatted = BenchmarkSuite.FormatScore(100 * score);
runner.NotifyScore(formatted);
}
}
RunStep();
}
// Counts the total number of registered benchmarks. Useful for
// showing progress as a percentage.
BenchmarkSuite.CountBenchmarks = function() {
var result = 0;
var suites = BenchmarkSuite.suites;
for (var i = 0; i < suites.length; i++) {
result += suites[i].benchmarks.length;
}
return result;
}
// Computes the geometric mean of a set of numbers.
BenchmarkSuite.GeometricMean = function(numbers) {
var log = 0;
for (var i = 0; i < numbers.length; i++) {
log += Math.log(numbers[i]);
}
return Math.pow(Math.E, log / numbers.length);
}
// Computes the geometric mean of a set of throughput time measurements.
BenchmarkSuite.GeometricMeanTime = function(measurements) {
var log = 0;
for (var i = 0; i < measurements.length; i++) {
log += Math.log(measurements[i].time);
}
return Math.pow(Math.E, log / measurements.length);
}
// Computes the geometric mean of a set of rms measurements.
BenchmarkSuite.GeometricMeanLatency = function(measurements) {
var log = 0;
var hasLatencyResult = false;
for (var i = 0; i < measurements.length; i++) {
if (measurements[i].latency != 0) {
log += Math.log(measurements[i].latency);
hasLatencyResult = true;
}
}
if (hasLatencyResult) {
return Math.pow(Math.E, log / measurements.length);
} else {
return 0;
}
}
// Converts a score value to a string with at least three significant
// digits.
BenchmarkSuite.FormatScore = function(value) {
if (value > 100) {
return value.toFixed(0);
} else {
return value.toPrecision(3);
}
}
// Notifies the runner that we're done running a single benchmark in
// the benchmark suite. This can be useful to report progress.
BenchmarkSuite.prototype.NotifyStep = function(result) {
this.results.push(result);
if (this.runner.NotifyStep) this.runner.NotifyStep(result.benchmark.name);
}
// Notifies the runner that we're done with running a suite and that
// we have a result which can be reported to the user if needed.
BenchmarkSuite.prototype.NotifyResult = function() {
var mean = BenchmarkSuite.GeometricMeanTime(this.results);
var score = this.reference[0] / mean;
BenchmarkSuite.scores.push(score);
if (this.runner.NotifyResult) {
var formatted = BenchmarkSuite.FormatScore(100 * score);
this.runner.NotifyResult(this.name, formatted);
}
if (this.reference.length == 2) {
var meanLatency = BenchmarkSuite.GeometricMeanLatency(this.results);
if (meanLatency != 0) {
var scoreLatency = this.reference[1] / meanLatency;
BenchmarkSuite.scores.push(scoreLatency);
if (this.runner.NotifyResult) {
var formattedLatency = BenchmarkSuite.FormatScore(100 * scoreLatency)
this.runner.NotifyResult(this.name + "Latency", formattedLatency);
}
}
}
}
BenchmarkSuite.prototype.NotifySkipped = function(runner) {
BenchmarkSuite.scores.push(1); // push default reference score.
if (runner.NotifyResult) {
runner.NotifyResult(this.name, "Skipped");
}
}
// Notifies the runner that running a benchmark resulted in an error.
BenchmarkSuite.prototype.NotifyError = function(error) {
if (this.runner.NotifyError) {
this.runner.NotifyError(this.name, error);
}
if (this.runner.NotifyStep) {
this.runner.NotifyStep(this.name);
}
}
// Runs a single benchmark for at least a second and computes the
// average time it takes to run a single iteration.
BenchmarkSuite.prototype.RunSingleBenchmark = function(benchmark, data) {
var config = BenchmarkSuite.config;
var doWarmup = config.doWarmup !== undefined
? config.doWarmup
: benchmark.doWarmup;
var doDeterministic = config.doDeterministic !== undefined
? config.doDeterministic
: benchmark.doDeterministic;
function Measure(data) {
var elapsed = 0;
var start = new Date();
// Run either for 1 second or for the number of iterations specified
// by minIterations, depending on the config flag doDeterministic.
for (var i = 0; (doDeterministic ?
i<benchmark.deterministicIterations : elapsed < 1000); i++) {
benchmark.run();
elapsed = new Date() - start;
}
if (data != null) {
data.runs += i;
data.elapsed += elapsed;
}
}
// Sets up data in order to skip or not the warmup phase.
if (!doWarmup && data == null) {
data = { runs: 0, elapsed: 0 };
}
if (data == null) {
Measure(null);
return { runs: 0, elapsed: 0 };
} else {
Measure(data);
// If we've run too few iterations, we continue for another second.
if (data.runs < benchmark.minIterations) return data;
var usec = (data.elapsed * 1000) / data.runs;
var rms = (benchmark.rmsResult != null) ? benchmark.rmsResult() : 0;
this.NotifyStep(new BenchmarkResult(benchmark, usec, rms));
return null;
}
}
// This function starts running a suite, but stops between each
// individual benchmark in the suite and returns a continuation
// function which can be invoked to run the next benchmark. Once the
// last benchmark has been executed, null is returned.
BenchmarkSuite.prototype.RunStep = function(runner) {
BenchmarkSuite.ResetRNG();
this.results = [];
this.runner = runner;
var length = this.benchmarks.length;
var index = 0;
var suite = this;
var data;
// Run the setup, the actual benchmark, and the tear down in three
// separate steps to allow the framework to yield between any of the
// steps.
function RunNextSetup() {
if (index < length) {
try {
suite.benchmarks[index].Setup();
} catch (e) {
suite.NotifyError(e);
return null;
}
return RunNextBenchmark;
}
suite.NotifyResult();
return null;
}
function RunNextBenchmark() {
try {
data = suite.RunSingleBenchmark(suite.benchmarks[index], data);
} catch (e) {
suite.NotifyError(e);
return null;
}
// If data is null, we're done with this benchmark.
return (data == null) ? RunNextTearDown : RunNextBenchmark();
}
function RunNextTearDown() {
try {
suite.benchmarks[index++].TearDown();
} catch (e) {
suite.NotifyError(e);
return null;
}
return RunNextSetup;
}
// Start out running the setup.
return RunNextSetup();
}
/////////////////////////////////////////////////////////////
// box2d.js
/////////////////////////////////////////////////////////////
// Portions copyright 2013 Google, Inc
/*
* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
/*
* Following code is beautified using http://jsbeautifier.org/
*/
var Box2D = {};
(function (F, G) {
function K() {}
if (!(Object.defineProperty instanceof Function) && Object.prototype.__defineGetter__ instanceof Function && Object.prototype.__defineSetter__ instanceof Function) Object.defineProperty = function (y, w, A) {
A.get instanceof Function && y.__defineGetter__(w, A.get);
A.set instanceof Function && y.__defineSetter__(w, A.set)
};
F.inherit = function (y, w) {
K.prototype = w.prototype;
y.prototype = new K;
y.prototype.constructor = y
};
F.generateCallback = function (y, w) {
return function () {
w.apply(y, arguments)
}
};
F.NVector = function (y) {
if (y === G) y = 0;
for (var w = Array(y || 0), A = 0; A < y; ++A) w[A] = 0;
return w
};
F.is = function (y, w) {
if (y === null) return false;
if (w instanceof Function && y instanceof w) return true;
if (y.constructor.__implements != G && y.constructor.__implements[w]) return true;
return false
};
F.parseUInt = function (y) {
return Math.abs(parseInt(y))
}
})(Box2D);
var Vector = Array,
Vector_a2j_Number = Box2D.NVector;
if (typeof Box2D === "undefined") Box2D = {};
if (typeof Box2D.Collision === "undefined") Box2D.Collision = {};
if (typeof Box2D.Collision.Shapes === "undefined") Box2D.Collision.Shapes = {};
if (typeof Box2D.Common === "undefined") Box2D.Common = {};
if (typeof Box2D.Common.Math === "undefined") Box2D.Common.Math = {};
if (typeof Box2D.Dynamics === "undefined") Box2D.Dynamics = {};
if (typeof Box2D.Dynamics.Contacts === "undefined") Box2D.Dynamics.Contacts = {};
if (typeof Box2D.Dynamics.Controllers === "undefined") Box2D.Dynamics.Controllers = {};
if (typeof Box2D.Dynamics.Joints === "undefined") Box2D.Dynamics.Joints = {};
(function () {
function F() {
F.b2AABB.apply(this, arguments)
}
function G() {
G.b2Bound.apply(this, arguments)
}
function K() {
K.b2BoundValues.apply(this, arguments);
this.constructor === K && this.b2BoundValues.apply(this, arguments)
}
function y() {
y.b2Collision.apply(this, arguments)
}
function w() {
w.b2ContactID.apply(this, arguments);
this.constructor === w && this.b2ContactID.apply(this, arguments)
}
function A() {
A.b2ContactPoint.apply(this, arguments)
}
function U() {
U.b2Distance.apply(this, arguments)
}
function p() {
p.b2DistanceInput.apply(this,
arguments)
}
function B() {
B.b2DistanceOutput.apply(this, arguments)
}
function Q() {
Q.b2DistanceProxy.apply(this, arguments)
}
function V() {
V.b2DynamicTree.apply(this, arguments);
this.constructor === V && this.b2DynamicTree.apply(this, arguments)
}
function M() {
M.b2DynamicTreeBroadPhase.apply(this, arguments)
}
function L() {
L.b2DynamicTreeNode.apply(this, arguments)
}
function I() {
I.b2DynamicTreePair.apply(this, arguments)
}
function W() {
W.b2Manifold.apply(this, arguments);
this.constructor === W && this.b2Manifold.apply(this, arguments)
}
function Y() {
Y.b2ManifoldPoint.apply(this, arguments);
this.constructor === Y && this.b2ManifoldPoint.apply(this, arguments)
}
function k() {
k.b2Point.apply(this, arguments)
}
function z() {
z.b2RayCastInput.apply(this, arguments);
this.constructor === z && this.b2RayCastInput.apply(this, arguments)
}
function u() {
u.b2RayCastOutput.apply(this, arguments)
}
function D() {
D.b2Segment.apply(this, arguments)
}
function H() {
H.b2SeparationFunction.apply(this, arguments)
}
function O() {
O.b2Simplex.apply(this, arguments);
this.constructor === O && this.b2Simplex.apply(this, arguments)
}
function E() {
E.b2SimplexCache.apply(this, arguments)
}
function R() {
R.b2SimplexVertex.apply(this, arguments)
}
function N() {
N.b2TimeOfImpact.apply(this, arguments)
}
function S() {
S.b2TOIInput.apply(this, arguments)
}
function aa() {
aa.b2WorldManifold.apply(this, arguments);
this.constructor === aa && this.b2WorldManifold.apply(this, arguments)
}
function Z() {
Z.ClipVertex.apply(this, arguments)
}
function d() {
d.Features.apply(this, arguments)
}
function h() {
h.b2CircleShape.apply(this, arguments);
this.constructor === h && this.b2CircleShape.apply(this, arguments)
}
function l() {
l.b2EdgeChainDef.apply(this, arguments);
this.constructor === l && this.b2EdgeChainDef.apply(this, arguments)
}
function j() {
j.b2EdgeShape.apply(this, arguments);
this.constructor === j && this.b2EdgeShape.apply(this, arguments)
}
function o() {
o.b2MassData.apply(this, arguments)
}
function q() {
q.b2PolygonShape.apply(this, arguments);
this.constructor === q && this.b2PolygonShape.apply(this, arguments)
}
function n() {
n.b2Shape.apply(this, arguments);
this.constructor === n && this.b2Shape.apply(this, arguments)
}
function a() {
a.b2Color.apply(this, arguments);
this.constructor === a && this.b2Color.apply(this, arguments)
}
function c() {
c.b2Settings.apply(this, arguments)
}
function g() {
g.b2Mat22.apply(this, arguments);
this.constructor === g && this.b2Mat22.apply(this, arguments)
}
function b() {
b.b2Mat33.apply(this, arguments);
this.constructor === b && this.b2Mat33.apply(this, arguments)
}
function e() {
e.b2Math.apply(this, arguments)
}
function f() {
f.b2Sweep.apply(this, arguments)
}
function m() {
m.b2Transform.apply(this,
arguments);
this.constructor === m && this.b2Transform.apply(this, arguments)
}
function r() {
r.b2Vec2.apply(this, arguments);
this.constructor === r && this.b2Vec2.apply(this, arguments)
}
function s() {
s.b2Vec3.apply(this, arguments);
this.constructor === s && this.b2Vec3.apply(this, arguments)
}
function v() {
v.b2Body.apply(this, arguments);
this.constructor === v && this.b2Body.apply(this, arguments)
}
function t() {
t.b2BodyDef.apply(this, arguments);
this.constructor === t && this.b2BodyDef.apply(this, arguments)
}
function x() {
x.b2ContactFilter.apply(this,
arguments)
}
function C() {
C.b2ContactImpulse.apply(this, arguments)
}
function J() {
J.b2ContactListener.apply(this, arguments)
}
function T() {
T.b2ContactManager.apply(this, arguments);
this.constructor === T && this.b2ContactManager.apply(this, arguments)
}
function P() {
P.b2DebugDraw.apply(this, arguments);
this.constructor === P && this.b2DebugDraw.apply(this, arguments)
}
function X() {
X.b2DestructionListener.apply(this, arguments)
}
function $() {
$.b2FilterData.apply(this, arguments)
}
function ba() {
ba.b2Fixture.apply(this, arguments);
this.constructor === ba && this.b2Fixture.apply(this, arguments)
}
function ca() {
ca.b2FixtureDef.apply(this, arguments);
this.constructor === ca && this.b2FixtureDef.apply(this, arguments)
}
function da() {
da.b2Island.apply(this, arguments);
this.constructor === da && this.b2Island.apply(this, arguments)
}
function Fa() {
Fa.b2TimeStep.apply(this, arguments)
}
function ea() {
ea.b2World.apply(this, arguments);
this.constructor === ea && this.b2World.apply(this, arguments)
}
function Ga() {
Ga.b2CircleContact.apply(this, arguments)
}
function fa() {
fa.b2Contact.apply(this,
arguments);
this.constructor === fa && this.b2Contact.apply(this, arguments)
}
function ga() {
ga.b2ContactConstraint.apply(this, arguments);
this.constructor === ga && this.b2ContactConstraint.apply(this, arguments)
}
function Ha() {
Ha.b2ContactConstraintPoint.apply(this, arguments)
}
function Ia() {
Ia.b2ContactEdge.apply(this, arguments)
}
function ha() {
ha.b2ContactFactory.apply(this, arguments);
this.constructor === ha && this.b2ContactFactory.apply(this, arguments)
}
function Ja() {
Ja.b2ContactRegister.apply(this, arguments)
}
function Ka() {
Ka.b2ContactResult.apply(this,
arguments)
}
function ia() {
ia.b2ContactSolver.apply(this, arguments);
this.constructor === ia && this.b2ContactSolver.apply(this, arguments)
}
function La() {
La.b2EdgeAndCircleContact.apply(this, arguments)
}
function ja() {
ja.b2NullContact.apply(this, arguments);
this.constructor === ja && this.b2NullContact.apply(this, arguments)
}
function Ma() {
Ma.b2PolyAndCircleContact.apply(this, arguments)
}
function Na() {
Na.b2PolyAndEdgeContact.apply(this, arguments)
}
function Oa() {
Oa.b2PolygonContact.apply(this, arguments)
}
function ka() {
ka.b2PositionSolverManifold.apply(this,
arguments);
this.constructor === ka && this.b2PositionSolverManifold.apply(this, arguments)
}
function Pa() {
Pa.b2BuoyancyController.apply(this, arguments)
}
function Qa() {
Qa.b2ConstantAccelController.apply(this, arguments)
}
function Ra() {
Ra.b2ConstantForceController.apply(this, arguments)
}
function Sa() {
Sa.b2Controller.apply(this, arguments)
}
function Ta() {
Ta.b2ControllerEdge.apply(this, arguments)
}
function Ua() {
Ua.b2GravityController.apply(this, arguments)
}
function Va() {
Va.b2TensorDampingController.apply(this, arguments)
}
function la() {
la.b2DistanceJoint.apply(this, arguments);
this.constructor === la && this.b2DistanceJoint.apply(this, arguments)
}
function ma() {
ma.b2DistanceJointDef.apply(this, arguments);
this.constructor === ma && this.b2DistanceJointDef.apply(this, arguments)
}
function na() {
na.b2FrictionJoint.apply(this, arguments);
this.constructor === na && this.b2FrictionJoint.apply(this, arguments)
}
function oa() {
oa.b2FrictionJointDef.apply(this, arguments);
this.constructor === oa && this.b2FrictionJointDef.apply(this, arguments)
}
function pa() {
pa.b2GearJoint.apply(this,
arguments);
this.constructor === pa && this.b2GearJoint.apply(this, arguments)
}
function qa() {
qa.b2GearJointDef.apply(this, arguments);
this.constructor === qa && this.b2GearJointDef.apply(this, arguments)
}
function Wa() {
Wa.b2Jacobian.apply(this, arguments)
}
function ra() {
ra.b2Joint.apply(this, arguments);
this.constructor === ra && this.b2Joint.apply(this, arguments)
}
function sa() {
sa.b2JointDef.apply(this, arguments);
this.constructor === sa && this.b2JointDef.apply(this, arguments)
}
function Xa() {
Xa.b2JointEdge.apply(this, arguments)
}
function ta() {
ta.b2LineJoint.apply(this, arguments);
this.constructor === ta && this.b2LineJoint.apply(this, arguments)
}
function ua() {
ua.b2LineJointDef.apply(this, arguments);
this.constructor === ua && this.b2LineJointDef.apply(this, arguments)
}
function va() {
va.b2MouseJoint.apply(this, arguments);
this.constructor === va && this.b2MouseJoint.apply(this, arguments)
}
function wa() {
wa.b2MouseJointDef.apply(this, arguments);
this.constructor === wa && this.b2MouseJointDef.apply(this, arguments)
}
function xa() {
xa.b2PrismaticJoint.apply(this,
arguments);
this.constructor === xa && this.b2PrismaticJoint.apply(this, arguments)
}
function ya() {
ya.b2PrismaticJointDef.apply(this, arguments);
this.constructor === ya && this.b2PrismaticJointDef.apply(this, arguments)
}
function za() {
za.b2PulleyJoint.apply(this, arguments);
this.constructor === za && this.b2PulleyJoint.apply(this, arguments)
}
function Aa() {
Aa.b2PulleyJointDef.apply(this, arguments);
this.constructor === Aa && this.b2PulleyJointDef.apply(this, arguments)
}
function Ba() {
Ba.b2RevoluteJoint.apply(this, arguments);
this.constructor === Ba && this.b2RevoluteJoint.apply(this, arguments)
}
function Ca() {
Ca.b2RevoluteJointDef.apply(this, arguments);
this.constructor === Ca && this.b2RevoluteJointDef.apply(this, arguments)
}
function Da() {
Da.b2WeldJoint.apply(this, arguments);
this.constructor === Da && this.b2WeldJoint.apply(this, arguments)
}
function Ea() {
Ea.b2WeldJointDef.apply(this, arguments);
this.constructor === Ea && this.b2WeldJointDef.apply(this, arguments)
}
Box2D.Collision.IBroadPhase = "Box2D.Collision.IBroadPhase";
Box2D.Collision.b2AABB = F;
Box2D.Collision.b2Bound = G;
Box2D.Collision.b2BoundValues = K;
Box2D.Collision.b2Collision = y;
Box2D.Collision.b2ContactID = w;
Box2D.Collision.b2ContactPoint = A;
Box2D.Collision.b2Distance = U;
Box2D.Collision.b2DistanceInput = p;
Box2D.Collision.b2DistanceOutput = B;
Box2D.Collision.b2DistanceProxy = Q;
Box2D.Collision.b2DynamicTree = V;
Box2D.Collision.b2DynamicTreeBroadPhase = M;
Box2D.Collision.b2DynamicTreeNode = L;
Box2D.Collision.b2DynamicTreePair = I;
Box2D.Collision.b2Manifold = W;
Box2D.Collision.b2ManifoldPoint = Y;
Box2D.Collision.b2Point = k;
Box2D.Collision.b2RayCastInput = z;
Box2D.Collision.b2RayCastOutput = u;
Box2D.Collision.b2Segment = D;
Box2D.Collision.b2SeparationFunction = H;
Box2D.Collision.b2Simplex = O;
Box2D.Collision.b2SimplexCache = E;
Box2D.Collision.b2SimplexVertex = R;
Box2D.Collision.b2TimeOfImpact = N;
Box2D.Collision.b2TOIInput = S;
Box2D.Collision.b2WorldManifold = aa;
Box2D.Collision.ClipVertex = Z;
Box2D.Collision.Features = d;
Box2D.Collision.Shapes.b2CircleShape = h;
Box2D.Collision.Shapes.b2EdgeChainDef = l;
Box2D.Collision.Shapes.b2EdgeShape = j;
Box2D.Collision.Shapes.b2MassData = o;
Box2D.Collision.Shapes.b2PolygonShape = q;
Box2D.Collision.Shapes.b2Shape = n;
Box2D.Common.b2internal = "Box2D.Common.b2internal";
Box2D.Common.b2Color = a;
Box2D.Common.b2Settings = c;
Box2D.Common.Math.b2Mat22 = g;
Box2D.Common.Math.b2Mat33 = b;
Box2D.Common.Math.b2Math = e;
Box2D.Common.Math.b2Sweep = f;
Box2D.Common.Math.b2Transform = m;
Box2D.Common.Math.b2Vec2 = r;
Box2D.Common.Math.b2Vec3 = s;
Box2D.Dynamics.b2Body = v;
Box2D.Dynamics.b2BodyDef = t;
Box2D.Dynamics.b2ContactFilter = x;
Box2D.Dynamics.b2ContactImpulse = C;
Box2D.Dynamics.b2ContactListener = J;
Box2D.Dynamics.b2ContactManager = T;
Box2D.Dynamics.b2DebugDraw = P;
Box2D.Dynamics.b2DestructionListener = X;
Box2D.Dynamics.b2FilterData = $;
Box2D.Dynamics.b2Fixture = ba;
Box2D.Dynamics.b2FixtureDef = ca;
Box2D.Dynamics.b2Island = da;
Box2D.Dynamics.b2TimeStep = Fa;
Box2D.Dynamics.b2World = ea;
Box2D.Dynamics.Contacts.b2CircleContact = Ga;
Box2D.Dynamics.Contacts.b2Contact = fa;
Box2D.Dynamics.Contacts.b2ContactConstraint = ga;
Box2D.Dynamics.Contacts.b2ContactConstraintPoint = Ha;
Box2D.Dynamics.Contacts.b2ContactEdge = Ia;
Box2D.Dynamics.Contacts.b2ContactFactory = ha;
Box2D.Dynamics.Contacts.b2ContactRegister = Ja;
Box2D.Dynamics.Contacts.b2ContactResult = Ka;
Box2D.Dynamics.Contacts.b2ContactSolver = ia;
Box2D.Dynamics.Contacts.b2EdgeAndCircleContact = La;
Box2D.Dynamics.Contacts.b2NullContact = ja;
Box2D.Dynamics.Contacts.b2PolyAndCircleContact = Ma;
Box2D.Dynamics.Contacts.b2PolyAndEdgeContact = Na;
Box2D.Dynamics.Contacts.b2PolygonContact = Oa;
Box2D.Dynamics.Contacts.b2PositionSolverManifold = ka;
Box2D.Dynamics.Controllers.b2BuoyancyController = Pa;
Box2D.Dynamics.Controllers.b2ConstantAccelController = Qa;
Box2D.Dynamics.Controllers.b2ConstantForceController = Ra;
Box2D.Dynamics.Controllers.b2Controller = Sa;
Box2D.Dynamics.Controllers.b2ControllerEdge = Ta;
Box2D.Dynamics.Controllers.b2GravityController = Ua;
Box2D.Dynamics.Controllers.b2TensorDampingController = Va;
Box2D.Dynamics.Joints.b2DistanceJoint = la;
Box2D.Dynamics.Joints.b2DistanceJointDef = ma;
Box2D.Dynamics.Joints.b2FrictionJoint = na;
Box2D.Dynamics.Joints.b2FrictionJointDef = oa;
Box2D.Dynamics.Joints.b2GearJoint = pa;
Box2D.Dynamics.Joints.b2GearJointDef = qa;
Box2D.Dynamics.Joints.b2Jacobian = Wa;
Box2D.Dynamics.Joints.b2Joint = ra;
Box2D.Dynamics.Joints.b2JointDef = sa;
Box2D.Dynamics.Joints.b2JointEdge = Xa;
Box2D.Dynamics.Joints.b2LineJoint = ta;
Box2D.Dynamics.Joints.b2LineJointDef = ua;
Box2D.Dynamics.Joints.b2MouseJoint = va;
Box2D.Dynamics.Joints.b2MouseJointDef = wa;
Box2D.Dynamics.Joints.b2PrismaticJoint = xa;
Box2D.Dynamics.Joints.b2PrismaticJointDef = ya;
Box2D.Dynamics.Joints.b2PulleyJoint = za;
Box2D.Dynamics.Joints.b2PulleyJointDef = Aa;
Box2D.Dynamics.Joints.b2RevoluteJoint = Ba;
Box2D.Dynamics.Joints.b2RevoluteJointDef = Ca;
Box2D.Dynamics.Joints.b2WeldJoint = Da;
Box2D.Dynamics.Joints.b2WeldJointDef = Ea
})();
Box2D.postDefs = [];
(function () {
var F = Box2D.Collision.Shapes.b2CircleShape,
G = Box2D.Collision.Shapes.b2PolygonShape,
K = Box2D.Collision.Shapes.b2Shape,
y = Box2D.Common.b2Settings,
w = Box2D.Common.Math.b2Math,
A = Box2D.Common.Math.b2Sweep,
U = Box2D.Common.Math.b2Transform,
p = Box2D.Common.Math.b2Vec2,
B = Box2D.Collision.b2AABB,
Q = Box2D.Collision.b2Bound,
V = Box2D.Collision.b2BoundValues,
M = Box2D.Collision.b2Collision,
L = Box2D.Collision.b2ContactID,
I = Box2D.Collision.b2ContactPoint,
W = Box2D.Collision.b2Distance,
Y = Box2D.Collision.b2DistanceInput,
k = Box2D.Collision.b2DistanceOutput,
z = Box2D.Collision.b2DistanceProxy,
u = Box2D.Collision.b2DynamicTree,
D = Box2D.Collision.b2DynamicTreeBroadPhase,
H = Box2D.Collision.b2DynamicTreeNode,
O = Box2D.Collision.b2DynamicTreePair,
E = Box2D.Collision.b2Manifold,
R = Box2D.Collision.b2ManifoldPoint,
N = Box2D.Collision.b2Point,
S = Box2D.Collision.b2RayCastInput,
aa = Box2D.Collision.b2RayCastOutput,
Z = Box2D.Collision.b2Segment,
d = Box2D.Collision.b2SeparationFunction,
h = Box2D.Collision.b2Simplex,
l = Box2D.Collision.b2SimplexCache,
j = Box2D.Collision.b2SimplexVertex,
o = Box2D.Collision.b2TimeOfImpact,
q = Box2D.Collision.b2TOIInput,
n = Box2D.Collision.b2WorldManifold,
a = Box2D.Collision.ClipVertex,
c = Box2D.Collision.Features,
g = Box2D.Collision.IBroadPhase;
B.b2AABB = function () {
this.lowerBound = new p;
this.upperBound = new p
};
B.prototype.IsValid = function () {
var b = this.upperBound.y - this.lowerBound.y;
return b = (b = this.upperBound.x - this.lowerBound.x >= 0 && b >= 0) && this.lowerBound.IsValid() && this.upperBound.IsValid()
};
B.prototype.GetCenter = function () {
return new p((this.lowerBound.x + this.upperBound.x) / 2, (this.lowerBound.y + this.upperBound.y) / 2)
};
B.prototype.GetExtents = function () {
return new p((this.upperBound.x - this.lowerBound.x) / 2, (this.upperBound.y - this.lowerBound.y) / 2)
};
B.prototype.Contains = function (b) {
var e = true;
return e = (e = (e = (e = e && this.lowerBound.x <= b.lowerBound.x) && this.lowerBound.y <= b.lowerBound.y) && b.upperBound.x <= this.upperBound.x) && b.upperBound.y <= this.upperBound.y
};
B.prototype.RayCast = function (b, e) {
var f = -Number.MAX_VALUE,
m = Number.MAX_VALUE,
r = e.p1.x,
s = e.p1.y,
v = e.p2.x - e.p1.x,
t = e.p2.y - e.p1.y,
x = Math.abs(t),
C = b.normal,
J = 0,
T = 0,
P = J = 0;
P = 0;
if (Math.abs(v) < Number.MIN_VALUE) {
if (r < this.lowerBound.x || this.upperBound.x < r) return false
} else {
J = 1 / v;
T = (this.lowerBound.x - r) * J;
J = (this.upperBound.x - r) * J;
P = -1;
if (T > J) {
P = T;
T = J;
J = P;
P = 1
}
if (T > f) {
C.x = P;
C.y = 0;
f = T
}
m = Math.min(m, J);
if (f > m) return false
} if (x < Number.MIN_VALUE) {
if (s < this.lowerBound.y || this.upperBound.y < s) return false
} else {
J = 1 / t;
T = (this.lowerBound.y - s) * J;
J = (this.upperBound.y - s) * J;
P = -1;
if (T > J) {
P = T;
T = J;
J = P;
P = 1
}
if (T > f) {
C.y = P;
C.x = 0;
f = T
}
m = Math.min(m, J);
if (f > m) return false
}
b.fraction = f;
return true
};
B.prototype.TestOverlap = function (b) {
var e = b.lowerBound.y - this.upperBound.y,
f = this.lowerBound.y - b.upperBound.y;
if (b.lowerBound.x - this.upperBound.x > 0 || e > 0) return false;
if (this.lowerBound.x - b.upperBound.x > 0 || f > 0) return false;
return true
};
B.Combine = function (b, e) {
var f = new B;
f.Combine(b, e);
return f
};
B.prototype.Combine = function (b, e) {
this.lowerBound.x = Math.min(b.lowerBound.x, e.lowerBound.x);
this.lowerBound.y = Math.min(b.lowerBound.y, e.lowerBound.y);
this.upperBound.x = Math.max(b.upperBound.x, e.upperBound.x);
this.upperBound.y = Math.max(b.upperBound.y, e.upperBound.y)
};
Q.b2Bound = function () {};
Q.prototype.IsLower = function () {
return (this.value & 1) == 0
};
Q.prototype.IsUpper = function () {
return (this.value & 1) == 1
};
Q.prototype.Swap = function (b) {
var e = this.value,
f = this.proxy,
m = this.stabbingCount;
this.value = b.value;
this.proxy = b.proxy;
this.stabbingCount = b.stabbingCount;
b.value = e;
b.proxy = f;
b.stabbingCount = m
};
V.b2BoundValues = function () {};
V.prototype.b2BoundValues = function () {
this.lowerValues = new Vector_a2j_Number;
this.lowerValues[0] = 0;
this.lowerValues[1] = 0;
this.upperValues = new Vector_a2j_Number;
this.upperValues[0] = 0;
this.upperValues[1] = 0
};
M.b2Collision = function () {};
M.ClipSegmentToLine = function (b, e, f, m) {
if (m === undefined) m = 0;
var r, s = 0;
r = e[0];
var v = r.v;
r = e[1];
var t = r.v,
x = f.x * v.x + f.y * v.y - m;
r = f.x * t.x + f.y * t.y - m;
x <= 0 && b[s++].Set(e[0]);
r <= 0 && b[s++].Set(e[1]);
if (x * r < 0) {
f = x / (x - r);
r = b[s];
r = r.v;
r.x = v.x + f * (t.x - v.x);
r.y = v.y + f * (t.y - v.y);
r = b[s];
r.id = (x > 0 ? e[0] : e[1]).id;
++s
}
return s
};
M.EdgeSeparation = function (b, e, f, m, r) {
if (f === undefined) f = 0;
parseInt(b.m_vertexCount);
var s = b.m_vertices;
b = b.m_normals;
var v = parseInt(m.m_vertexCount),
t = m.m_vertices,
x, C;
x = e.R;
C = b[f];
b = x.col1.x * C.x + x.col2.x * C.y;
m = x.col1.y * C.x + x.col2.y * C.y;
x = r.R;
var J = x.col1.x * b + x.col1.y * m;
x = x.col2.x * b + x.col2.y * m;
for (var T = 0, P = Number.MAX_VALUE, X = 0; X < v; ++X) {
C = t[X];
C = C.x * J + C.y * x;
if (C < P) {
P = C;
T = X
}
}
C = s[f];
x = e.R;
f = e.position.x + (x.col1.x * C.x + x.col2.x * C.y);
e = e.position.y + (x.col1.y * C.x + x.col2.y * C.y);
C = t[T];
x = r.R;
s = r.position.x + (x.col1.x * C.x + x.col2.x * C.y);
r = r.position.y + (x.col1.y * C.x + x.col2.y * C.y);
s -= f;
r -= e;
return s * b + r * m
};
M.FindMaxSeparation = function (b, e, f, m, r) {
var s = parseInt(e.m_vertexCount),
v = e.m_normals,
t, x;
x = r.R;
t = m.m_centroid;
var C = r.position.x + (x.col1.x * t.x + x.col2.x * t.y),
J = r.position.y + (x.col1.y * t.x + x.col2.y * t.y);
x = f.R;
t = e.m_centroid;
C -= f.position.x + (x.col1.x * t.x + x.col2.x * t.y);
J -= f.position.y + (x.col1.y * t.x + x.col2.y * t.y);
x = C * f.R.col1.x + J * f.R.col1.y;
J = C * f.R.col2.x + J * f.R.col2.y;
C = 0;
for (var T = -Number.MAX_VALUE, P = 0; P < s; ++P) {
t = v[P];
t = t.x * x + t.y * J;
if (t > T) {
T = t;
C = P
}
}
v = M.EdgeSeparation(e, f, C, m, r);
t = parseInt(C - 1 >= 0 ? C - 1 : s - 1);
x = M.EdgeSeparation(e, f, t, m, r);
J = parseInt(C + 1 < s ? C + 1 : 0);
T = M.EdgeSeparation(e, f, J, m, r);
var X = P = 0,
$ = 0;
if (x > v && x > T) {
$ = -1;
P = t;
X = x
} else if (T > v) {
$ = 1;
P = J;
X = T
} else {
b[0] = C;
return v
}
for (;;) {
C = $ == -1 ? P - 1 >= 0 ? P - 1 : s - 1 : P + 1 < s ? P + 1 : 0;
v = M.EdgeSeparation(e, f, C, m, r);
if (v > X) {
P = C;
X = v
} else break
}
b[0] = P;
return X
};
M.FindIncidentEdge = function (b, e, f, m, r, s) {
if (m === undefined) m = 0;
parseInt(e.m_vertexCount);
var v = e.m_normals,
t = parseInt(r.m_vertexCount);
e = r.m_vertices;
r = r.m_normals;
var x;
x = f.R;
f = v[m];
v = x.col1.x * f.x + x.col2.x * f.y;
var C = x.col1.y * f.x + x.col2.y * f.y;
x = s.R;
f = x.col1.x * v + x.col1.y * C;
C = x.col2.x * v + x.col2.y * C;
v = f;
x = 0;
for (var J = Number.MAX_VALUE, T = 0; T < t; ++T) {
f = r[T];
f = v * f.x + C * f.y;
if (f < J) {
J = f;
x = T
}
}
r = parseInt(x);
v = parseInt(r + 1 < t ? r + 1 : 0);
t = b[0];
f = e[r];
x = s.R;
t.v.x = s.position.x + (x.col1.x * f.x + x.col2.x * f.y);
t.v.y = s.position.y + (x.col1.y * f.x + x.col2.y * f.y);
t.id.features.referenceEdge = m;
t.id.features.incidentEdge = r;
t.id.features.incidentVertex = 0;
t = b[1];
f = e[v];
x = s.R;
t.v.x = s.position.x + (x.col1.x * f.x + x.col2.x * f.y);
t.v.y = s.position.y + (x.col1.y * f.x + x.col2.y * f.y);
t.id.features.referenceEdge = m;
t.id.features.incidentEdge = v;
t.id.features.incidentVertex = 1
};
M.MakeClipPointVector = function () {
var b = new Vector(2);
b[0] = new a;
b[1] = new a;
return b
};
M.CollidePolygons = function (b, e, f, m, r) {
var s;
b.m_pointCount = 0;
var v = e.m_radius + m.m_radius;
s = 0;
M.s_edgeAO[0] = s;
var t = M.FindMaxSeparation(M.s_edgeAO, e, f, m, r);
s = M.s_edgeAO[0];
if (!(t > v)) {
var x = 0;
M.s_edgeBO[0] = x;
var C = M.FindMaxSeparation(M.s_edgeBO,
m, r, e, f);
x = M.s_edgeBO[0];
if (!(C > v)) {
var J = 0,
T = 0;
if (C > 0.98 * t + 0.0010) {
t = m;
m = e;
e = r;
f = f;
J = x;
b.m_type = E.e_faceB;
T = 1
} else {
t = e;
m = m;
e = f;
f = r;
J = s;
b.m_type = E.e_faceA;
T = 0
}
s = M.s_incidentEdge;
M.FindIncidentEdge(s, t, e, J, m, f);
x = parseInt(t.m_vertexCount);
r = t.m_vertices;
t = r[J];
var P;
P = J + 1 < x ? r[parseInt(J + 1)] : r[0];
J = M.s_localTangent;
J.Set(P.x - t.x, P.y - t.y);
J.Normalize();
r = M.s_localNormal;
r.x = J.y;
r.y = -J.x;
m = M.s_planePoint;
m.Set(0.5 * (t.x + P.x), 0.5 * (t.y + P.y));
C = M.s_tangent;
x = e.R;
C.x = x.col1.x * J.x + x.col2.x * J.y;
C.y = x.col1.y * J.x + x.col2.y * J.y;
var X = M.s_tangent2;
X.x = -C.x;
X.y = -C.y;
J = M.s_normal;
J.x = C.y;
J.y = -C.x;
var $ = M.s_v11,
ba = M.s_v12;
$.x = e.position.x + (x.col1.x * t.x + x.col2.x * t.y);
$.y = e.position.y + (x.col1.y * t.x + x.col2.y * t.y);
ba.x = e.position.x + (x.col1.x * P.x + x.col2.x * P.y);
ba.y = e.position.y + (x.col1.y * P.x + x.col2.y * P.y);
e = J.x * $.x + J.y * $.y;
x = C.x * ba.x + C.y * ba.y + v;
P = M.s_clipPoints1;
t = M.s_clipPoints2;
ba = 0;
ba = M.ClipSegmentToLine(P, s, X, -C.x * $.x - C.y * $.y + v);
if (!(ba < 2)) {
ba = M.ClipSegmentToLine(t, P, C, x);
if (!(ba < 2)) {
b.m_localPlaneNormal.SetV(r);
b.m_localPoint.SetV(m);
for (m = r = 0; m < y.b2_maxManifoldPoints; ++m) {
s = t[m];
if (J.x * s.v.x + J.y * s.v.y - e <= v) {
C = b.m_points[r];
x = f.R;
X = s.v.x - f.position.x;
$ = s.v.y - f.position.y;
C.m_localPoint.x = X * x.col1.x + $ * x.col1.y;
C.m_localPoint.y = X * x.col2.x + $ * x.col2.y;
C.m_id.Set(s.id);
C.m_id.features.flip = T;
++r
}
}
b.m_pointCount = r
}
}
}
}
};
M.CollideCircles = function (b, e, f, m, r) {
b.m_pointCount = 0;
var s, v;
s = f.R;
v = e.m_p;
var t = f.position.x + (s.col1.x * v.x + s.col2.x * v.y);
f = f.position.y + (s.col1.y * v.x + s.col2.y * v.y);
s = r.R;
v = m.m_p;
t = r.position.x + (s.col1.x * v.x + s.col2.x * v.y) - t;
r = r.position.y + (s.col1.y * v.x + s.col2.y * v.y) - f;
s = e.m_radius + m.m_radius;
if (!(t * t + r * r > s * s)) {
b.m_type = E.e_circles;
b.m_localPoint.SetV(e.m_p);
b.m_localPlaneNormal.SetZero();
b.m_pointCount = 1;
b.m_points[0].m_localPoint.SetV(m.m_p);
b.m_points[0].m_id.key = 0
}
};
M.CollidePolygonAndCircle = function (b, e, f, m, r) {
var s = b.m_pointCount = 0,
v = 0,
t, x;
x = r.R;
t = m.m_p;
var C = r.position.y + (x.col1.y * t.x + x.col2.y * t.y);
s = r.position.x + (x.col1.x * t.x + x.col2.x * t.y) - f.position.x;
v = C - f.position.y;
x = f.R;
f = s * x.col1.x + v * x.col1.y;
x = s * x.col2.x + v * x.col2.y;
var J = 0;
C = -Number.MAX_VALUE;
r = e.m_radius + m.m_radius;
var T = parseInt(e.m_vertexCount),
P = e.m_vertices;
e = e.m_normals;
for (var X = 0; X < T; ++X) {
t = P[X];
s = f - t.x;
v = x - t.y;
t = e[X];
s = t.x * s + t.y * v;
if (s > r) return;
if (s > C) {
C = s;
J = X
}
}
s = parseInt(J);
v = parseInt(s + 1 < T ? s + 1 : 0);
t = P[s];
P = P[v];
if (C < Number.MIN_VALUE) {
b.m_pointCount = 1;
b.m_type = E.e_faceA;
b.m_localPlaneNormal.SetV(e[J]);
b.m_localPoint.x = 0.5 * (t.x + P.x);
b.m_localPoint.y = 0.5 * (t.y + P.y)
} else {
C = (f - P.x) * (t.x - P.x) + (x - P.y) * (t.y - P.y);
if ((f - t.x) * (P.x - t.x) + (x - t.y) * (P.y - t.y) <= 0) {
if ((f - t.x) * (f - t.x) + (x - t.y) * (x - t.y) > r * r) return;
b.m_pointCount = 1;
b.m_type = E.e_faceA;
b.m_localPlaneNormal.x = f - t.x;
b.m_localPlaneNormal.y = x - t.y;
b.m_localPlaneNormal.Normalize();
b.m_localPoint.SetV(t)
} else if (C <= 0) {
if ((f - P.x) * (f - P.x) + (x - P.y) * (x - P.y) > r * r) return;
b.m_pointCount = 1;
b.m_type = E.e_faceA;
b.m_localPlaneNormal.x = f - P.x;
b.m_localPlaneNormal.y = x - P.y;
b.m_localPlaneNormal.Normalize();
b.m_localPoint.SetV(P)
} else {
J = 0.5 * (t.x + P.x);
t = 0.5 * (t.y + P.y);
C = (f - J) * e[s].x + (x - t) * e[s].y;
if (C > r) return;
b.m_pointCount = 1;
b.m_type = E.e_faceA;
b.m_localPlaneNormal.x = e[s].x;
b.m_localPlaneNormal.y = e[s].y;
b.m_localPlaneNormal.Normalize();
b.m_localPoint.Set(J, t)
}
}
b.m_points[0].m_localPoint.SetV(m.m_p);
b.m_points[0].m_id.key = 0
};
M.TestOverlap = function (b, e) {
var f = e.lowerBound,
m = b.upperBound,
r = f.x - m.x,
s = f.y - m.y;
f = b.lowerBound;
m = e.upperBound;
var v = f.y - m.y;
if (r > 0 || s > 0) return false;
if (f.x - m.x > 0 || v > 0) return false;
return true
};
Box2D.postDefs.push(function () {
Box2D.Collision.b2Collision.s_incidentEdge = M.MakeClipPointVector();
Box2D.Collision.b2Collision.s_clipPoints1 = M.MakeClipPointVector();
Box2D.Collision.b2Collision.s_clipPoints2 = M.MakeClipPointVector();
Box2D.Collision.b2Collision.s_edgeAO = new Vector_a2j_Number(1);
Box2D.Collision.b2Collision.s_edgeBO = new Vector_a2j_Number(1);
Box2D.Collision.b2Collision.s_localTangent = new p;
Box2D.Collision.b2Collision.s_localNormal = new p;
Box2D.Collision.b2Collision.s_planePoint = new p;
Box2D.Collision.b2Collision.s_normal = new p;
Box2D.Collision.b2Collision.s_tangent = new p;
Box2D.Collision.b2Collision.s_tangent2 = new p;
Box2D.Collision.b2Collision.s_v11 = new p;
Box2D.Collision.b2Collision.s_v12 = new p;
Box2D.Collision.b2Collision.b2CollidePolyTempVec = new p;
Box2D.Collision.b2Collision.b2_nullFeature = 255
});
L.b2ContactID = function () {
this.features = new c
};
L.prototype.b2ContactID = function () {
this.features._m_id = this
};
L.prototype.Set = function (b) {
this.key = b._key
};
L.prototype.Copy = function () {
var b = new L;
b.key = this.key;
return b
};
Object.defineProperty(L.prototype, "key", {
enumerable: false,
configurable: true,
get: function () {
return this._key
}
});
Object.defineProperty(L.prototype, "key", {
enumerable: false,
configurable: true,
set: function (b) {
if (b === undefined) b = 0;
this._key = b;
this.features._referenceEdge = this._key & 255;
this.features._incidentEdge = (this._key & 65280) >> 8 & 255;
this.features._incidentVertex = (this._key & 16711680) >> 16 & 255;
this.features._flip = (this._key & 4278190080) >> 24 & 255
}
});
I.b2ContactPoint = function () {
this.position = new p;
this.velocity = new p;
this.normal = new p;
this.id = new L
};
W.b2Distance = function () {};
W.Distance = function (b, e, f) {
++W.b2_gjkCalls;
var m = f.proxyA,
r = f.proxyB,
s = f.transformA,
v = f.transformB,
t = W.s_simplex;
t.ReadCache(e, m, s, r, v);
var x = t.m_vertices,
C = W.s_saveA,
J = W.s_saveB,
T = 0;
t.GetClosestPoint().LengthSquared();
for (var P = 0, X, $ = 0; $ < 20;) {
T = t.m_count;
for (P = 0; P < T; P++) {
C[P] = x[P].indexA;
J[P] = x[P].indexB
}
switch (t.m_count) {
case 1:
break;
case 2:
t.Solve2();
break;
case 3:
t.Solve3();
break;
default:
y.b2Assert(false)
}
if (t.m_count == 3) break;
X = t.GetClosestPoint();
X.LengthSquared();
P = t.GetSearchDirection();
if (P.LengthSquared() < Number.MIN_VALUE * Number.MIN_VALUE) break;
X = x[t.m_count];
X.indexA = m.GetSupport(w.MulTMV(s.R, P.GetNegative()));
X.wA = w.MulX(s, m.GetVertex(X.indexA));
X.indexB = r.GetSupport(w.MulTMV(v.R, P));
X.wB = w.MulX(v, r.GetVertex(X.indexB));
X.w = w.SubtractVV(X.wB, X.wA);
++$;
++W.b2_gjkIters;
var ba = false;
for (P = 0; P < T; P++)
if (X.indexA == C[P] && X.indexB == J[P]) {
ba = true;
break
}
if (ba) break;
++t.m_count
}
W.b2_gjkMaxIters = w.Max(W.b2_gjkMaxIters, $);
t.GetWitnessPoints(b.pointA, b.pointB);
b.distance = w.SubtractVV(b.pointA,
b.pointB).Length();
b.iterations = $;
t.WriteCache(e);
if (f.useRadii) {
e = m.m_radius;
r = r.m_radius;
if (b.distance > e + r && b.distance > Number.MIN_VALUE) {
b.distance -= e + r;
f = w.SubtractVV(b.pointB, b.pointA);
f.Normalize();
b.pointA.x += e * f.x;
b.pointA.y += e * f.y;
b.pointB.x -= r * f.x;
b.pointB.y -= r * f.y
} else {
X = new p;
X.x = 0.5 * (b.pointA.x + b.pointB.x);
X.y = 0.5 * (b.pointA.y + b.pointB.y);
b.pointA.x = b.pointB.x = X.x;
b.pointA.y = b.pointB.y = X.y;
b.distance = 0
}
}
};
Box2D.postDefs.push(function () {
Box2D.Collision.b2Distance.s_simplex = new h;
Box2D.Collision.b2Distance.s_saveA = new Vector_a2j_Number(3);
Box2D.Collision.b2Distance.s_saveB = new Vector_a2j_Number(3)
});
Y.b2DistanceInput = function () {};
k.b2DistanceOutput = function () {
this.pointA = new p;
this.pointB = new p
};
z.b2DistanceProxy = function () {};
z.prototype.Set = function (b) {
switch (b.GetType()) {
case K.e_circleShape:
b = b instanceof F ? b : null;
this.m_vertices = new Vector(1, true);
this.m_vertices[0] = b.m_p;
this.m_count = 1;
this.m_radius = b.m_radius;
break;
case K.e_polygonShape:
b = b instanceof G ? b : null;
this.m_vertices = b.m_vertices;
this.m_count = b.m_vertexCount;
this.m_radius = b.m_radius;
break;
default:
y.b2Assert(false)
}
};
z.prototype.GetSupport = function (b) {
for (var e = 0, f = this.m_vertices[0].x * b.x + this.m_vertices[0].y * b.y, m = 1; m < this.m_count; ++m) {
var r = this.m_vertices[m].x * b.x + this.m_vertices[m].y * b.y;
if (r > f) {
e = m;
f = r
}
}
return e
};
z.prototype.GetSupportVertex = function (b) {
for (var e = 0, f = this.m_vertices[0].x * b.x + this.m_vertices[0].y * b.y, m = 1; m < this.m_count; ++m) {
var r = this.m_vertices[m].x * b.x + this.m_vertices[m].y * b.y;
if (r > f) {
e = m;
f = r
}
}
return this.m_vertices[e]
};
z.prototype.GetVertexCount = function () {
return this.m_count
};
z.prototype.GetVertex = function (b) {
if (b === undefined) b = 0;
y.b2Assert(0 <= b && b < this.m_count);
return this.m_vertices[b]
};
u.b2DynamicTree = function () {};
u.prototype.b2DynamicTree = function () {
this.m_freeList = this.m_root = null;
this.m_insertionCount = this.m_path = 0
};
u.prototype.CreateProxy = function (b, e) {
var f = this.AllocateNode(),
m = y.b2_aabbExtension,
r = y.b2_aabbExtension;
f.aabb.lowerBound.x = b.lowerBound.x - m;
f.aabb.lowerBound.y = b.lowerBound.y - r;
f.aabb.upperBound.x = b.upperBound.x + m;
f.aabb.upperBound.y = b.upperBound.y + r;
f.userData = e;
this.InsertLeaf(f);
return f
};
u.prototype.DestroyProxy = function (b) {
this.RemoveLeaf(b);
this.FreeNode(b)
};
u.prototype.MoveProxy = function (b, e, f) {
y.b2Assert(b.IsLeaf());
if (b.aabb.Contains(e)) return false;
this.RemoveLeaf(b);
var m = y.b2_aabbExtension + y.b2_aabbMultiplier * (f.x > 0 ? f.x : -f.x);
f = y.b2_aabbExtension + y.b2_aabbMultiplier * (f.y > 0 ? f.y : -f.y);
b.aabb.lowerBound.x = e.lowerBound.x - m;
b.aabb.lowerBound.y = e.lowerBound.y - f;
b.aabb.upperBound.x = e.upperBound.x + m;
b.aabb.upperBound.y = e.upperBound.y + f;
this.InsertLeaf(b);
return true
};
u.prototype.Rebalance = function (b) {
if (b === undefined) b = 0;
if (this.m_root != null) for (var e = 0; e < b; e++) {
for (var f = this.m_root, m = 0; f.IsLeaf() == false;) {
f = this.m_path >> m & 1 ? f.child2 : f.child1;
m = m + 1 & 31
}++this.m_path;
this.RemoveLeaf(f);
this.InsertLeaf(f)
}
};
u.prototype.GetFatAABB = function (b) {
return b.aabb
};
u.prototype.GetUserData = function (b) {
return b.userData
};
u.prototype.Query = function (b, e) {
if (this.m_root != null) {
var f = new Vector,
m = 0;
for (f[m++] = this.m_root; m > 0;) {
var r = f[--m];
if (r.aabb.TestOverlap(e))
if (r.IsLeaf()) {
if (!b(r)) break
} else {
f[m++] = r.child1;
f[m++] = r.child2
}
}
}
};
u.prototype.RayCast = function (b, e) {
if (this.m_root != null) {
var f = e.p1,
m = e.p2,
r = w.SubtractVV(f, m);
r.Normalize();
r = w.CrossFV(1, r);
var s = w.AbsV(r),
v = e.maxFraction,
t = new B,
x = 0,
C = 0;
x = f.x + v * (m.x - f.x);
C = f.y + v * (m.y - f.y);
t.lowerBound.x = Math.min(f.x, x);
t.lowerBound.y = Math.min(f.y, C);
t.upperBound.x = Math.max(f.x, x);
t.upperBound.y = Math.max(f.y, C);
var J = new Vector,
T = 0;
for (J[T++] = this.m_root; T > 0;) {
v = J[--T];
if (v.aabb.TestOverlap(t) != false) {
x = v.aabb.GetCenter();
C = v.aabb.GetExtents();
if (!(Math.abs(r.x * (f.x - x.x) + r.y * (f.y - x.y)) - s.x * C.x - s.y * C.y > 0))
if (v.IsLeaf()) {
x = new S;
x.p1 = e.p1;
x.p2 = e.p2;
x.maxFraction = e.maxFraction;
v = b(x, v);
if (v == 0) break;
if (v > 0) {
x = f.x + v * (m.x - f.x);
C = f.y + v * (m.y - f.y);
t.lowerBound.x = Math.min(f.x, x);
t.lowerBound.y = Math.min(f.y, C);
t.upperBound.x = Math.max(f.x, x);
t.upperBound.y = Math.max(f.y, C)
}
} else {
J[T++] = v.child1;
J[T++] = v.child2
}
}
}
}
};
u.prototype.AllocateNode = function () {
if (this.m_freeList) {
var b = this.m_freeList;
this.m_freeList = b.parent;
b.parent = null;
b.child1 = null;
b.child2 = null;
return b
}
return new H
};
u.prototype.FreeNode = function (b) {
b.parent = this.m_freeList;
this.m_freeList = b
};
u.prototype.InsertLeaf = function (b) {
++this.m_insertionCount;
if (this.m_root == null) {
this.m_root = b;
this.m_root.parent = null
} else {
var e = b.aabb.GetCenter(),
f = this.m_root;
if (f.IsLeaf() == false) {
do {
var m = f.child1;
f = f.child2;
f = Math.abs((m.aabb.lowerBound.x + m.aabb.upperBound.x) / 2 - e.x) + Math.abs((m.aabb.lowerBound.y + m.aabb.upperBound.y) / 2 - e.y) < Math.abs((f.aabb.lowerBound.x + f.aabb.upperBound.x) / 2 - e.x) + Math.abs((f.aabb.lowerBound.y + f.aabb.upperBound.y) / 2 - e.y) ? m : f
} while (f.IsLeaf() == false)
}
e = f.parent;
m = this.AllocateNode();
m.parent = e;
m.userData = null;
m.aabb.Combine(b.aabb, f.aabb);
if (e) {
if (f.parent.child1 == f) e.child1 = m;
else e.child2 = m;
m.child1 = f;
m.child2 = b;
f.parent = m;
b.parent = m;
do {
if (e.aabb.Contains(m.aabb)) break;
e.aabb.Combine(e.child1.aabb, e.child2.aabb);
m = e;
e = e.parent
} while (e)
} else {
m.child1 = f;
m.child2 = b;
f.parent = m;
this.m_root = b.parent = m
}
}
};
u.prototype.RemoveLeaf = function (b) {
if (b == this.m_root) this.m_root = null;
else {
var e = b.parent,
f = e.parent;
b = e.child1 == b ? e.child2 : e.child1;
if (f) {
if (f.child1 == e) f.child1 = b;
else f.child2 = b;
b.parent = f;
for (this.FreeNode(e); f;) {
e = f.aabb;
f.aabb = B.Combine(f.child1.aabb, f.child2.aabb);
if (e.Contains(f.aabb)) break;
f = f.parent
}
} else {
this.m_root = b;
b.parent = null;
this.FreeNode(e)
}
}
};
D.b2DynamicTreeBroadPhase = function () {
this.m_tree = new u;
this.m_moveBuffer = new Vector;
this.m_pairBuffer = new Vector;
this.m_pairCount = 0
};
D.prototype.CreateProxy = function (b, e) {
var f = this.m_tree.CreateProxy(b, e);
++this.m_proxyCount;
this.BufferMove(f);
return f
};
D.prototype.DestroyProxy = function (b) {
this.UnBufferMove(b);
--this.m_proxyCount;
this.m_tree.DestroyProxy(b)
};
D.prototype.MoveProxy = function (b, e, f) {
this.m_tree.MoveProxy(b, e, f) && this.BufferMove(b)
};
D.prototype.TestOverlap = function (b, e) {
var f = this.m_tree.GetFatAABB(b),
m = this.m_tree.GetFatAABB(e);
return f.TestOverlap(m)
};
D.prototype.GetUserData = function (b) {
return this.m_tree.GetUserData(b)
};
D.prototype.GetFatAABB = function (b) {
return this.m_tree.GetFatAABB(b)
};
D.prototype.GetProxyCount = function () {
return this.m_proxyCount
};
D.prototype.UpdatePairs = function (b) {
var e = this;
var f = e.m_pairCount = 0,
m;
for (f = 0; f < e.m_moveBuffer.length; ++f) {
m = e.m_moveBuffer[f];
var r = e.m_tree.GetFatAABB(m);
e.m_tree.Query(function (t) {
if (t == m) return true;
if (e.m_pairCount == e.m_pairBuffer.length) e.m_pairBuffer[e.m_pairCount] = new O;
var x = e.m_pairBuffer[e.m_pairCount];
x.proxyA = t < m ? t : m;
x.proxyB = t >= m ? t : m;
++e.m_pairCount;
return true
},
r)
}
for (f = e.m_moveBuffer.length = 0; f < e.m_pairCount;) {
r = e.m_pairBuffer[f];
var s = e.m_tree.GetUserData(r.proxyA),
v = e.m_tree.GetUserData(r.proxyB);
b(s, v);
for (++f; f < e.m_pairCount;) {
s = e.m_pairBuffer[f];
if (s.proxyA != r.proxyA || s.proxyB != r.proxyB) break;
++f
}
}
};
D.prototype.Query = function (b, e) {
this.m_tree.Query(b, e)
};
D.prototype.RayCast = function (b, e) {
this.m_tree.RayCast(b, e)
};
D.prototype.Validate = function () {};
D.prototype.Rebalance = function (b) {
if (b === undefined) b = 0;
this.m_tree.Rebalance(b)
};
D.prototype.BufferMove = function (b) {
this.m_moveBuffer[this.m_moveBuffer.length] = b
};
D.prototype.UnBufferMove = function (b) {
this.m_moveBuffer.splice(parseInt(this.m_moveBuffer.indexOf(b)), 1)
};
D.prototype.ComparePairs = function () {
return 0
};
D.__implements = {};
D.__implements[g] = true;
H.b2DynamicTreeNode = function () {
this.aabb = new B
};
H.prototype.IsLeaf = function () {
return this.child1 == null
};
O.b2DynamicTreePair = function () {};
E.b2Manifold = function () {
this.m_pointCount = 0
};
E.prototype.b2Manifold = function () {
this.m_points = new Vector(y.b2_maxManifoldPoints);
for (var b = 0; b < y.b2_maxManifoldPoints; b++) this.m_points[b] = new R;
this.m_localPlaneNormal = new p;
this.m_localPoint = new p
};
E.prototype.Reset = function () {
for (var b = 0; b < y.b2_maxManifoldPoints; b++)(this.m_points[b] instanceof R ? this.m_points[b] : null).Reset();
this.m_localPlaneNormal.SetZero();
this.m_localPoint.SetZero();
this.m_pointCount = this.m_type = 0
};
E.prototype.Set = function (b) {
this.m_pointCount = b.m_pointCount;
for (var e = 0; e < y.b2_maxManifoldPoints; e++)(this.m_points[e] instanceof R ? this.m_points[e] : null).Set(b.m_points[e]);
this.m_localPlaneNormal.SetV(b.m_localPlaneNormal);
this.m_localPoint.SetV(b.m_localPoint);
this.m_type = b.m_type
};
E.prototype.Copy = function () {
var b = new E;
b.Set(this);
return b
};
Box2D.postDefs.push(function () {
Box2D.Collision.b2Manifold.e_circles = 1;
Box2D.Collision.b2Manifold.e_faceA = 2;
Box2D.Collision.b2Manifold.e_faceB = 4
});
R.b2ManifoldPoint = function () {
this.m_localPoint = new p;
this.m_id = new L
};
R.prototype.b2ManifoldPoint = function () {
this.Reset()
};
R.prototype.Reset = function () {
this.m_localPoint.SetZero();
this.m_tangentImpulse = this.m_normalImpulse = 0;
this.m_id.key = 0
};
R.prototype.Set = function (b) {
this.m_localPoint.SetV(b.m_localPoint);
this.m_normalImpulse = b.m_normalImpulse;
this.m_tangentImpulse = b.m_tangentImpulse;
this.m_id.Set(b.m_id)
};
N.b2Point = function () {
this.p = new p
};
N.prototype.Support = function () {
return this.p
};
N.prototype.GetFirstVertex = function () {
return this.p
};
S.b2RayCastInput = function () {
this.p1 = new p;
this.p2 = new p
};
S.prototype.b2RayCastInput = function (b, e, f) {
if (b === undefined) b = null;
if (e === undefined) e = null;
if (f === undefined) f = 1;
b && this.p1.SetV(b);
e && this.p2.SetV(e);
this.maxFraction = f
};
aa.b2RayCastOutput = function () {
this.normal = new p
};
Z.b2Segment = function () {
this.p1 = new p;
this.p2 = new p
};
Z.prototype.TestSegment = function (b, e, f, m) {
if (m === undefined) m = 0;
var r = f.p1,
s = f.p2.x - r.x,
v = f.p2.y - r.y;
f = this.p2.y - this.p1.y;
var t = -(this.p2.x - this.p1.x),
x = 100 * Number.MIN_VALUE,
C = -(s * f + v * t);
if (C > x) {
var J = r.x - this.p1.x,
T = r.y - this.p1.y;
r = J * f + T * t;
if (0 <= r && r <= m * C) {
m = -s * T + v * J;
if (-x * C <= m && m <= C * (1 + x)) {
r /= C;
m = Math.sqrt(f * f + t * t);
f /= m;
t /= m;
b[0] = r;
e.Set(f,
t);
return true
}
}
}
return false
};
Z.prototype.Extend = function (b) {
this.ExtendForward(b);
this.ExtendBackward(b)
};
Z.prototype.ExtendForward = function (b) {
var e = this.p2.x - this.p1.x,
f = this.p2.y - this.p1.y;
b = Math.min(e > 0 ? (b.upperBound.x - this.p1.x) / e : e < 0 ? (b.lowerBound.x - this.p1.x) / e : Number.POSITIVE_INFINITY, f > 0 ? (b.upperBound.y - this.p1.y) / f : f < 0 ? (b.lowerBound.y - this.p1.y) / f : Number.POSITIVE_INFINITY);
this.p2.x = this.p1.x + e * b;
this.p2.y = this.p1.y + f * b
};
Z.prototype.ExtendBackward = function (b) {
var e = -this.p2.x + this.p1.x,
f = -this.p2.y + this.p1.y;
b = Math.min(e > 0 ? (b.upperBound.x - this.p2.x) / e : e < 0 ? (b.lowerBound.x - this.p2.x) / e : Number.POSITIVE_INFINITY, f > 0 ? (b.upperBound.y - this.p2.y) / f : f < 0 ? (b.lowerBound.y - this.p2.y) / f : Number.POSITIVE_INFINITY);
this.p1.x = this.p2.x + e * b;
this.p1.y = this.p2.y + f * b
};
d.b2SeparationFunction = function () {
this.m_localPoint = new p;
this.m_axis = new p
};
d.prototype.Initialize = function (b, e, f, m, r) {
this.m_proxyA = e;
this.m_proxyB = m;
var s = parseInt(b.count);
y.b2Assert(0 < s && s < 3);
var v, t, x, C, J = C = x = m = e = 0,
T = 0;
J = 0;
if (s == 1) {
this.m_type = d.e_points;
v = this.m_proxyA.GetVertex(b.indexA[0]);
t = this.m_proxyB.GetVertex(b.indexB[0]);
s = v;
b = f.R;
e = f.position.x + (b.col1.x * s.x + b.col2.x * s.y);
m = f.position.y + (b.col1.y * s.x + b.col2.y * s.y);
s = t;
b = r.R;
x = r.position.x + (b.col1.x * s.x + b.col2.x * s.y);
C = r.position.y + (b.col1.y * s.x + b.col2.y * s.y);
this.m_axis.x = x - e;
this.m_axis.y = C - m;
this.m_axis.Normalize()
} else {
if (b.indexB[0] == b.indexB[1]) {
this.m_type = d.e_faceA;
e = this.m_proxyA.GetVertex(b.indexA[0]);
m = this.m_proxyA.GetVertex(b.indexA[1]);
t = this.m_proxyB.GetVertex(b.indexB[0]);
this.m_localPoint.x = 0.5 * (e.x + m.x);
this.m_localPoint.y = 0.5 * (e.y + m.y);
this.m_axis = w.CrossVF(w.SubtractVV(m, e), 1);
this.m_axis.Normalize();
s = this.m_axis;
b = f.R;
J = b.col1.x * s.x + b.col2.x * s.y;
T = b.col1.y * s.x + b.col2.y * s.y;
s = this.m_localPoint;
b = f.R;
e = f.position.x + (b.col1.x * s.x + b.col2.x * s.y);
m = f.position.y + (b.col1.y * s.x + b.col2.y * s.y);
s = t;
b = r.R;
x = r.position.x + (b.col1.x * s.x + b.col2.x * s.y);
C = r.position.y + (b.col1.y * s.x + b.col2.y * s.y);
J = (x - e) * J + (C - m) * T
} else if (b.indexA[0] == b.indexA[0]) {
this.m_type = d.e_faceB;
x = this.m_proxyB.GetVertex(b.indexB[0]);
C = this.m_proxyB.GetVertex(b.indexB[1]);
v = this.m_proxyA.GetVertex(b.indexA[0]);
this.m_localPoint.x = 0.5 * (x.x + C.x);
this.m_localPoint.y = 0.5 * (x.y + C.y);
this.m_axis = w.CrossVF(w.SubtractVV(C, x), 1);
this.m_axis.Normalize();
s = this.m_axis;
b = r.R;
J = b.col1.x * s.x + b.col2.x * s.y;
T = b.col1.y * s.x + b.col2.y * s.y;
s = this.m_localPoint;
b = r.R;
x = r.position.x + (b.col1.x * s.x + b.col2.x * s.y);
C = r.position.y + (b.col1.y * s.x + b.col2.y * s.y);
s = v;
b = f.R;
e = f.position.x + (b.col1.x * s.x + b.col2.x * s.y);
m = f.position.y + (b.col1.y * s.x + b.col2.y * s.y);
J = (e - x) * J + (m - C) * T
} else {
e = this.m_proxyA.GetVertex(b.indexA[0]);
m = this.m_proxyA.GetVertex(b.indexA[1]);
x = this.m_proxyB.GetVertex(b.indexB[0]);
C = this.m_proxyB.GetVertex(b.indexB[1]);
w.MulX(f, v);
v = w.MulMV(f.R, w.SubtractVV(m, e));
w.MulX(r, t);
J = w.MulMV(r.R, w.SubtractVV(C, x));
r = v.x * v.x + v.y * v.y;
t = J.x * J.x + J.y * J.y;
b = w.SubtractVV(J, v);
f = v.x * b.x + v.y * b.y;
b = J.x * b.x + J.y * b.y;
v = v.x * J.x + v.y * J.y;
T = r * t - v * v;
J = 0;
if (T != 0) J = w.Clamp((v * b - f * t) / T, 0, 1);
if ((v * J + b) / t < 0) J = w.Clamp((v - f) / r, 0, 1);
v = new p;
v.x = e.x + J * (m.x - e.x);
v.y = e.y + J * (m.y - e.y);
t = new p;
t.x = x.x + J * (C.x - x.x);
t.y = x.y + J * (C.y - x.y);
if (J == 0 || J == 1) {
this.m_type = d.e_faceB;
this.m_axis = w.CrossVF(w.SubtractVV(C, x), 1);
this.m_axis.Normalize();
this.m_localPoint = t
} else {
this.m_type = d.e_faceA;
this.m_axis = w.CrossVF(w.SubtractVV(m, e), 1);
this.m_localPoint = v
}
}
J < 0 && this.m_axis.NegativeSelf()
}
};
d.prototype.Evaluate = function (b, e) {
var f, m, r = 0;
switch (this.m_type) {
case d.e_points:
f = w.MulTMV(b.R, this.m_axis);
m = w.MulTMV(e.R, this.m_axis.GetNegative());
f = this.m_proxyA.GetSupportVertex(f);
m = this.m_proxyB.GetSupportVertex(m);
f = w.MulX(b, f);
m = w.MulX(e, m);
return r = (m.x - f.x) * this.m_axis.x + (m.y - f.y) * this.m_axis.y;
case d.e_faceA:
r = w.MulMV(b.R, this.m_axis);
f = w.MulX(b, this.m_localPoint);
m = w.MulTMV(e.R, r.GetNegative());
m = this.m_proxyB.GetSupportVertex(m);
m = w.MulX(e, m);
return r = (m.x - f.x) * r.x + (m.y - f.y) * r.y;
case d.e_faceB:
r = w.MulMV(e.R, this.m_axis);
m = w.MulX(e, this.m_localPoint);
f = w.MulTMV(b.R, r.GetNegative());
f = this.m_proxyA.GetSupportVertex(f);
f = w.MulX(b, f);
return r = (f.x - m.x) * r.x + (f.y - m.y) * r.y;
default:
y.b2Assert(false);
return 0
}
};
Box2D.postDefs.push(function () {
Box2D.Collision.b2SeparationFunction.e_points = 1;
Box2D.Collision.b2SeparationFunction.e_faceA = 2;
Box2D.Collision.b2SeparationFunction.e_faceB = 4
});
h.b2Simplex = function () {
this.m_v1 = new j;
this.m_v2 = new j;
this.m_v3 = new j;
this.m_vertices = new Vector(3)
};
h.prototype.b2Simplex = function () {
this.m_vertices[0] = this.m_v1;
this.m_vertices[1] = this.m_v2;
this.m_vertices[2] = this.m_v3
};
h.prototype.ReadCache = function (b, e, f, m, r) {
y.b2Assert(0 <= b.count && b.count <= 3);
var s, v;
this.m_count = b.count;
for (var t = this.m_vertices, x = 0; x < this.m_count; x++) {
var C = t[x];
C.indexA = b.indexA[x];
C.indexB = b.indexB[x];
s = e.GetVertex(C.indexA);
v = m.GetVertex(C.indexB);
C.wA = w.MulX(f, s);
C.wB = w.MulX(r, v);
C.w = w.SubtractVV(C.wB, C.wA);
C.a = 0
}
if (this.m_count > 1) {
b = b.metric;
s = this.GetMetric();
if (s < 0.5 * b || 2 * b < s || s < Number.MIN_VALUE) this.m_count = 0
}
if (this.m_count == 0) {
C = t[0];
C.indexA = 0;
C.indexB = 0;
s = e.GetVertex(0);
v = m.GetVertex(0);
C.wA = w.MulX(f, s);
C.wB = w.MulX(r, v);
C.w = w.SubtractVV(C.wB, C.wA);
this.m_count = 1
}
};
h.prototype.WriteCache = function (b) {
b.metric = this.GetMetric();
b.count = Box2D.parseUInt(this.m_count);
for (var e = this.m_vertices, f = 0; f < this.m_count; f++) {
b.indexA[f] = Box2D.parseUInt(e[f].indexA);
b.indexB[f] = Box2D.parseUInt(e[f].indexB)
}
};
h.prototype.GetSearchDirection = function () {
switch (this.m_count) {
case 1:
return this.m_v1.w.GetNegative();
case 2:
var b = w.SubtractVV(this.m_v2.w, this.m_v1.w);
return w.CrossVV(b, this.m_v1.w.GetNegative()) > 0 ? w.CrossFV(1, b) : w.CrossVF(b, 1);
default:
y.b2Assert(false);
return new p
}
};
h.prototype.GetClosestPoint = function () {
switch (this.m_count) {
case 0:
y.b2Assert(false);
return new p;
case 1:
return this.m_v1.w;
case 2:
return new p(this.m_v1.a * this.m_v1.w.x + this.m_v2.a * this.m_v2.w.x, this.m_v1.a * this.m_v1.w.y + this.m_v2.a * this.m_v2.w.y);
default:
y.b2Assert(false);
return new p
}
};
h.prototype.GetWitnessPoints = function (b, e) {
switch (this.m_count) {
case 0:
y.b2Assert(false);
break;
case 1:
b.SetV(this.m_v1.wA);
e.SetV(this.m_v1.wB);
break;
case 2:
b.x = this.m_v1.a * this.m_v1.wA.x + this.m_v2.a * this.m_v2.wA.x;
b.y = this.m_v1.a * this.m_v1.wA.y + this.m_v2.a * this.m_v2.wA.y;
e.x = this.m_v1.a * this.m_v1.wB.x + this.m_v2.a * this.m_v2.wB.x;
e.y = this.m_v1.a * this.m_v1.wB.y + this.m_v2.a * this.m_v2.wB.y;
break;
case 3:
e.x = b.x = this.m_v1.a * this.m_v1.wA.x + this.m_v2.a * this.m_v2.wA.x + this.m_v3.a * this.m_v3.wA.x;
e.y = b.y = this.m_v1.a * this.m_v1.wA.y + this.m_v2.a * this.m_v2.wA.y + this.m_v3.a * this.m_v3.wA.y;
break;
default:
y.b2Assert(false)
}
};
h.prototype.GetMetric = function () {
switch (this.m_count) {
case 0:
y.b2Assert(false);
return 0;
case 1:
return 0;
case 2:
return w.SubtractVV(this.m_v1.w,
this.m_v2.w).Length();
case 3:
return w.CrossVV(w.SubtractVV(this.m_v2.w, this.m_v1.w), w.SubtractVV(this.m_v3.w, this.m_v1.w));
default:
y.b2Assert(false);
return 0
}
};
h.prototype.Solve2 = function () {
var b = this.m_v1.w,
e = this.m_v2.w,
f = w.SubtractVV(e, b);
b = -(b.x * f.x + b.y * f.y);
if (b <= 0) this.m_count = this.m_v1.a = 1;
else {
e = e.x * f.x + e.y * f.y;
if (e <= 0) {
this.m_count = this.m_v2.a = 1;
this.m_v1.Set(this.m_v2)
} else {
f = 1 / (e + b);
this.m_v1.a = e * f;
this.m_v2.a = b * f;
this.m_count = 2
}
}
};
h.prototype.Solve3 = function () {
var b = this.m_v1.w,
e = this.m_v2.w,
f = this.m_v3.w,
m = w.SubtractVV(e, b),
r = w.Dot(b, m),
s = w.Dot(e, m);
r = -r;
var v = w.SubtractVV(f, b),
t = w.Dot(b, v),
x = w.Dot(f, v);
t = -t;
var C = w.SubtractVV(f, e),
J = w.Dot(e, C);
C = w.Dot(f, C);
J = -J;
v = w.CrossVV(m, v);
m = v * w.CrossVV(e, f);
f = v * w.CrossVV(f, b);
b = v * w.CrossVV(b, e);
if (r <= 0 && t <= 0) this.m_count = this.m_v1.a = 1;
else if (s > 0 && r > 0 && b <= 0) {
x = 1 / (s + r);
this.m_v1.a = s * x;
this.m_v2.a = r * x;
this.m_count = 2
} else if (x > 0 && t > 0 && f <= 0) {
s = 1 / (x + t);
this.m_v1.a = x * s;
this.m_v3.a = t * s;
this.m_count = 2;
this.m_v2.Set(this.m_v3)
} else if (s <= 0 && J <= 0) {
this.m_count = this.m_v2.a = 1;
this.m_v1.Set(this.m_v2)
} else if (x <= 0 && C <= 0) {
this.m_count = this.m_v3.a = 1;
this.m_v1.Set(this.m_v3)
} else if (C > 0 && J > 0 && m <= 0) {
s = 1 / (C + J);
this.m_v2.a = C * s;
this.m_v3.a = J * s;
this.m_count = 2;
this.m_v1.Set(this.m_v3)
} else {
s = 1 / (m + f + b);
this.m_v1.a = m * s;
this.m_v2.a = f * s;
this.m_v3.a = b * s;
this.m_count = 3
}
};
l.b2SimplexCache = function () {
this.indexA = new Vector_a2j_Number(3);
this.indexB = new Vector_a2j_Number(3)
};
j.b2SimplexVertex = function () {};
j.prototype.Set = function (b) {
this.wA.SetV(b.wA);
this.wB.SetV(b.wB);
this.w.SetV(b.w);
this.a = b.a;
this.indexA = b.indexA;
this.indexB = b.indexB
};
o.b2TimeOfImpact = function () {};
o.TimeOfImpact = function (b) {
++o.b2_toiCalls;
var e = b.proxyA,
f = b.proxyB,
m = b.sweepA,
r = b.sweepB;
y.b2Assert(m.t0 == r.t0);
y.b2Assert(1 - m.t0 > Number.MIN_VALUE);
var s = e.m_radius + f.m_radius;
b = b.tolerance;
var v = 0,
t = 0,
x = 0;
o.s_cache.count = 0;
for (o.s_distanceInput.useRadii = false;;) {
m.GetTransform(o.s_xfA, v);
r.GetTransform(o.s_xfB, v);
o.s_distanceInput.proxyA = e;
o.s_distanceInput.proxyB = f;
o.s_distanceInput.transformA = o.s_xfA;
o.s_distanceInput.transformB = o.s_xfB;
W.Distance(o.s_distanceOutput, o.s_cache, o.s_distanceInput);
if (o.s_distanceOutput.distance <= 0) {
v = 1;
break
}
o.s_fcn.Initialize(o.s_cache, e, o.s_xfA, f, o.s_xfB);
var C = o.s_fcn.Evaluate(o.s_xfA, o.s_xfB);
if (C <= 0) {
v = 1;
break
}
if (t == 0) x = C > s ? w.Max(s - b, 0.75 * s) : w.Max(C - b, 0.02 * s);
if (C - x < 0.5 * b) {
if (t == 0) {
v = 1;
break
}
break
}
var J = v,
T = v,
P = 1;
C = C;
m.GetTransform(o.s_xfA, P);
r.GetTransform(o.s_xfB, P);
var X = o.s_fcn.Evaluate(o.s_xfA, o.s_xfB);
if (X >= x) {
v = 1;
break
}
for (var $ = 0;;) {
var ba = 0;
ba = $ & 1 ? T + (x - C) * (P - T) / (X - C) : 0.5 * (T + P);
m.GetTransform(o.s_xfA, ba);
r.GetTransform(o.s_xfB, ba);
var ca = o.s_fcn.Evaluate(o.s_xfA, o.s_xfB);
if (w.Abs(ca - x) < 0.025 * b) {
J = ba;
break
}
if (ca > x) {
T = ba;
C = ca
} else {
P = ba;
X = ca
}++$;
++o.b2_toiRootIters;
if ($ == 50) break
}
o.b2_toiMaxRootIters = w.Max(o.b2_toiMaxRootIters, $);
if (J < (1 + 100 * Number.MIN_VALUE) * v) break;
v = J;
t++;
++o.b2_toiIters;
if (t == 1E3) break
}
o.b2_toiMaxIters = w.Max(o.b2_toiMaxIters, t);
return v
};
Box2D.postDefs.push(function () {
Box2D.Collision.b2TimeOfImpact.b2_toiCalls = 0;
Box2D.Collision.b2TimeOfImpact.b2_toiIters = 0;
Box2D.Collision.b2TimeOfImpact.b2_toiMaxIters = 0;
Box2D.Collision.b2TimeOfImpact.b2_toiRootIters = 0;
Box2D.Collision.b2TimeOfImpact.b2_toiMaxRootIters = 0;
Box2D.Collision.b2TimeOfImpact.s_cache = new l;
Box2D.Collision.b2TimeOfImpact.s_distanceInput = new Y;
Box2D.Collision.b2TimeOfImpact.s_xfA = new U;
Box2D.Collision.b2TimeOfImpact.s_xfB = new U;
Box2D.Collision.b2TimeOfImpact.s_fcn = new d;
Box2D.Collision.b2TimeOfImpact.s_distanceOutput = new k
});
q.b2TOIInput = function () {
this.proxyA = new z;
this.proxyB = new z;
this.sweepA = new A;
this.sweepB = new A
};
n.b2WorldManifold = function () {
this.m_normal = new p
};
n.prototype.b2WorldManifold = function () {
this.m_points = new Vector(y.b2_maxManifoldPoints);
for (var b = 0; b < y.b2_maxManifoldPoints; b++) this.m_points[b] = new p
};
n.prototype.Initialize = function (b, e, f, m, r) {
if (f === undefined) f = 0;
if (r === undefined) r = 0;
if (b.m_pointCount != 0) {
var s = 0,
v, t, x = 0,
C = 0,
J = 0,
T = 0,
P = 0;
v = 0;
switch (b.m_type) {
case E.e_circles:
t = e.R;
v = b.m_localPoint;
s = e.position.x + t.col1.x * v.x + t.col2.x * v.y;
e = e.position.y + t.col1.y * v.x + t.col2.y * v.y;
t = m.R;
v = b.m_points[0].m_localPoint;
b = m.position.x + t.col1.x * v.x + t.col2.x * v.y;
m = m.position.y + t.col1.y * v.x + t.col2.y * v.y;
v = b - s;
t = m - e;
x = v * v + t * t;
if (x > Number.MIN_VALUE * Number.MIN_VALUE) {
x = Math.sqrt(x);
this.m_normal.x = v / x;
this.m_normal.y = t / x
} else {
this.m_normal.x = 1;
this.m_normal.y = 0
}
v = e + f * this.m_normal.y;
m = m - r * this.m_normal.y;
this.m_points[0].x = 0.5 * (s + f * this.m_normal.x + (b - r * this.m_normal.x));
this.m_points[0].y = 0.5 * (v + m);
break;
case E.e_faceA:
t = e.R;
v = b.m_localPlaneNormal;
x = t.col1.x * v.x + t.col2.x * v.y;
C = t.col1.y * v.x + t.col2.y * v.y;
t = e.R;
v = b.m_localPoint;
J = e.position.x + t.col1.x * v.x + t.col2.x * v.y;
T = e.position.y + t.col1.y * v.x + t.col2.y * v.y;
this.m_normal.x = x;
this.m_normal.y = C;
for (s = 0; s < b.m_pointCount; s++) {
t = m.R;
v = b.m_points[s].m_localPoint;
P = m.position.x + t.col1.x * v.x + t.col2.x * v.y;
v = m.position.y + t.col1.y * v.x + t.col2.y * v.y;
this.m_points[s].x = P + 0.5 * (f - (P - J) * x - (v - T) * C - r) * x;
this.m_points[s].y = v + 0.5 * (f - (P - J) * x - (v - T) * C - r) * C
}
break;
case E.e_faceB:
t = m.R;
v = b.m_localPlaneNormal;
x = t.col1.x * v.x + t.col2.x * v.y;
C = t.col1.y * v.x + t.col2.y * v.y;
t = m.R;
v = b.m_localPoint;
J = m.position.x + t.col1.x * v.x + t.col2.x * v.y;
T = m.position.y + t.col1.y * v.x + t.col2.y * v.y;
this.m_normal.x = -x;
this.m_normal.y = -C;
for (s = 0; s < b.m_pointCount; s++) {
t = e.R;
v = b.m_points[s].m_localPoint;
P = e.position.x + t.col1.x * v.x + t.col2.x * v.y;
v = e.position.y + t.col1.y * v.x + t.col2.y * v.y;
this.m_points[s].x = P + 0.5 * (r - (P - J) * x - (v - T) * C - f) * x;
this.m_points[s].y = v + 0.5 * (r - (P - J) * x - (v - T) * C - f) * C
}
}
}
};
a.ClipVertex = function () {
this.v = new p;
this.id = new L
};
a.prototype.Set = function (b) {
this.v.SetV(b.v);
this.id.Set(b.id)
};
c.Features = function () {};
Object.defineProperty(c.prototype, "referenceEdge", {
enumerable: false,
configurable: true,
get: function () {
return this._referenceEdge
}
});
Object.defineProperty(c.prototype, "referenceEdge", {
enumerable: false,
configurable: true,
set: function (b) {
if (b === undefined) b = 0;
this._referenceEdge = b;
this._m_id._key = this._m_id._key & 4294967040 | this._referenceEdge & 255
}
});
Object.defineProperty(c.prototype, "incidentEdge", {
enumerable: false,
configurable: true,
get: function () {
return this._incidentEdge
}
});
Object.defineProperty(c.prototype,
"incidentEdge", {
enumerable: false,
configurable: true,
set: function (b) {
if (b === undefined) b = 0;
this._incidentEdge = b;
this._m_id._key = this._m_id._key & 4294902015 | this._incidentEdge << 8 & 65280
}
});
Object.defineProperty(c.prototype, "incidentVertex", {
enumerable: false,
configurable: true,
get: function () {
return this._incidentVertex
}
});
Object.defineProperty(c.prototype, "incidentVertex", {
enumerable: false,
configurable: true,
set: function (b) {
if (b === undefined) b = 0;
this._incidentVertex = b;
this._m_id._key = this._m_id._key & 4278255615 |
this._incidentVertex << 16 & 16711680
}
});
Object.defineProperty(c.prototype, "flip", {
enumerable: false,
configurable: true,
get: function () {
return this._flip
}
});
Object.defineProperty(c.prototype, "flip", {
enumerable: false,
configurable: true,
set: function (b) {
if (b === undefined) b = 0;
this._flip = b;
this._m_id._key = this._m_id._key & 16777215 | this._flip << 24 & 4278190080
}
})
})();
(function () {
var F = Box2D.Common.b2Settings,
G = Box2D.Collision.Shapes.b2CircleShape,
K = Box2D.Collision.Shapes.b2EdgeChainDef,
y = Box2D.Collision.Shapes.b2EdgeShape,
w = Box2D.Collision.Shapes.b2MassData,
A = Box2D.Collision.Shapes.b2PolygonShape,
U = Box2D.Collision.Shapes.b2Shape,
p = Box2D.Common.Math.b2Mat22,
B = Box2D.Common.Math.b2Math,
Q = Box2D.Common.Math.b2Transform,
V = Box2D.Common.Math.b2Vec2,
M = Box2D.Collision.b2Distance,
L = Box2D.Collision.b2DistanceInput,
I = Box2D.Collision.b2DistanceOutput,
W = Box2D.Collision.b2DistanceProxy,
Y = Box2D.Collision.b2SimplexCache;
Box2D.inherit(G, Box2D.Collision.Shapes.b2Shape);
G.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
G.b2CircleShape = function () {
Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments);
this.m_p = new V
};
G.prototype.Copy = function () {
var k = new G;
k.Set(this);
return k
};
G.prototype.Set = function (k) {
this.__super.Set.call(this, k);
if (Box2D.is(k, G)) this.m_p.SetV((k instanceof G ? k : null).m_p)
};
G.prototype.TestPoint = function (k, z) {
var u = k.R,
D = k.position.x + (u.col1.x * this.m_p.x + u.col2.x * this.m_p.y);
u = k.position.y + (u.col1.y * this.m_p.x + u.col2.y * this.m_p.y);
D = z.x - D;
u = z.y - u;
return D * D + u * u <= this.m_radius * this.m_radius
};
G.prototype.RayCast = function (k, z, u) {
var D = u.R,
H = z.p1.x - (u.position.x + (D.col1.x * this.m_p.x + D.col2.x * this.m_p.y));
u = z.p1.y - (u.position.y + (D.col1.y * this.m_p.x + D.col2.y * this.m_p.y));
D = z.p2.x - z.p1.x;
var O = z.p2.y - z.p1.y,
E = H * D + u * O,
R = D * D + O * O,
N = E * E - R * (H * H + u * u - this.m_radius * this.m_radius);
if (N < 0 || R < Number.MIN_VALUE) return false;
E = -(E + Math.sqrt(N));
if (0 <= E && E <= z.maxFraction * R) {
E /= R;
k.fraction = E;
k.normal.x = H + E * D;
k.normal.y = u + E * O;
k.normal.Normalize();
return true
}
return false
};
G.prototype.ComputeAABB = function (k, z) {
var u = z.R,
D = z.position.x + (u.col1.x * this.m_p.x + u.col2.x * this.m_p.y);
u = z.position.y + (u.col1.y * this.m_p.x + u.col2.y * this.m_p.y);
k.lowerBound.Set(D - this.m_radius, u - this.m_radius);
k.upperBound.Set(D + this.m_radius, u + this.m_radius)
};
G.prototype.ComputeMass = function (k, z) {
if (z === undefined) z = 0;
k.mass = z * F.b2_pi * this.m_radius * this.m_radius;
k.center.SetV(this.m_p);
k.I = k.mass * (0.5 * this.m_radius * this.m_radius + (this.m_p.x * this.m_p.x + this.m_p.y * this.m_p.y))
};
G.prototype.ComputeSubmergedArea = function (k, z, u, D) {
if (z === undefined) z = 0;
u = B.MulX(u, this.m_p);
var H = -(B.Dot(k, u) - z);
if (H < -this.m_radius + Number.MIN_VALUE) return 0;
if (H > this.m_radius) {
D.SetV(u);
return Math.PI * this.m_radius * this.m_radius
}
z = this.m_radius * this.m_radius;
var O = H * H;
H = z * (Math.asin(H / this.m_radius) + Math.PI / 2) + H * Math.sqrt(z - O);
z = -2 / 3 * Math.pow(z - O, 1.5) / H;
D.x = u.x + k.x * z;
D.y = u.y + k.y * z;
return H
};
G.prototype.GetLocalPosition = function () {
return this.m_p
};
G.prototype.SetLocalPosition = function (k) {
this.m_p.SetV(k)
};
G.prototype.GetRadius = function () {
return this.m_radius
};
G.prototype.SetRadius = function (k) {
if (k === undefined) k = 0;
this.m_radius = k
};
G.prototype.b2CircleShape = function (k) {
if (k === undefined) k = 0;
this.__super.b2Shape.call(this);
this.m_type = U.e_circleShape;
this.m_radius = k
};
K.b2EdgeChainDef = function () {};
K.prototype.b2EdgeChainDef = function () {
this.vertexCount = 0;
this.isALoop = true;
this.vertices = []
};
Box2D.inherit(y, Box2D.Collision.Shapes.b2Shape);
y.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
y.b2EdgeShape = function () {
Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments);
this.s_supportVec = new V;
this.m_v1 = new V;
this.m_v2 = new V;
this.m_coreV1 = new V;
this.m_coreV2 = new V;
this.m_normal = new V;
this.m_direction = new V;
this.m_cornerDir1 = new V;
this.m_cornerDir2 = new V
};
y.prototype.TestPoint = function () {
return false
};
y.prototype.RayCast = function (k, z, u) {
var D, H = z.p2.x - z.p1.x,
O = z.p2.y - z.p1.y;
D = u.R;
var E = u.position.x + (D.col1.x * this.m_v1.x + D.col2.x * this.m_v1.y),
R = u.position.y + (D.col1.y * this.m_v1.x + D.col2.y * this.m_v1.y),
N = u.position.y + (D.col1.y * this.m_v2.x + D.col2.y * this.m_v2.y) - R;
u = -(u.position.x + (D.col1.x * this.m_v2.x + D.col2.x * this.m_v2.y) - E);
D = 100 * Number.MIN_VALUE;
var S = -(H * N + O * u);
if (S > D) {
E = z.p1.x - E;
var aa = z.p1.y - R;
R = E * N + aa * u;
if (0 <= R && R <= z.maxFraction * S) {
z = -H * aa + O * E;
if (-D * S <= z && z <= S * (1 + D)) {
R /= S;
k.fraction = R;
z = Math.sqrt(N * N + u * u);
k.normal.x = N / z;
k.normal.y = u / z;
return true
}
}
}
return false
};
y.prototype.ComputeAABB = function (k, z) {
var u = z.R,
D = z.position.x + (u.col1.x * this.m_v1.x + u.col2.x * this.m_v1.y),
H = z.position.y + (u.col1.y * this.m_v1.x + u.col2.y * this.m_v1.y),
O = z.position.x + (u.col1.x * this.m_v2.x + u.col2.x * this.m_v2.y);
u = z.position.y + (u.col1.y * this.m_v2.x + u.col2.y * this.m_v2.y);
if (D < O) {
k.lowerBound.x = D;
k.upperBound.x = O
} else {
k.lowerBound.x = O;
k.upperBound.x = D
} if (H < u) {
k.lowerBound.y = H;
k.upperBound.y = u
} else {
k.lowerBound.y = u;
k.upperBound.y = H
}
};
y.prototype.ComputeMass = function (k) {
k.mass = 0;
k.center.SetV(this.m_v1);
k.I = 0
};
y.prototype.ComputeSubmergedArea = function (k, z, u, D) {
if (z === undefined) z = 0;
var H = new V(k.x * z, k.y * z),
O = B.MulX(u, this.m_v1);
u = B.MulX(u, this.m_v2);
var E = B.Dot(k, O) - z;
k = B.Dot(k, u) - z;
if (E > 0)
if (k > 0) return 0;
else {
O.x = -k / (E - k) * O.x + E / (E - k) * u.x;
O.y = -k / (E - k) * O.y + E / (E - k) * u.y
} else if (k > 0) {
u.x = -k / (E - k) * O.x + E / (E - k) * u.x;
u.y = -k / (E - k) * O.y + E / (E - k) * u.y
}
D.x = (H.x + O.x + u.x) / 3;
D.y = (H.y + O.y + u.y) / 3;
return 0.5 * ((O.x - H.x) * (u.y - H.y) - (O.y - H.y) * (u.x - H.x))
};
y.prototype.GetLength = function () {
return this.m_length
};
y.prototype.GetVertex1 = function () {
return this.m_v1
};
y.prototype.GetVertex2 = function () {
return this.m_v2
};
y.prototype.GetCoreVertex1 = function () {
return this.m_coreV1
};
y.prototype.GetCoreVertex2 = function () {
return this.m_coreV2
};
y.prototype.GetNormalVector = function () {
return this.m_normal
};
y.prototype.GetDirectionVector = function () {
return this.m_direction
};
y.prototype.GetCorner1Vector = function () {
return this.m_cornerDir1
};
y.prototype.GetCorner2Vector = function () {
return this.m_cornerDir2
};
y.prototype.Corner1IsConvex = function () {
return this.m_cornerConvex1
};
y.prototype.Corner2IsConvex = function () {
return this.m_cornerConvex2
};
y.prototype.GetFirstVertex = function (k) {
var z = k.R;
return new V(k.position.x + (z.col1.x * this.m_coreV1.x + z.col2.x * this.m_coreV1.y), k.position.y + (z.col1.y * this.m_coreV1.x + z.col2.y * this.m_coreV1.y))
};
y.prototype.GetNextEdge = function () {
return this.m_nextEdge
};
y.prototype.GetPrevEdge = function () {
return this.m_prevEdge
};
y.prototype.Support = function (k, z, u) {
if (z === undefined) z = 0;
if (u === undefined) u = 0;
var D = k.R,
H = k.position.x + (D.col1.x * this.m_coreV1.x + D.col2.x * this.m_coreV1.y),
O = k.position.y + (D.col1.y * this.m_coreV1.x + D.col2.y * this.m_coreV1.y),
E = k.position.x + (D.col1.x * this.m_coreV2.x + D.col2.x * this.m_coreV2.y);
k = k.position.y + (D.col1.y * this.m_coreV2.x + D.col2.y * this.m_coreV2.y);
if (H * z + O * u > E * z + k * u) {
this.s_supportVec.x = H;
this.s_supportVec.y = O
} else {
this.s_supportVec.x = E;
this.s_supportVec.y = k
}
return this.s_supportVec
};
y.prototype.b2EdgeShape = function (k, z) {
this.__super.b2Shape.call(this);
this.m_type = U.e_edgeShape;
this.m_nextEdge = this.m_prevEdge = null;
this.m_v1 = k;
this.m_v2 = z;
this.m_direction.Set(this.m_v2.x - this.m_v1.x, this.m_v2.y - this.m_v1.y);
this.m_length = this.m_direction.Normalize();
this.m_normal.Set(this.m_direction.y, -this.m_direction.x);
this.m_coreV1.Set(-F.b2_toiSlop * (this.m_normal.x - this.m_direction.x) + this.m_v1.x, -F.b2_toiSlop * (this.m_normal.y - this.m_direction.y) + this.m_v1.y);
this.m_coreV2.Set(-F.b2_toiSlop * (this.m_normal.x + this.m_direction.x) + this.m_v2.x, -F.b2_toiSlop * (this.m_normal.y + this.m_direction.y) + this.m_v2.y);
this.m_cornerDir1 = this.m_normal;
this.m_cornerDir2.Set(-this.m_normal.x, -this.m_normal.y)
};
y.prototype.SetPrevEdge = function (k, z, u, D) {
this.m_prevEdge = k;
this.m_coreV1 = z;
this.m_cornerDir1 = u;
this.m_cornerConvex1 = D
};
y.prototype.SetNextEdge = function (k, z, u, D) {
this.m_nextEdge = k;
this.m_coreV2 = z;
this.m_cornerDir2 = u;
this.m_cornerConvex2 = D
};
w.b2MassData = function () {
this.mass = 0;
this.center = new V(0, 0);
this.I = 0
};
Box2D.inherit(A, Box2D.Collision.Shapes.b2Shape);
A.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
A.b2PolygonShape = function () {
Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments)
};
A.prototype.Copy = function () {
var k = new A;
k.Set(this);
return k
};
A.prototype.Set = function (k) {
this.__super.Set.call(this, k);
if (Box2D.is(k, A)) {
k = k instanceof A ? k : null;
this.m_centroid.SetV(k.m_centroid);
this.m_vertexCount = k.m_vertexCount;
this.Reserve(this.m_vertexCount);
for (var z = 0; z < this.m_vertexCount; z++) {
this.m_vertices[z].SetV(k.m_vertices[z]);
this.m_normals[z].SetV(k.m_normals[z])
}
}
};
A.prototype.SetAsArray = function (k, z) {
if (z === undefined) z = 0;
var u = new Vector,
D = 0,
H;
for (D = 0; D < k.length; ++D) {
H = k[D];
u.push(H)
}
this.SetAsVector(u,
z)
};
A.AsArray = function (k, z) {
if (z === undefined) z = 0;
var u = new A;
u.SetAsArray(k, z);
return u
};
A.prototype.SetAsVector = function (k, z) {
if (z === undefined) z = 0;
if (z == 0) z = k.length;
F.b2Assert(2 <= z);
this.m_vertexCount = z;
this.Reserve(z);
var u = 0;
for (u = 0; u < this.m_vertexCount; u++) this.m_vertices[u].SetV(k[u]);
for (u = 0; u < this.m_vertexCount; ++u) {
var D = parseInt(u),
H = parseInt(u + 1 < this.m_vertexCount ? u + 1 : 0);
D = B.SubtractVV(this.m_vertices[H], this.m_vertices[D]);
F.b2Assert(D.LengthSquared() > Number.MIN_VALUE);
this.m_normals[u].SetV(B.CrossVF(D,
1));
this.m_normals[u].Normalize()
}
this.m_centroid = A.ComputeCentroid(this.m_vertices, this.m_vertexCount)
};
A.AsVector = function (k, z) {
if (z === undefined) z = 0;
var u = new A;
u.SetAsVector(k, z);
return u
};
A.prototype.SetAsBox = function (k, z) {
if (k === undefined) k = 0;
if (z === undefined) z = 0;
this.m_vertexCount = 4;
this.Reserve(4);
this.m_vertices[0].Set(-k, -z);
this.m_vertices[1].Set(k, -z);
this.m_vertices[2].Set(k, z);
this.m_vertices[3].Set(-k, z);
this.m_normals[0].Set(0, -1);
this.m_normals[1].Set(1, 0);
this.m_normals[2].Set(0,
1);
this.m_normals[3].Set(-1, 0);
this.m_centroid.SetZero()
};
A.AsBox = function (k, z) {
if (k === undefined) k = 0;
if (z === undefined) z = 0;
var u = new A;
u.SetAsBox(k, z);
return u
};
A.prototype.SetAsOrientedBox = function (k, z, u, D) {
if (k === undefined) k = 0;
if (z === undefined) z = 0;
if (u === undefined) u = null;
if (D === undefined) D = 0;
this.m_vertexCount = 4;
this.Reserve(4);
this.m_vertices[0].Set(-k, -z);
this.m_vertices[1].Set(k, -z);
this.m_vertices[2].Set(k, z);
this.m_vertices[3].Set(-k, z);
this.m_normals[0].Set(0, -1);
this.m_normals[1].Set(1, 0);
this.m_normals[2].Set(0, 1);
this.m_normals[3].Set(-1, 0);
this.m_centroid = u;
k = new Q;
k.position = u;
k.R.Set(D);
for (u = 0; u < this.m_vertexCount; ++u) {
this.m_vertices[u] = B.MulX(k, this.m_vertices[u]);
this.m_normals[u] = B.MulMV(k.R, this.m_normals[u])
}
};
A.AsOrientedBox = function (k, z, u, D) {
if (k === undefined) k = 0;
if (z === undefined) z = 0;
if (u === undefined) u = null;
if (D === undefined) D = 0;
var H = new A;
H.SetAsOrientedBox(k, z, u, D);
return H
};
A.prototype.SetAsEdge = function (k, z) {
this.m_vertexCount = 2;
this.Reserve(2);
this.m_vertices[0].SetV(k);
this.m_vertices[1].SetV(z);
this.m_centroid.x = 0.5 * (k.x + z.x);
this.m_centroid.y = 0.5 * (k.y + z.y);
this.m_normals[0] = B.CrossVF(B.SubtractVV(z, k), 1);
this.m_normals[0].Normalize();
this.m_normals[1].x = -this.m_normals[0].x;
this.m_normals[1].y = -this.m_normals[0].y
};
A.AsEdge = function (k, z) {
var u = new A;
u.SetAsEdge(k, z);
return u
};
A.prototype.TestPoint = function (k, z) {
var u;
u = k.R;
for (var D = z.x - k.position.x, H = z.y - k.position.y, O = D * u.col1.x + H * u.col1.y, E = D * u.col2.x + H * u.col2.y, R = 0; R < this.m_vertexCount; ++R) {
u = this.m_vertices[R];
D = O - u.x;
H = E - u.y;
u = this.m_normals[R];
if (u.x * D + u.y * H > 0) return false
}
return true
};
A.prototype.RayCast = function (k, z, u) {
var D = 0,
H = z.maxFraction,
O = 0,
E = 0,
R, N;
O = z.p1.x - u.position.x;
E = z.p1.y - u.position.y;
R = u.R;
var S = O * R.col1.x + E * R.col1.y,
aa = O * R.col2.x + E * R.col2.y;
O = z.p2.x - u.position.x;
E = z.p2.y - u.position.y;
R = u.R;
z = O * R.col1.x + E * R.col1.y - S;
R = O * R.col2.x + E * R.col2.y - aa;
for (var Z = parseInt(-1), d = 0; d < this.m_vertexCount; ++d) {
N = this.m_vertices[d];
O = N.x - S;
E = N.y - aa;
N = this.m_normals[d];
O = N.x * O + N.y * E;
E = N.x * z + N.y * R;
if (E == 0) {
if (O < 0) return false
} else if (E < 0 && O < D * E) {
D = O / E;
Z = d
} else if (E > 0 && O < H * E) H = O / E;
if (H < D - Number.MIN_VALUE) return false
}
if (Z >= 0) {
k.fraction = D;
R = u.R;
N = this.m_normals[Z];
k.normal.x = R.col1.x * N.x + R.col2.x * N.y;
k.normal.y = R.col1.y * N.x + R.col2.y * N.y;
return true
}
return false
};
A.prototype.ComputeAABB = function (k, z) {
for (var u = z.R, D = this.m_vertices[0], H = z.position.x + (u.col1.x * D.x + u.col2.x * D.y), O = z.position.y + (u.col1.y * D.x + u.col2.y * D.y), E = H, R = O, N = 1; N < this.m_vertexCount; ++N) {
D = this.m_vertices[N];
var S = z.position.x + (u.col1.x * D.x + u.col2.x * D.y);
D = z.position.y + (u.col1.y * D.x + u.col2.y * D.y);
H = H < S ? H : S;
O = O < D ? O : D;
E = E > S ? E : S;
R = R > D ? R : D
}
k.lowerBound.x = H - this.m_radius;
k.lowerBound.y = O - this.m_radius;
k.upperBound.x = E + this.m_radius;
k.upperBound.y = R + this.m_radius
};
A.prototype.ComputeMass = function (k, z) {
if (z === undefined) z = 0;
if (this.m_vertexCount == 2) {
k.center.x = 0.5 * (this.m_vertices[0].x + this.m_vertices[1].x);
k.center.y = 0.5 * (this.m_vertices[0].y + this.m_vertices[1].y);
k.mass = 0;
k.I = 0
} else {
for (var u = 0, D = 0, H = 0, O = 0, E = 1 / 3, R = 0; R < this.m_vertexCount; ++R) {
var N = this.m_vertices[R],
S = R + 1 < this.m_vertexCount ? this.m_vertices[parseInt(R + 1)] : this.m_vertices[0],
aa = N.x - 0,
Z = N.y - 0,
d = S.x - 0,
h = S.y - 0,
l = aa * h - Z * d,
j = 0.5 * l;
H += j;
u += j * E * (0 + N.x + S.x);
D += j * E * (0 + N.y + S.y);
N = aa;
Z = Z;
d = d;
h = h;
O += l * (E * (0.25 * (N * N + d * N + d * d) + (0 * N + 0 * d)) + 0 + (E * (0.25 * (Z * Z + h * Z + h * h) + (0 * Z + 0 * h)) + 0))
}
k.mass = z * H;
u *= 1 / H;
D *= 1 / H;
k.center.Set(u, D);
k.I = z * O
}
};
A.prototype.ComputeSubmergedArea = function (k, z, u, D) {
if (z === undefined) z = 0;
var H = B.MulTMV(u.R, k),
O = z - B.Dot(k, u.position),
E = new Vector_a2j_Number,
R = 0,
N = parseInt(-1);
z = parseInt(-1);
var S = false;
for (k = k = 0; k < this.m_vertexCount; ++k) {
E[k] = B.Dot(H, this.m_vertices[k]) - O;
var aa = E[k] < -Number.MIN_VALUE;
if (k > 0)
if (aa) {
if (!S) {
N = k - 1;
R++
}
} else if (S) {
z = k - 1;
R++
}
S = aa
}
switch (R) {
case 0:
if (S) {
k = new w;
this.ComputeMass(k, 1);
D.SetV(B.MulX(u, k.center));
return k.mass
} else return 0;
case 1:
if (N == -1) N = this.m_vertexCount - 1;
else z = this.m_vertexCount - 1
}
k = parseInt((N + 1) % this.m_vertexCount);
H = parseInt((z + 1) % this.m_vertexCount);
O = (0 - E[N]) / (E[k] - E[N]);
E = (0 - E[z]) / (E[H] - E[z]);
N = new V(this.m_vertices[N].x * (1 - O) + this.m_vertices[k].x * O, this.m_vertices[N].y * (1 - O) + this.m_vertices[k].y * O);
z = new V(this.m_vertices[z].x * (1 - E) + this.m_vertices[H].x * E, this.m_vertices[z].y * (1 - E) + this.m_vertices[H].y * E);
E = 0;
O = new V;
R = this.m_vertices[k];
for (k = k; k != H;) {
k = (k + 1) % this.m_vertexCount;
S = k == H ? z : this.m_vertices[k];
aa = 0.5 * ((R.x - N.x) * (S.y - N.y) - (R.y - N.y) * (S.x - N.x));
E += aa;
O.x += aa * (N.x + R.x + S.x) / 3;
O.y += aa * (N.y + R.y + S.y) / 3;
R = S
}
O.Multiply(1 / E);
D.SetV(B.MulX(u, O));
return E
};
A.prototype.GetVertexCount = function () {
return this.m_vertexCount
};
A.prototype.GetVertices = function () {
return this.m_vertices
};
A.prototype.GetNormals = function () {
return this.m_normals
};
A.prototype.GetSupport = function (k) {
for (var z = 0, u = this.m_vertices[0].x * k.x + this.m_vertices[0].y * k.y, D = 1; D < this.m_vertexCount; ++D) {
var H = this.m_vertices[D].x * k.x + this.m_vertices[D].y * k.y;
if (H > u) {
z = D;
u = H
}
}
return z
};
A.prototype.GetSupportVertex = function (k) {
for (var z = 0, u = this.m_vertices[0].x * k.x + this.m_vertices[0].y * k.y, D = 1; D < this.m_vertexCount; ++D) {
var H = this.m_vertices[D].x * k.x + this.m_vertices[D].y * k.y;
if (H > u) {
z = D;
u = H
}
}
return this.m_vertices[z]
};
A.prototype.Validate = function () {
return false
};
A.prototype.b2PolygonShape = function () {
this.__super.b2Shape.call(this);
this.m_type = U.e_polygonShape;
this.m_centroid = new V;
this.m_vertices = new Vector;
this.m_normals = new Vector
};
A.prototype.Reserve = function (k) {
if (k === undefined) k = 0;
for (var z = parseInt(this.m_vertices.length); z < k; z++) {
this.m_vertices[z] = new V;
this.m_normals[z] = new V
}
};
A.ComputeCentroid = function (k, z) {
if (z === undefined) z = 0;
for (var u = new V, D = 0, H = 1 / 3, O = 0; O < z; ++O) {
var E = k[O],
R = O + 1 < z ? k[parseInt(O + 1)] : k[0],
N = 0.5 * ((E.x - 0) * (R.y - 0) - (E.y - 0) * (R.x - 0));
D += N;
u.x += N * H * (0 + E.x + R.x);
u.y += N * H * (0 + E.y + R.y)
}
u.x *= 1 / D;
u.y *= 1 / D;
return u
};
A.ComputeOBB = function (k, z, u) {
if (u === undefined) u = 0;
var D = 0,
H = new Vector(u + 1);
for (D = 0; D < u; ++D) H[D] = z[D];
H[u] = H[0];
z = Number.MAX_VALUE;
for (D = 1; D <= u; ++D) {
var O = H[parseInt(D - 1)],
E = H[D].x - O.x,
R = H[D].y - O.y,
N = Math.sqrt(E * E + R * R);
E /= N;
R /= N;
for (var S = -R, aa = E, Z = N = Number.MAX_VALUE, d = -Number.MAX_VALUE, h = -Number.MAX_VALUE, l = 0; l < u; ++l) {
var j = H[l].x - O.x,
o = H[l].y - O.y,
q = E * j + R * o;
j = S * j + aa * o;
if (q < N) N = q;
if (j < Z) Z = j;
if (q > d) d = q;
if (j > h) h = j
}
l = (d - N) * (h - Z);
if (l < 0.95 * z) {
z = l;
k.R.col1.x = E;
k.R.col1.y = R;
k.R.col2.x = S;
k.R.col2.y = aa;
E = 0.5 * (N + d);
R = 0.5 * (Z + h);
S = k.R;
k.center.x = O.x + (S.col1.x * E + S.col2.x * R);
k.center.y = O.y + (S.col1.y * E + S.col2.y * R);
k.extents.x = 0.5 * (d - N);
k.extents.y = 0.5 * (h - Z)
}
}
};
Box2D.postDefs.push(function () {
Box2D.Collision.Shapes.b2PolygonShape.s_mat = new p
});
U.b2Shape = function () {};
U.prototype.Copy = function () {
return null
};
U.prototype.Set = function (k) {
this.m_radius = k.m_radius
};
U.prototype.GetType = function () {
return this.m_type
};
U.prototype.TestPoint = function () {
return false
};
U.prototype.RayCast = function () {
return false
};
U.prototype.ComputeAABB = function () {};
U.prototype.ComputeMass = function () {};
U.prototype.ComputeSubmergedArea = function () {
return 0
};
U.TestOverlap = function (k, z, u, D) {
var H = new L;
H.proxyA = new W;
H.proxyA.Set(k);
H.proxyB = new W;
H.proxyB.Set(u);
H.transformA = z;
H.transformB = D;
H.useRadii = true;
k = new Y;
k.count = 0;
z = new I;
M.Distance(z, k, H);
return z.distance < 10 * Number.MIN_VALUE
};
U.prototype.b2Shape = function () {
this.m_type = U.e_unknownShape;
this.m_radius = F.b2_linearSlop
};
Box2D.postDefs.push(function () {
Box2D.Collision.Shapes.b2Shape.e_unknownShape = parseInt(-1);
Box2D.Collision.Shapes.b2Shape.e_circleShape = 0;
Box2D.Collision.Shapes.b2Shape.e_polygonShape = 1;
Box2D.Collision.Shapes.b2Shape.e_edgeShape = 2;
Box2D.Collision.Shapes.b2Shape.e_shapeTypeCount = 3;
Box2D.Collision.Shapes.b2Shape.e_hitCollide = 1;
Box2D.Collision.Shapes.b2Shape.e_missCollide = 0;
Box2D.Collision.Shapes.b2Shape.e_startsInsideCollide = parseInt(-1)
})
})();
(function () {
var F = Box2D.Common.b2Color,
G = Box2D.Common.b2Settings,
K = Box2D.Common.Math.b2Math;
F.b2Color = function () {
this._b = this._g = this._r = 0
};
F.prototype.b2Color = function (y, w, A) {
if (y === undefined) y = 0;
if (w === undefined) w = 0;
if (A === undefined) A = 0;
this._r = Box2D.parseUInt(255 * K.Clamp(y, 0, 1));
this._g = Box2D.parseUInt(255 * K.Clamp(w, 0, 1));
this._b = Box2D.parseUInt(255 * K.Clamp(A, 0, 1))
};
F.prototype.Set = function (y, w, A) {
if (y === undefined) y = 0;
if (w === undefined) w = 0;
if (A === undefined) A = 0;
this._r = Box2D.parseUInt(255 * K.Clamp(y,
0, 1));
this._g = Box2D.parseUInt(255 * K.Clamp(w, 0, 1));
this._b = Box2D.parseUInt(255 * K.Clamp(A, 0, 1))
};
Object.defineProperty(F.prototype, "r", {
enumerable: false,
configurable: true,
set: function (y) {
if (y === undefined) y = 0;
this._r = Box2D.parseUInt(255 * K.Clamp(y, 0, 1))
}
});
Object.defineProperty(F.prototype, "g", {
enumerable: false,
configurable: true,
set: function (y) {
if (y === undefined) y = 0;
this._g = Box2D.parseUInt(255 * K.Clamp(y, 0, 1))
}
});
Object.defineProperty(F.prototype, "b", {
enumerable: false,
configurable: true,
set: function (y) {
if (y === undefined) y = 0;
this._b = Box2D.parseUInt(255 * K.Clamp(y, 0, 1))
}
});
Object.defineProperty(F.prototype, "color", {
enumerable: false,
configurable: true,
get: function () {
return this._r << 16 | this._g << 8 | this._b
}
});
G.b2Settings = function () {};
G.b2MixFriction = function (y, w) {
if (y === undefined) y = 0;
if (w === undefined) w = 0;
return Math.sqrt(y * w)
};
G.b2MixRestitution = function (y, w) {
if (y === undefined) y = 0;
if (w === undefined) w = 0;
return y > w ? y : w
};
G.b2Assert = function (y) {
if (!y) throw "Assertion Failed";
};
Box2D.postDefs.push(function () {
Box2D.Common.b2Settings.VERSION = "2.1alpha";
Box2D.Common.b2Settings.USHRT_MAX = 65535;
Box2D.Common.b2Settings.b2_pi = Math.PI;
Box2D.Common.b2Settings.b2_maxManifoldPoints = 2;
Box2D.Common.b2Settings.b2_aabbExtension = 0.1;
Box2D.Common.b2Settings.b2_aabbMultiplier = 2;
Box2D.Common.b2Settings.b2_polygonRadius = 2 * G.b2_linearSlop;
Box2D.Common.b2Settings.b2_linearSlop = 0.0050;
Box2D.Common.b2Settings.b2_angularSlop = 2 / 180 * G.b2_pi;
Box2D.Common.b2Settings.b2_toiSlop = 8 * G.b2_linearSlop;
Box2D.Common.b2Settings.b2_maxTOIContactsPerIsland = 32;
Box2D.Common.b2Settings.b2_maxTOIJointsPerIsland = 32;
Box2D.Common.b2Settings.b2_velocityThreshold = 1;
Box2D.Common.b2Settings.b2_maxLinearCorrection = 0.2;
Box2D.Common.b2Settings.b2_maxAngularCorrection = 8 / 180 * G.b2_pi;
Box2D.Common.b2Settings.b2_maxTranslation = 2;
Box2D.Common.b2Settings.b2_maxTranslationSquared = G.b2_maxTranslation * G.b2_maxTranslation;
Box2D.Common.b2Settings.b2_maxRotation = 0.5 * G.b2_pi;
Box2D.Common.b2Settings.b2_maxRotationSquared = G.b2_maxRotation * G.b2_maxRotation;
Box2D.Common.b2Settings.b2_contactBaumgarte = 0.2;
Box2D.Common.b2Settings.b2_timeToSleep = 0.5;
Box2D.Common.b2Settings.b2_linearSleepTolerance = 0.01;
Box2D.Common.b2Settings.b2_angularSleepTolerance = 2 / 180 * G.b2_pi
})
})();
(function () {
var F = Box2D.Common.Math.b2Mat22,
G = Box2D.Common.Math.b2Mat33,
K = Box2D.Common.Math.b2Math,
y = Box2D.Common.Math.b2Sweep,
w = Box2D.Common.Math.b2Transform,
A = Box2D.Common.Math.b2Vec2,
U = Box2D.Common.Math.b2Vec3;
F.b2Mat22 = function () {
this.col1 = new A;
this.col2 = new A
};
F.prototype.b2Mat22 = function () {
this.SetIdentity()
};
F.FromAngle = function (p) {
if (p === undefined) p = 0;
var B = new F;
B.Set(p);
return B
};
F.FromVV = function (p, B) {
var Q = new F;
Q.SetVV(p, B);
return Q
};
F.prototype.Set = function (p) {
if (p === undefined) p = 0;
var B = Math.cos(p);
p = Math.sin(p);
this.col1.x = B;
this.col2.x = -p;
this.col1.y = p;
this.col2.y = B
};
F.prototype.SetVV = function (p, B) {
this.col1.SetV(p);
this.col2.SetV(B)
};
F.prototype.Copy = function () {
var p = new F;
p.SetM(this);
return p
};
F.prototype.SetM = function (p) {
this.col1.SetV(p.col1);
this.col2.SetV(p.col2)
};
F.prototype.AddM = function (p) {
this.col1.x += p.col1.x;
this.col1.y += p.col1.y;
this.col2.x += p.col2.x;
this.col2.y += p.col2.y
};
F.prototype.SetIdentity = function () {
this.col1.x = 1;
this.col2.x = 0;
this.col1.y = 0;
this.col2.y = 1
};
F.prototype.SetZero = function () {
this.col1.x = 0;
this.col2.x = 0;
this.col1.y = 0;
this.col2.y = 0
};
F.prototype.GetAngle = function () {
return Math.atan2(this.col1.y, this.col1.x)
};
F.prototype.GetInverse = function (p) {
var B = this.col1.x,
Q = this.col2.x,
V = this.col1.y,
M = this.col2.y,
L = B * M - Q * V;
if (L != 0) L = 1 / L;
p.col1.x = L * M;
p.col2.x = -L * Q;
p.col1.y = -L * V;
p.col2.y = L * B;
return p
};
F.prototype.Solve = function (p, B, Q) {
if (B === undefined) B = 0;
if (Q === undefined) Q = 0;
var V = this.col1.x,
M = this.col2.x,
L = this.col1.y,
I = this.col2.y,
W = V * I - M * L;
if (W != 0) W = 1 / W;
p.x = W * (I * B - M * Q);
p.y = W * (V * Q - L * B);
return p
};
F.prototype.Abs = function () {
this.col1.Abs();
this.col2.Abs()
};
G.b2Mat33 = function () {
this.col1 = new U;
this.col2 = new U;
this.col3 = new U
};
G.prototype.b2Mat33 = function (p, B, Q) {
if (p === undefined) p = null;
if (B === undefined) B = null;
if (Q === undefined) Q = null;
if (!p && !B && !Q) {
this.col1.SetZero();
this.col2.SetZero();
this.col3.SetZero()
} else {
this.col1.SetV(p);
this.col2.SetV(B);
this.col3.SetV(Q)
}
};
G.prototype.SetVVV = function (p, B, Q) {
this.col1.SetV(p);
this.col2.SetV(B);
this.col3.SetV(Q)
};
G.prototype.Copy = function () {
return new G(this.col1, this.col2, this.col3)
};
G.prototype.SetM = function (p) {
this.col1.SetV(p.col1);
this.col2.SetV(p.col2);
this.col3.SetV(p.col3)
};
G.prototype.AddM = function (p) {
this.col1.x += p.col1.x;
this.col1.y += p.col1.y;
this.col1.z += p.col1.z;
this.col2.x += p.col2.x;
this.col2.y += p.col2.y;
this.col2.z += p.col2.z;
this.col3.x += p.col3.x;
this.col3.y += p.col3.y;
this.col3.z += p.col3.z
};
G.prototype.SetIdentity = function () {
this.col1.x = 1;
this.col2.x = 0;
this.col3.x = 0;
this.col1.y = 0;
this.col2.y = 1;
this.col3.y = 0;
this.col1.z = 0;
this.col2.z = 0;
this.col3.z = 1
};
G.prototype.SetZero = function () {
this.col1.x = 0;
this.col2.x = 0;
this.col3.x = 0;
this.col1.y = 0;
this.col2.y = 0;
this.col3.y = 0;
this.col1.z = 0;
this.col2.z = 0;
this.col3.z = 0
};
G.prototype.Solve22 = function (p, B, Q) {
if (B === undefined) B = 0;
if (Q === undefined) Q = 0;
var V = this.col1.x,
M = this.col2.x,
L = this.col1.y,
I = this.col2.y,
W = V * I - M * L;
if (W != 0) W = 1 / W;
p.x = W * (I * B - M * Q);
p.y = W * (V * Q - L * B);
return p
};
G.prototype.Solve33 = function (p, B, Q, V) {
if (B === undefined) B = 0;
if (Q === undefined) Q = 0;
if (V === undefined) V = 0;
var M = this.col1.x,
L = this.col1.y,
I = this.col1.z,
W = this.col2.x,
Y = this.col2.y,
k = this.col2.z,
z = this.col3.x,
u = this.col3.y,
D = this.col3.z,
H = M * (Y * D - k * u) + L * (k * z - W * D) + I * (W * u - Y * z);
if (H != 0) H = 1 / H;
p.x = H * (B * (Y * D - k * u) + Q * (k * z - W * D) + V * (W * u - Y * z));
p.y = H * (M * (Q * D - V * u) + L * (V * z - B * D) + I * (B * u - Q * z));
p.z = H * (M * (Y * V - k * Q) + L * (k * B - W * V) + I * (W * Q - Y * B));
return p
};
K.b2Math = function () {};
K.IsValid = function (p) {
if (p === undefined) p = 0;
return isFinite(p)
};
K.Dot = function (p, B) {
return p.x * B.x + p.y * B.y
};
K.CrossVV = function (p, B) {
return p.x * B.y - p.y * B.x
};
K.CrossVF = function (p, B) {
if (B === undefined) B = 0;
return new A(B * p.y, -B * p.x)
};
K.CrossFV = function (p, B) {
if (p === undefined) p = 0;
return new A(-p * B.y, p * B.x)
};
K.MulMV = function (p, B) {
return new A(p.col1.x * B.x + p.col2.x * B.y, p.col1.y * B.x + p.col2.y * B.y)
};
K.MulTMV = function (p, B) {
return new A(K.Dot(B, p.col1), K.Dot(B, p.col2))
};
K.MulX = function (p, B) {
var Q = K.MulMV(p.R, B);
Q.x += p.position.x;
Q.y += p.position.y;
return Q
};
K.MulXT = function (p, B) {
var Q = K.SubtractVV(B, p.position),
V = Q.x * p.R.col1.x + Q.y * p.R.col1.y;
Q.y = Q.x * p.R.col2.x + Q.y * p.R.col2.y;
Q.x = V;
return Q
};
K.AddVV = function (p, B) {
return new A(p.x + B.x, p.y + B.y)
};
K.SubtractVV = function (p, B) {
return new A(p.x - B.x, p.y - B.y)
};
K.Distance = function (p, B) {
var Q = p.x - B.x,
V = p.y - B.y;
return Math.sqrt(Q * Q + V * V)
};
K.DistanceSquared = function (p, B) {
var Q = p.x - B.x,
V = p.y - B.y;
return Q * Q + V * V
};
K.MulFV = function (p, B) {
if (p === undefined) p = 0;
return new A(p * B.x, p * B.y)
};
K.AddMM = function (p, B) {
return F.FromVV(K.AddVV(p.col1, B.col1), K.AddVV(p.col2, B.col2))
};
K.MulMM = function (p, B) {
return F.FromVV(K.MulMV(p,
B.col1), K.MulMV(p, B.col2))
};
K.MulTMM = function (p, B) {
var Q = new A(K.Dot(p.col1, B.col1), K.Dot(p.col2, B.col1)),
V = new A(K.Dot(p.col1, B.col2), K.Dot(p.col2, B.col2));
return F.FromVV(Q, V)
};
K.Abs = function (p) {
if (p === undefined) p = 0;
return p > 0 ? p : -p
};
K.AbsV = function (p) {
return new A(K.Abs(p.x), K.Abs(p.y))
};
K.AbsM = function (p) {
return F.FromVV(K.AbsV(p.col1), K.AbsV(p.col2))
};
K.Min = function (p, B) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
return p < B ? p : B
};
K.MinV = function (p, B) {
return new A(K.Min(p.x, B.x), K.Min(p.y, B.y))
};
K.Max = function (p, B) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
return p > B ? p : B
};
K.MaxV = function (p, B) {
return new A(K.Max(p.x, B.x), K.Max(p.y, B.y))
};
K.Clamp = function (p, B, Q) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
if (Q === undefined) Q = 0;
return p < B ? B : p > Q ? Q : p
};
K.ClampV = function (p, B, Q) {
return K.MaxV(B, K.MinV(p, Q))
};
K.Swap = function (p, B) {
var Q = p[0];
p[0] = B[0];
B[0] = Q
};
K.Random = function () {
return Math.random() * 2 - 1
};
K.RandomRange = function (p, B) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
var Q = Math.random();
return Q = (B - p) * Q + p
};
K.NextPowerOfTwo = function (p) {
if (p === undefined) p = 0;
p |= p >> 1 & 2147483647;
p |= p >> 2 & 1073741823;
p |= p >> 4 & 268435455;
p |= p >> 8 & 16777215;
p |= p >> 16 & 65535;
return p + 1
};
K.IsPowerOfTwo = function (p) {
if (p === undefined) p = 0;
return p > 0 && (p & p - 1) == 0
};
Box2D.postDefs.push(function () {
Box2D.Common.Math.b2Math.b2Vec2_zero = new A(0, 0);
Box2D.Common.Math.b2Math.b2Mat22_identity = F.FromVV(new A(1, 0), new A(0, 1));
Box2D.Common.Math.b2Math.b2Transform_identity = new w(K.b2Vec2_zero, K.b2Mat22_identity)
});
y.b2Sweep = function () {
this.localCenter = new A;
this.c0 = new A;
this.c = new A
};
y.prototype.Set = function (p) {
this.localCenter.SetV(p.localCenter);
this.c0.SetV(p.c0);
this.c.SetV(p.c);
this.a0 = p.a0;
this.a = p.a;
this.t0 = p.t0
};
y.prototype.Copy = function () {
var p = new y;
p.localCenter.SetV(this.localCenter);
p.c0.SetV(this.c0);
p.c.SetV(this.c);
p.a0 = this.a0;
p.a = this.a;
p.t0 = this.t0;
return p
};
y.prototype.GetTransform = function (p, B) {
if (B === undefined) B = 0;
p.position.x = (1 - B) * this.c0.x + B * this.c.x;
p.position.y = (1 - B) * this.c0.y + B * this.c.y;
p.R.Set((1 - B) * this.a0 + B * this.a);
var Q = p.R;
p.position.x -= Q.col1.x * this.localCenter.x + Q.col2.x * this.localCenter.y;
p.position.y -= Q.col1.y * this.localCenter.x + Q.col2.y * this.localCenter.y
};
y.prototype.Advance = function (p) {
if (p === undefined) p = 0;
if (this.t0 < p && 1 - this.t0 > Number.MIN_VALUE) {
var B = (p - this.t0) / (1 - this.t0);
this.c0.x = (1 - B) * this.c0.x + B * this.c.x;
this.c0.y = (1 - B) * this.c0.y + B * this.c.y;
this.a0 = (1 - B) * this.a0 + B * this.a;
this.t0 = p
}
};
w.b2Transform = function () {
this.position = new A;
this.R = new F
};
w.prototype.b2Transform = function (p, B) {
if (p === undefined) p = null;
if (B === undefined) B = null;
if (p) {
this.position.SetV(p);
this.R.SetM(B)
}
};
w.prototype.Initialize = function (p, B) {
this.position.SetV(p);
this.R.SetM(B)
};
w.prototype.SetIdentity = function () {
this.position.SetZero();
this.R.SetIdentity()
};
w.prototype.Set = function (p) {
this.position.SetV(p.position);
this.R.SetM(p.R)
};
w.prototype.GetAngle = function () {
return Math.atan2(this.R.col1.y, this.R.col1.x)
};
A.b2Vec2 = function () {};
A.prototype.b2Vec2 = function (p, B) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
this.x = p;
this.y = B
};
A.prototype.SetZero = function () {
this.y = this.x = 0
};
A.prototype.Set = function (p, B) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
this.x = p;
this.y = B
};
A.prototype.SetV = function (p) {
this.x = p.x;
this.y = p.y
};
A.prototype.GetNegative = function () {
return new A(-this.x, -this.y)
};
A.prototype.NegativeSelf = function () {
this.x = -this.x;
this.y = -this.y
};
A.Make = function (p, B) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
return new A(p, B)
};
A.prototype.Copy = function () {
return new A(this.x, this.y)
};
A.prototype.Add = function (p) {
this.x += p.x;
this.y += p.y
};
A.prototype.Subtract = function (p) {
this.x -= p.x;
this.y -= p.y
};
A.prototype.Multiply = function (p) {
if (p === undefined) p = 0;
this.x *= p;
this.y *= p
};
A.prototype.MulM = function (p) {
var B = this.x;
this.x = p.col1.x * B + p.col2.x * this.y;
this.y = p.col1.y * B + p.col2.y * this.y
};
A.prototype.MulTM = function (p) {
var B = K.Dot(this, p.col1);
this.y = K.Dot(this, p.col2);
this.x = B
};
A.prototype.CrossVF = function (p) {
if (p === undefined) p = 0;
var B = this.x;
this.x = p * this.y;
this.y = -p * B
};
A.prototype.CrossFV = function (p) {
if (p === undefined) p = 0;
var B = this.x;
this.x = -p * this.y;
this.y = p * B
};
A.prototype.MinV = function (p) {
this.x = this.x < p.x ? this.x : p.x;
this.y = this.y < p.y ? this.y : p.y
};
A.prototype.MaxV = function (p) {
this.x = this.x > p.x ? this.x : p.x;
this.y = this.y > p.y ? this.y : p.y
};
A.prototype.Abs = function () {
if (this.x < 0) this.x = -this.x;
if (this.y < 0) this.y = -this.y
};
A.prototype.Length = function () {
return Math.sqrt(this.x * this.x + this.y * this.y)
};
A.prototype.LengthSquared = function () {
return this.x * this.x + this.y * this.y
};
A.prototype.Normalize = function () {
var p = Math.sqrt(this.x * this.x + this.y * this.y);
if (p < Number.MIN_VALUE) return 0;
var B = 1 / p;
this.x *= B;
this.y *= B;
return p
};
A.prototype.IsValid = function () {
return K.IsValid(this.x) && K.IsValid(this.y)
};
U.b2Vec3 = function () {};
U.prototype.b2Vec3 = function (p, B, Q) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
if (Q === undefined) Q = 0;
this.x = p;
this.y = B;
this.z = Q
};
U.prototype.SetZero = function () {
this.x = this.y = this.z = 0
};
U.prototype.Set = function (p, B, Q) {
if (p === undefined) p = 0;
if (B === undefined) B = 0;
if (Q === undefined) Q = 0;
this.x = p;
this.y = B;
this.z = Q
};
U.prototype.SetV = function (p) {
this.x = p.x;
this.y = p.y;
this.z = p.z
};
U.prototype.GetNegative = function () {
return new U(-this.x, -this.y, -this.z)
};
U.prototype.NegativeSelf = function () {
this.x = -this.x;
this.y = -this.y;
this.z = -this.z
};
U.prototype.Copy = function () {
return new U(this.x, this.y, this.z)
};
U.prototype.Add = function (p) {
this.x += p.x;
this.y += p.y;
this.z += p.z
};
U.prototype.Subtract = function (p) {
this.x -= p.x;
this.y -= p.y;
this.z -= p.z
};
U.prototype.Multiply = function (p) {
if (p === undefined) p = 0;
this.x *= p;
this.y *= p;
this.z *= p
}
})();
(function () {
var F = Box2D.Common.Math.b2Math,
G = Box2D.Common.Math.b2Sweep,
K = Box2D.Common.Math.b2Transform,
y = Box2D.Common.Math.b2Vec2,
w = Box2D.Common.b2Color,
A = Box2D.Common.b2Settings,
U = Box2D.Collision.b2AABB,
p = Box2D.Collision.b2ContactPoint,
B = Box2D.Collision.b2DynamicTreeBroadPhase,
Q = Box2D.Collision.b2RayCastInput,
V = Box2D.Collision.b2RayCastOutput,
M = Box2D.Collision.Shapes.b2CircleShape,
L = Box2D.Collision.Shapes.b2EdgeShape,
I = Box2D.Collision.Shapes.b2MassData,
W = Box2D.Collision.Shapes.b2PolygonShape,
Y = Box2D.Collision.Shapes.b2Shape,
k = Box2D.Dynamics.b2Body,
z = Box2D.Dynamics.b2BodyDef,
u = Box2D.Dynamics.b2ContactFilter,
D = Box2D.Dynamics.b2ContactImpulse,
H = Box2D.Dynamics.b2ContactListener,
O = Box2D.Dynamics.b2ContactManager,
E = Box2D.Dynamics.b2DebugDraw,
R = Box2D.Dynamics.b2DestructionListener,
N = Box2D.Dynamics.b2FilterData,
S = Box2D.Dynamics.b2Fixture,
aa = Box2D.Dynamics.b2FixtureDef,
Z = Box2D.Dynamics.b2Island,
d = Box2D.Dynamics.b2TimeStep,
h = Box2D.Dynamics.b2World,
l = Box2D.Dynamics.Contacts.b2Contact,
j = Box2D.Dynamics.Contacts.b2ContactFactory,
o = Box2D.Dynamics.Contacts.b2ContactSolver,
q = Box2D.Dynamics.Joints.b2Joint,
n = Box2D.Dynamics.Joints.b2PulleyJoint;
k.b2Body = function () {
this.m_xf = new K;
this.m_sweep = new G;
this.m_linearVelocity = new y;
this.m_force = new y
};
k.prototype.connectEdges = function (a, c, g) {
if (g === undefined) g = 0;
var b = Math.atan2(c.GetDirectionVector().y, c.GetDirectionVector().x);
g = F.MulFV(Math.tan((b - g) * 0.5), c.GetDirectionVector());
g = F.SubtractVV(g, c.GetNormalVector());
g = F.MulFV(A.b2_toiSlop, g);
g = F.AddVV(g, c.GetVertex1());
var e = F.AddVV(a.GetDirectionVector(),
c.GetDirectionVector());
e.Normalize();
var f = F.Dot(a.GetDirectionVector(), c.GetNormalVector()) > 0;
a.SetNextEdge(c, g, e, f);
c.SetPrevEdge(a, g, e, f);
return b
};
k.prototype.CreateFixture = function (a) {
if (this.m_world.IsLocked() == true) return null;
var c = new S;
c.Create(this, this.m_xf, a);
this.m_flags & k.e_activeFlag && c.CreateProxy(this.m_world.m_contactManager.m_broadPhase, this.m_xf);
c.m_next = this.m_fixtureList;
this.m_fixtureList = c;
++this.m_fixtureCount;
c.m_body = this;
c.m_density > 0 && this.ResetMassData();
this.m_world.m_flags |= h.e_newFixture;
return c
};
k.prototype.CreateFixture2 = function (a, c) {
if (c === undefined) c = 0;
var g = new aa;
g.shape = a;
g.density = c;
return this.CreateFixture(g)
};
k.prototype.DestroyFixture = function (a) {
if (this.m_world.IsLocked() != true) {
for (var c = this.m_fixtureList, g = null; c != null;) {
if (c == a) {
if (g) g.m_next = a.m_next;
else this.m_fixtureList = a.m_next;
break
}
g = c;
c = c.m_next
}
for (c = this.m_contactList; c;) {
g = c.contact;
c = c.next;
var b = g.GetFixtureA(),
e = g.GetFixtureB();
if (a == b || a == e) this.m_world.m_contactManager.Destroy(g)
}
this.m_flags &
k.e_activeFlag && a.DestroyProxy(this.m_world.m_contactManager.m_broadPhase);
a.Destroy();
a.m_body = null;
a.m_next = null;
--this.m_fixtureCount;
this.ResetMassData()
}
};
k.prototype.SetPositionAndAngle = function (a, c) {
if (c === undefined) c = 0;
var g;
if (this.m_world.IsLocked() != true) {
this.m_xf.R.Set(c);
this.m_xf.position.SetV(a);
g = this.m_xf.R;
var b = this.m_sweep.localCenter;
this.m_sweep.c.x = g.col1.x * b.x + g.col2.x * b.y;
this.m_sweep.c.y = g.col1.y * b.x + g.col2.y * b.y;
this.m_sweep.c.x += this.m_xf.position.x;
this.m_sweep.c.y += this.m_xf.position.y;
this.m_sweep.c0.SetV(this.m_sweep.c);
this.m_sweep.a0 = this.m_sweep.a = c;
b = this.m_world.m_contactManager.m_broadPhase;
for (g = this.m_fixtureList; g; g = g.m_next) g.Synchronize(b, this.m_xf, this.m_xf);
this.m_world.m_contactManager.FindNewContacts()
}
};
k.prototype.SetTransform = function (a) {
this.SetPositionAndAngle(a.position, a.GetAngle())
};
k.prototype.GetTransform = function () {
return this.m_xf
};
k.prototype.GetPosition = function () {
return this.m_xf.position
};
k.prototype.SetPosition = function (a) {
this.SetPositionAndAngle(a,
this.GetAngle())
};
k.prototype.GetAngle = function () {
return this.m_sweep.a
};
k.prototype.SetAngle = function (a) {
if (a === undefined) a = 0;
this.SetPositionAndAngle(this.GetPosition(), a)
};
k.prototype.GetWorldCenter = function () {
return this.m_sweep.c
};
k.prototype.GetLocalCenter = function () {
return this.m_sweep.localCenter
};
k.prototype.SetLinearVelocity = function (a) {
this.m_type != k.b2_staticBody && this.m_linearVelocity.SetV(a)
};
k.prototype.GetLinearVelocity = function () {
return this.m_linearVelocity
};
k.prototype.SetAngularVelocity = function (a) {
if (a === undefined) a = 0;
if (this.m_type != k.b2_staticBody) this.m_angularVelocity = a
};
k.prototype.GetAngularVelocity = function () {
return this.m_angularVelocity
};
k.prototype.GetDefinition = function () {
var a = new z;
a.type = this.GetType();
a.allowSleep = (this.m_flags & k.e_allowSleepFlag) == k.e_allowSleepFlag;
a.angle = this.GetAngle();
a.angularDamping = this.m_angularDamping;
a.angularVelocity = this.m_angularVelocity;
a.fixedRotation = (this.m_flags & k.e_fixedRotationFlag) == k.e_fixedRotationFlag;
a.bullet = (this.m_flags &
k.e_bulletFlag) == k.e_bulletFlag;
a.awake = (this.m_flags & k.e_awakeFlag) == k.e_awakeFlag;
a.linearDamping = this.m_linearDamping;
a.linearVelocity.SetV(this.GetLinearVelocity());
a.position = this.GetPosition();
a.userData = this.GetUserData();
return a
};
k.prototype.ApplyForce = function (a, c) {
if (this.m_type == k.b2_dynamicBody) {
this.IsAwake() == false && this.SetAwake(true);
this.m_force.x += a.x;
this.m_force.y += a.y;
this.m_torque += (c.x - this.m_sweep.c.x) * a.y - (c.y - this.m_sweep.c.y) * a.x
}
};
k.prototype.ApplyTorque = function (a) {
if (a === undefined) a = 0;
if (this.m_type == k.b2_dynamicBody) {
this.IsAwake() == false && this.SetAwake(true);
this.m_torque += a
}
};
k.prototype.ApplyImpulse = function (a, c) {
if (this.m_type == k.b2_dynamicBody) {
this.IsAwake() == false && this.SetAwake(true);
this.m_linearVelocity.x += this.m_invMass * a.x;
this.m_linearVelocity.y += this.m_invMass * a.y;
this.m_angularVelocity += this.m_invI * ((c.x - this.m_sweep.c.x) * a.y - (c.y - this.m_sweep.c.y) * a.x)
}
};
k.prototype.Split = function (a) {
for (var c = this.GetLinearVelocity().Copy(), g = this.GetAngularVelocity(),
b = this.GetWorldCenter(), e = this.m_world.CreateBody(this.GetDefinition()), f, m = this.m_fixtureList; m;)
if (a(m)) {
var r = m.m_next;
if (f) f.m_next = r;
else this.m_fixtureList = r;
this.m_fixtureCount--;
m.m_next = e.m_fixtureList;
e.m_fixtureList = m;
e.m_fixtureCount++;
m.m_body = e;
m = r
} else {
f = m;
m = m.m_next
}
this.ResetMassData();
e.ResetMassData();
f = this.GetWorldCenter();
a = e.GetWorldCenter();
f = F.AddVV(c, F.CrossFV(g, F.SubtractVV(f, b)));
c = F.AddVV(c, F.CrossFV(g, F.SubtractVV(a, b)));
this.SetLinearVelocity(f);
e.SetLinearVelocity(c);
this.SetAngularVelocity(g);
e.SetAngularVelocity(g);
this.SynchronizeFixtures();
e.SynchronizeFixtures();
return e
};
k.prototype.Merge = function (a) {
var c;
for (c = a.m_fixtureList; c;) {
var g = c.m_next;
a.m_fixtureCount--;
c.m_next = this.m_fixtureList;
this.m_fixtureList = c;
this.m_fixtureCount++;
c.m_body = e;
c = g
}
b.m_fixtureCount = 0;
var b = this,
e = a;
b.GetWorldCenter();
e.GetWorldCenter();
b.GetLinearVelocity().Copy();
e.GetLinearVelocity().Copy();
b.GetAngularVelocity();
e.GetAngularVelocity();
b.ResetMassData();
this.SynchronizeFixtures()
};
k.prototype.GetMass = function () {
return this.m_mass
};
k.prototype.GetInertia = function () {
return this.m_I
};
k.prototype.GetMassData = function (a) {
a.mass = this.m_mass;
a.I = this.m_I;
a.center.SetV(this.m_sweep.localCenter)
};
k.prototype.SetMassData = function (a) {
A.b2Assert(this.m_world.IsLocked() == false);
if (this.m_world.IsLocked() != true)
if (this.m_type == k.b2_dynamicBody) {
this.m_invI = this.m_I = this.m_invMass = 0;
this.m_mass = a.mass;
if (this.m_mass <= 0) this.m_mass = 1;
this.m_invMass = 1 / this.m_mass;
if (a.I > 0 && (this.m_flags & k.e_fixedRotationFlag) == 0) {
this.m_I = a.I - this.m_mass * (a.center.x * a.center.x + a.center.y * a.center.y);
this.m_invI = 1 / this.m_I
}
var c = this.m_sweep.c.Copy();
this.m_sweep.localCenter.SetV(a.center);
this.m_sweep.c0.SetV(F.MulX(this.m_xf, this.m_sweep.localCenter));
this.m_sweep.c.SetV(this.m_sweep.c0);
this.m_linearVelocity.x += this.m_angularVelocity * -(this.m_sweep.c.y - c.y);
this.m_linearVelocity.y += this.m_angularVelocity * +(this.m_sweep.c.x - c.x)
}
};
k.prototype.ResetMassData = function () {
this.m_invI = this.m_I = this.m_invMass = this.m_mass = 0;
this.m_sweep.localCenter.SetZero();
if (!(this.m_type == k.b2_staticBody || this.m_type == k.b2_kinematicBody)) {
for (var a = y.Make(0, 0), c = this.m_fixtureList; c; c = c.m_next)
if (c.m_density != 0) {
var g = c.GetMassData();
this.m_mass += g.mass;
a.x += g.center.x * g.mass;
a.y += g.center.y * g.mass;
this.m_I += g.I
}
if (this.m_mass > 0) {
this.m_invMass = 1 / this.m_mass;
a.x *= this.m_invMass;
a.y *= this.m_invMass
} else this.m_invMass = this.m_mass = 1; if (this.m_I > 0 && (this.m_flags & k.e_fixedRotationFlag) == 0) {
this.m_I -= this.m_mass * (a.x * a.x + a.y * a.y);
this.m_I *= this.m_inertiaScale;
A.b2Assert(this.m_I > 0);
this.m_invI = 1 / this.m_I
} else this.m_invI = this.m_I = 0;
c = this.m_sweep.c.Copy();
this.m_sweep.localCenter.SetV(a);
this.m_sweep.c0.SetV(F.MulX(this.m_xf, this.m_sweep.localCenter));
this.m_sweep.c.SetV(this.m_sweep.c0);
this.m_linearVelocity.x += this.m_angularVelocity * -(this.m_sweep.c.y - c.y);
this.m_linearVelocity.y += this.m_angularVelocity * +(this.m_sweep.c.x - c.x)
}
};
k.prototype.GetWorldPoint = function (a) {
var c = this.m_xf.R;
a = new y(c.col1.x * a.x + c.col2.x * a.y, c.col1.y * a.x + c.col2.y * a.y);
a.x += this.m_xf.position.x;
a.y += this.m_xf.position.y;
return a
};
k.prototype.GetWorldVector = function (a) {
return F.MulMV(this.m_xf.R, a)
};
k.prototype.GetLocalPoint = function (a) {
return F.MulXT(this.m_xf, a)
};
k.prototype.GetLocalVector = function (a) {
return F.MulTMV(this.m_xf.R, a)
};
k.prototype.GetLinearVelocityFromWorldPoint = function (a) {
return new y(this.m_linearVelocity.x - this.m_angularVelocity * (a.y - this.m_sweep.c.y), this.m_linearVelocity.y + this.m_angularVelocity * (a.x - this.m_sweep.c.x))
};
k.prototype.GetLinearVelocityFromLocalPoint = function (a) {
var c = this.m_xf.R;
a = new y(c.col1.x * a.x + c.col2.x * a.y, c.col1.y * a.x + c.col2.y * a.y);
a.x += this.m_xf.position.x;
a.y += this.m_xf.position.y;
return new y(this.m_linearVelocity.x - this.m_angularVelocity * (a.y - this.m_sweep.c.y), this.m_linearVelocity.y + this.m_angularVelocity * (a.x - this.m_sweep.c.x))
};
k.prototype.GetLinearDamping = function () {
return this.m_linearDamping
};
k.prototype.SetLinearDamping = function (a) {
if (a === undefined) a = 0;
this.m_linearDamping = a
};
k.prototype.GetAngularDamping = function () {
return this.m_angularDamping
};
k.prototype.SetAngularDamping = function (a) {
if (a === undefined) a = 0;
this.m_angularDamping = a
};
k.prototype.SetType = function (a) {
if (a === undefined) a = 0;
if (this.m_type != a) {
this.m_type = a;
this.ResetMassData();
if (this.m_type == k.b2_staticBody) {
this.m_linearVelocity.SetZero();
this.m_angularVelocity = 0
}
this.SetAwake(true);
this.m_force.SetZero();
this.m_torque = 0;
for (a = this.m_contactList; a; a = a.next) a.contact.FlagForFiltering()
}
};
k.prototype.GetType = function () {
return this.m_type
};
k.prototype.SetBullet = function (a) {
if (a) this.m_flags |= k.e_bulletFlag;
else this.m_flags &= ~k.e_bulletFlag
};
k.prototype.IsBullet = function () {
return (this.m_flags & k.e_bulletFlag) == k.e_bulletFlag
};
k.prototype.SetSleepingAllowed = function (a) {
if (a) this.m_flags |= k.e_allowSleepFlag;
else {
this.m_flags &= ~k.e_allowSleepFlag;
this.SetAwake(true)
}
};
k.prototype.SetAwake = function (a) {
if (a) {
this.m_flags |= k.e_awakeFlag;
this.m_sleepTime = 0
} else {
this.m_flags &= ~k.e_awakeFlag;
this.m_sleepTime = 0;
this.m_linearVelocity.SetZero();
this.m_angularVelocity = 0;
this.m_force.SetZero();
this.m_torque = 0
}
};
k.prototype.IsAwake = function () {
return (this.m_flags & k.e_awakeFlag) == k.e_awakeFlag
};
k.prototype.SetFixedRotation = function (a) {
if (a) this.m_flags |= k.e_fixedRotationFlag;
else this.m_flags &= ~k.e_fixedRotationFlag;
this.ResetMassData()
};
k.prototype.IsFixedRotation = function () {
return (this.m_flags & k.e_fixedRotationFlag) == k.e_fixedRotationFlag
};
k.prototype.SetActive = function (a) {
if (a != this.IsActive()) {
var c;
if (a) {
this.m_flags |= k.e_activeFlag;
a = this.m_world.m_contactManager.m_broadPhase;
for (c = this.m_fixtureList; c; c = c.m_next) c.CreateProxy(a, this.m_xf)
} else {
this.m_flags &= ~k.e_activeFlag;
a = this.m_world.m_contactManager.m_broadPhase;
for (c = this.m_fixtureList; c; c = c.m_next) c.DestroyProxy(a);
for (a = this.m_contactList; a;) {
c = a;
a = a.next;
this.m_world.m_contactManager.Destroy(c.contact)
}
this.m_contactList = null
}
}
};
k.prototype.IsActive = function () {
return (this.m_flags & k.e_activeFlag) == k.e_activeFlag
};
k.prototype.IsSleepingAllowed = function () {
return (this.m_flags & k.e_allowSleepFlag) == k.e_allowSleepFlag
};
k.prototype.GetFixtureList = function () {
return this.m_fixtureList
};
k.prototype.GetJointList = function () {
return this.m_jointList
};
k.prototype.GetControllerList = function () {
return this.m_controllerList
};
k.prototype.GetContactList = function () {
return this.m_contactList
};
k.prototype.GetNext = function () {
return this.m_next
};
k.prototype.GetUserData = function () {
return this.m_userData
};
k.prototype.SetUserData = function (a) {
this.m_userData = a
};
k.prototype.GetWorld = function () {
return this.m_world
};
k.prototype.b2Body = function (a, c) {
this.m_flags = 0;
if (a.bullet) this.m_flags |= k.e_bulletFlag;
if (a.fixedRotation) this.m_flags |= k.e_fixedRotationFlag;
if (a.allowSleep) this.m_flags |= k.e_allowSleepFlag;
if (a.awake) this.m_flags |= k.e_awakeFlag;
if (a.active) this.m_flags |= k.e_activeFlag;
this.m_world = c;
this.m_xf.position.SetV(a.position);
this.m_xf.R.Set(a.angle);
this.m_sweep.localCenter.SetZero();
this.m_sweep.t0 = 1;
this.m_sweep.a0 = this.m_sweep.a = a.angle;
var g = this.m_xf.R,
b = this.m_sweep.localCenter;
this.m_sweep.c.x = g.col1.x * b.x + g.col2.x * b.y;
this.m_sweep.c.y = g.col1.y * b.x + g.col2.y * b.y;
this.m_sweep.c.x += this.m_xf.position.x;
this.m_sweep.c.y += this.m_xf.position.y;
this.m_sweep.c0.SetV(this.m_sweep.c);
this.m_contactList = this.m_controllerList = this.m_jointList = null;
this.m_controllerCount = 0;
this.m_next = this.m_prev = null;
this.m_linearVelocity.SetV(a.linearVelocity);
this.m_angularVelocity = a.angularVelocity;
this.m_linearDamping = a.linearDamping;
this.m_angularDamping = a.angularDamping;
this.m_force.Set(0, 0);
this.m_sleepTime = this.m_torque = 0;
this.m_type = a.type;
if (this.m_type == k.b2_dynamicBody) this.m_invMass = this.m_mass = 1;
else this.m_invMass = this.m_mass = 0;
this.m_invI = this.m_I = 0;
this.m_inertiaScale = a.inertiaScale;
this.m_userData = a.userData;
this.m_fixtureList = null;
this.m_fixtureCount = 0
};
k.prototype.SynchronizeFixtures = function () {
var a = k.s_xf1;
a.R.Set(this.m_sweep.a0);
var c = a.R,
g = this.m_sweep.localCenter;
a.position.x = this.m_sweep.c0.x - (c.col1.x * g.x + c.col2.x * g.y);
a.position.y = this.m_sweep.c0.y - (c.col1.y * g.x + c.col2.y * g.y);
g = this.m_world.m_contactManager.m_broadPhase;
for (c = this.m_fixtureList; c; c = c.m_next) c.Synchronize(g, a, this.m_xf)
};
k.prototype.SynchronizeTransform = function () {
this.m_xf.R.Set(this.m_sweep.a);
var a = this.m_xf.R,
c = this.m_sweep.localCenter;
this.m_xf.position.x = this.m_sweep.c.x - (a.col1.x * c.x + a.col2.x * c.y);
this.m_xf.position.y = this.m_sweep.c.y - (a.col1.y * c.x + a.col2.y * c.y)
};
k.prototype.ShouldCollide = function (a) {
if (this.m_type != k.b2_dynamicBody && a.m_type != k.b2_dynamicBody) return false;
for (var c = this.m_jointList; c; c = c.next)
if (c.other == a)
if (c.joint.m_collideConnected == false) return false;
return true
};
k.prototype.Advance = function (a) {
if (a === undefined) a = 0;
this.m_sweep.Advance(a);
this.m_sweep.c.SetV(this.m_sweep.c0);
this.m_sweep.a = this.m_sweep.a0;
this.SynchronizeTransform()
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.b2Body.s_xf1 = new K;
Box2D.Dynamics.b2Body.e_islandFlag = 1;
Box2D.Dynamics.b2Body.e_awakeFlag = 2;
Box2D.Dynamics.b2Body.e_allowSleepFlag = 4;
Box2D.Dynamics.b2Body.e_bulletFlag = 8;
Box2D.Dynamics.b2Body.e_fixedRotationFlag = 16;
Box2D.Dynamics.b2Body.e_activeFlag = 32;
Box2D.Dynamics.b2Body.b2_staticBody = 0;
Box2D.Dynamics.b2Body.b2_kinematicBody = 1;
Box2D.Dynamics.b2Body.b2_dynamicBody = 2
});
z.b2BodyDef = function () {
this.position = new y;
this.linearVelocity = new y
};
z.prototype.b2BodyDef = function () {
this.userData = null;
this.position.Set(0, 0);
this.angle = 0;
this.linearVelocity.Set(0, 0);
this.angularDamping = this.linearDamping = this.angularVelocity = 0;
this.awake = this.allowSleep = true;
this.bullet = this.fixedRotation = false;
this.type = k.b2_staticBody;
this.active = true;
this.inertiaScale = 1
};
u.b2ContactFilter = function () {};
u.prototype.ShouldCollide = function (a, c) {
var g = a.GetFilterData(),
b = c.GetFilterData();
if (g.groupIndex == b.groupIndex && g.groupIndex != 0) return g.groupIndex > 0;
return (g.maskBits & b.categoryBits) != 0 && (g.categoryBits & b.maskBits) != 0
};
u.prototype.RayCollide = function (a, c) {
if (!a) return true;
return this.ShouldCollide(a instanceof S ? a : null, c)
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.b2ContactFilter.b2_defaultFilter = new u
});
D.b2ContactImpulse = function () {
this.normalImpulses = new Vector_a2j_Number(A.b2_maxManifoldPoints);
this.tangentImpulses = new Vector_a2j_Number(A.b2_maxManifoldPoints)
};
H.b2ContactListener = function () {};
H.prototype.BeginContact = function () {};
H.prototype.EndContact = function () {};
H.prototype.PreSolve = function () {};
H.prototype.PostSolve = function () {};
Box2D.postDefs.push(function () {
Box2D.Dynamics.b2ContactListener.b2_defaultListener = new H
});
O.b2ContactManager = function () {};
O.prototype.b2ContactManager = function () {
this.m_world = null;
this.m_contactCount = 0;
this.m_contactFilter = u.b2_defaultFilter;
this.m_contactListener = H.b2_defaultListener;
this.m_contactFactory = new j(this.m_allocator);
this.m_broadPhase = new B
};
O.prototype.AddPair = function (a, c) {
var g = a instanceof S ? a : null,
b = c instanceof S ? c : null,
e = g.GetBody(),
f = b.GetBody();
if (e != f) {
for (var m = f.GetContactList(); m;) {
if (m.other == e) {
var r = m.contact.GetFixtureA(),
s = m.contact.GetFixtureB();
if (r == g && s == b) return;
if (r == b && s == g) return
}
m = m.next
}
if (f.ShouldCollide(e) != false)
if (this.m_contactFilter.ShouldCollide(g, b) != false) {
m = this.m_contactFactory.Create(g, b);
g = m.GetFixtureA();
b = m.GetFixtureB();
e = g.m_body;
f = b.m_body;
m.m_prev = null;
m.m_next = this.m_world.m_contactList;
if (this.m_world.m_contactList != null) this.m_world.m_contactList.m_prev = m;
this.m_world.m_contactList = m;
m.m_nodeA.contact = m;
m.m_nodeA.other = f;
m.m_nodeA.prev = null;
m.m_nodeA.next = e.m_contactList;
if (e.m_contactList != null) e.m_contactList.prev = m.m_nodeA;
e.m_contactList = m.m_nodeA;
m.m_nodeB.contact = m;
m.m_nodeB.other = e;
m.m_nodeB.prev = null;
m.m_nodeB.next = f.m_contactList;
if (f.m_contactList != null) f.m_contactList.prev = m.m_nodeB;
f.m_contactList = m.m_nodeB;
++this.m_world.m_contactCount
}
}
};
O.prototype.FindNewContacts = function () {
this.m_broadPhase.UpdatePairs(Box2D.generateCallback(this, this.AddPair))
};
O.prototype.Destroy = function (a) {
var c = a.GetFixtureA(),
g = a.GetFixtureB();
c = c.GetBody();
g = g.GetBody();
a.IsTouching() && this.m_contactListener.EndContact(a);
if (a.m_prev) a.m_prev.m_next = a.m_next;
if (a.m_next) a.m_next.m_prev = a.m_prev;
if (a == this.m_world.m_contactList) this.m_world.m_contactList = a.m_next;
if (a.m_nodeA.prev) a.m_nodeA.prev.next = a.m_nodeA.next;
if (a.m_nodeA.next) a.m_nodeA.next.prev = a.m_nodeA.prev;
if (a.m_nodeA == c.m_contactList) c.m_contactList = a.m_nodeA.next;
if (a.m_nodeB.prev) a.m_nodeB.prev.next = a.m_nodeB.next;
if (a.m_nodeB.next) a.m_nodeB.next.prev = a.m_nodeB.prev;
if (a.m_nodeB == g.m_contactList) g.m_contactList = a.m_nodeB.next;
this.m_contactFactory.Destroy(a);
--this.m_contactCount
};
O.prototype.Collide = function () {
for (var a = this.m_world.m_contactList; a;) {
var c = a.GetFixtureA(),
g = a.GetFixtureB(),
b = c.GetBody(),
e = g.GetBody();
if (b.IsAwake() == false && e.IsAwake() == false) a = a.GetNext();
else {
if (a.m_flags & l.e_filterFlag) {
if (e.ShouldCollide(b) == false) {
c = a;
a = c.GetNext();
this.Destroy(c);
continue
}
if (this.m_contactFilter.ShouldCollide(c, g) == false) {
c = a;
a = c.GetNext();
this.Destroy(c);
continue
}
a.m_flags &= ~l.e_filterFlag
}
if (this.m_broadPhase.TestOverlap(c.m_proxy, g.m_proxy) == false) {
c = a;
a = c.GetNext();
this.Destroy(c)
} else {
a.Update(this.m_contactListener);
a = a.GetNext()
}
}
}
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.b2ContactManager.s_evalCP = new p
});
E.b2DebugDraw = function () {};
E.prototype.b2DebugDraw = function () {};
E.prototype.SetFlags = function () {};
E.prototype.GetFlags = function () {};
E.prototype.AppendFlags = function () {};
E.prototype.ClearFlags = function () {};
E.prototype.SetSprite = function () {};
E.prototype.GetSprite = function () {};
E.prototype.SetDrawScale = function () {};
E.prototype.GetDrawScale = function () {};
E.prototype.SetLineThickness = function () {};
E.prototype.GetLineThickness = function () {};
E.prototype.SetAlpha = function () {};
E.prototype.GetAlpha = function () {};
E.prototype.SetFillAlpha = function () {};
E.prototype.GetFillAlpha = function () {};
E.prototype.SetXFormScale = function () {};
E.prototype.GetXFormScale = function () {};
E.prototype.DrawPolygon = function () {};
E.prototype.DrawSolidPolygon = function () {};
E.prototype.DrawCircle = function () {};
E.prototype.DrawSolidCircle = function () {};
E.prototype.DrawSegment = function () {};
E.prototype.DrawTransform = function () {};
Box2D.postDefs.push(function () {
Box2D.Dynamics.b2DebugDraw.e_shapeBit = 1;
Box2D.Dynamics.b2DebugDraw.e_jointBit = 2;
Box2D.Dynamics.b2DebugDraw.e_aabbBit = 4;
Box2D.Dynamics.b2DebugDraw.e_pairBit = 8;
Box2D.Dynamics.b2DebugDraw.e_centerOfMassBit = 16;
Box2D.Dynamics.b2DebugDraw.e_controllerBit = 32
});
R.b2DestructionListener = function () {};
R.prototype.SayGoodbyeJoint = function () {};
R.prototype.SayGoodbyeFixture = function () {};
N.b2FilterData = function () {
this.categoryBits = 1;
this.maskBits = 65535;
this.groupIndex = 0
};
N.prototype.Copy = function () {
var a = new N;
a.categoryBits = this.categoryBits;
a.maskBits = this.maskBits;
a.groupIndex = this.groupIndex;
return a
};
S.b2Fixture = function () {
this.m_filter = new N
};
S.prototype.GetType = function () {
return this.m_shape.GetType()
};
S.prototype.GetShape = function () {
return this.m_shape
};
S.prototype.SetSensor = function (a) {
if (this.m_isSensor != a) {
this.m_isSensor = a;
if (this.m_body != null) for (a = this.m_body.GetContactList(); a;) {
var c = a.contact,
g = c.GetFixtureA(),
b = c.GetFixtureB();
if (g == this || b == this) c.SetSensor(g.IsSensor() || b.IsSensor());
a = a.next
}
}
};
S.prototype.IsSensor = function () {
return this.m_isSensor
};
S.prototype.SetFilterData = function (a) {
this.m_filter = a.Copy();
if (!this.m_body) for (a = this.m_body.GetContactList(); a;) {
var c = a.contact,
g = c.GetFixtureA(),
b = c.GetFixtureB();
if (g == this || b == this) c.FlagForFiltering();
a = a.next
}
};
S.prototype.GetFilterData = function () {
return this.m_filter.Copy()
};
S.prototype.GetBody = function () {
return this.m_body
};
S.prototype.GetNext = function () {
return this.m_next
};
S.prototype.GetUserData = function () {
return this.m_userData
};
S.prototype.SetUserData = function (a) {
this.m_userData = a
};
S.prototype.TestPoint = function (a) {
return this.m_shape.TestPoint(this.m_body.GetTransform(),
a)
};
S.prototype.RayCast = function (a, c) {
return this.m_shape.RayCast(a, c, this.m_body.GetTransform())
};
S.prototype.GetMassData = function (a) {
if (a === undefined) a = null;
if (a == null) a = new I;
this.m_shape.ComputeMass(a, this.m_density);
return a
};
S.prototype.SetDensity = function (a) {
if (a === undefined) a = 0;
this.m_density = a
};
S.prototype.GetDensity = function () {
return this.m_density
};
S.prototype.GetFriction = function () {
return this.m_friction
};
S.prototype.SetFriction = function (a) {
if (a === undefined) a = 0;
this.m_friction = a
};
S.prototype.GetRestitution = function () {
return this.m_restitution
};
S.prototype.SetRestitution = function (a) {
if (a === undefined) a = 0;
this.m_restitution = a
};
S.prototype.GetAABB = function () {
return this.m_aabb
};
S.prototype.b2Fixture = function () {
this.m_aabb = new U;
this.m_shape = this.m_next = this.m_body = this.m_userData = null;
this.m_restitution = this.m_friction = this.m_density = 0
};
S.prototype.Create = function (a, c, g) {
this.m_userData = g.userData;
this.m_friction = g.friction;
this.m_restitution = g.restitution;
this.m_body = a;
this.m_next = null;
this.m_filter = g.filter.Copy();
this.m_isSensor = g.isSensor;
this.m_shape = g.shape.Copy();
this.m_density = g.density
};
S.prototype.Destroy = function () {
this.m_shape = null
};
S.prototype.CreateProxy = function (a, c) {
this.m_shape.ComputeAABB(this.m_aabb, c);
this.m_proxy = a.CreateProxy(this.m_aabb, this)
};
S.prototype.DestroyProxy = function (a) {
if (this.m_proxy != null) {
a.DestroyProxy(this.m_proxy);
this.m_proxy = null
}
};
S.prototype.Synchronize = function (a, c, g) {
if (this.m_proxy) {
var b = new U,
e = new U;
this.m_shape.ComputeAABB(b, c);
this.m_shape.ComputeAABB(e, g);
this.m_aabb.Combine(b, e);
c = F.SubtractVV(g.position, c.position);
a.MoveProxy(this.m_proxy, this.m_aabb, c)
}
};
aa.b2FixtureDef = function () {
this.filter = new N
};
aa.prototype.b2FixtureDef = function () {
this.userData = this.shape = null;
this.friction = 0.2;
this.density = this.restitution = 0;
this.filter.categoryBits = 1;
this.filter.maskBits = 65535;
this.filter.groupIndex = 0;
this.isSensor = false
};
Z.b2Island = function () {};
Z.prototype.b2Island = function () {
this.m_bodies = new Vector;
this.m_contacts = new Vector;
this.m_joints = new Vector
};
Z.prototype.Initialize = function (a, c, g, b, e, f) {
if (a === undefined) a = 0;
if (c === undefined) c = 0;
if (g === undefined) g = 0;
var m = 0;
this.m_bodyCapacity = a;
this.m_contactCapacity = c;
this.m_jointCapacity = g;
this.m_jointCount = this.m_contactCount = this.m_bodyCount = 0;
this.m_allocator = b;
this.m_listener = e;
this.m_contactSolver = f;
for (m = this.m_bodies.length; m < a; m++) this.m_bodies[m] = null;
for (m = this.m_contacts.length; m < c; m++) this.m_contacts[m] = null;
for (m = this.m_joints.length; m < g; m++) this.m_joints[m] = null
};
Z.prototype.Clear = function () {
this.m_jointCount = this.m_contactCount = this.m_bodyCount = 0
};
Z.prototype.Solve = function (a, c, g) {
var b = 0,
e = 0,
f;
for (b = 0; b < this.m_bodyCount; ++b) {
e = this.m_bodies[b];
if (e.GetType() == k.b2_dynamicBody) {
e.m_linearVelocity.x += a.dt * (c.x + e.m_invMass * e.m_force.x);
e.m_linearVelocity.y += a.dt * (c.y + e.m_invMass * e.m_force.y);
e.m_angularVelocity += a.dt * e.m_invI * e.m_torque;
e.m_linearVelocity.Multiply(F.Clamp(1 - a.dt * e.m_linearDamping, 0, 1));
e.m_angularVelocity *= F.Clamp(1 - a.dt * e.m_angularDamping, 0, 1)
}
}
this.m_contactSolver.Initialize(a, this.m_contacts,
this.m_contactCount, this.m_allocator);
c = this.m_contactSolver;
c.InitVelocityConstraints(a);
for (b = 0; b < this.m_jointCount; ++b) {
f = this.m_joints[b];
f.InitVelocityConstraints(a)
}
for (b = 0; b < a.velocityIterations; ++b) {
for (e = 0; e < this.m_jointCount; ++e) {
f = this.m_joints[e];
f.SolveVelocityConstraints(a)
}
c.SolveVelocityConstraints()
}
for (b = 0; b < this.m_jointCount; ++b) {
f = this.m_joints[b];
f.FinalizeVelocityConstraints()
}
c.FinalizeVelocityConstraints();
for (b = 0; b < this.m_bodyCount; ++b) {
e = this.m_bodies[b];
if (e.GetType() != k.b2_staticBody) {
var m = a.dt * e.m_linearVelocity.x,
r = a.dt * e.m_linearVelocity.y;
if (m * m + r * r > A.b2_maxTranslationSquared) {
e.m_linearVelocity.Normalize();
e.m_linearVelocity.x *= A.b2_maxTranslation * a.inv_dt;
e.m_linearVelocity.y *= A.b2_maxTranslation * a.inv_dt
}
m = a.dt * e.m_angularVelocity;
if (m * m > A.b2_maxRotationSquared) e.m_angularVelocity = e.m_angularVelocity < 0 ? -A.b2_maxRotation * a.inv_dt : A.b2_maxRotation * a.inv_dt;
e.m_sweep.c0.SetV(e.m_sweep.c);
e.m_sweep.a0 = e.m_sweep.a;
e.m_sweep.c.x += a.dt * e.m_linearVelocity.x;
e.m_sweep.c.y += a.dt * e.m_linearVelocity.y;
e.m_sweep.a += a.dt * e.m_angularVelocity;
e.SynchronizeTransform()
}
}
for (b = 0; b < a.positionIterations; ++b) {
m = c.SolvePositionConstraints(A.b2_contactBaumgarte);
r = true;
for (e = 0; e < this.m_jointCount; ++e) {
f = this.m_joints[e];
f = f.SolvePositionConstraints(A.b2_contactBaumgarte);
r = r && f
}
if (m && r) break
}
this.Report(c.m_constraints);
if (g) {
g = Number.MAX_VALUE;
c = A.b2_linearSleepTolerance * A.b2_linearSleepTolerance;
m = A.b2_angularSleepTolerance * A.b2_angularSleepTolerance;
for (b = 0; b < this.m_bodyCount; ++b) {
e = this.m_bodies[b];
if (e.GetType() != k.b2_staticBody) {
if ((e.m_flags & k.e_allowSleepFlag) == 0) g = e.m_sleepTime = 0;
if ((e.m_flags & k.e_allowSleepFlag) == 0 || e.m_angularVelocity * e.m_angularVelocity > m || F.Dot(e.m_linearVelocity, e.m_linearVelocity) > c) g = e.m_sleepTime = 0;
else {
e.m_sleepTime += a.dt;
g = F.Min(g, e.m_sleepTime)
}
}
}
if (g >= A.b2_timeToSleep)
for (b = 0; b < this.m_bodyCount; ++b) {
e = this.m_bodies[b];
e.SetAwake(false)
}
}
};
Z.prototype.SolveTOI = function (a) {
var c = 0,
g = 0;
this.m_contactSolver.Initialize(a, this.m_contacts, this.m_contactCount,
this.m_allocator);
var b = this.m_contactSolver;
for (c = 0; c < this.m_jointCount; ++c) this.m_joints[c].InitVelocityConstraints(a);
for (c = 0; c < a.velocityIterations; ++c) {
b.SolveVelocityConstraints();
for (g = 0; g < this.m_jointCount; ++g) this.m_joints[g].SolveVelocityConstraints(a)
}
for (c = 0; c < this.m_bodyCount; ++c) {
g = this.m_bodies[c];
if (g.GetType() != k.b2_staticBody) {
var e = a.dt * g.m_linearVelocity.x,
f = a.dt * g.m_linearVelocity.y;
if (e * e + f * f > A.b2_maxTranslationSquared) {
g.m_linearVelocity.Normalize();
g.m_linearVelocity.x *= A.b2_maxTranslation * a.inv_dt;
g.m_linearVelocity.y *= A.b2_maxTranslation * a.inv_dt
}
e = a.dt * g.m_angularVelocity;
if (e * e > A.b2_maxRotationSquared) g.m_angularVelocity = g.m_angularVelocity < 0 ? -A.b2_maxRotation * a.inv_dt : A.b2_maxRotation * a.inv_dt;
g.m_sweep.c0.SetV(g.m_sweep.c);
g.m_sweep.a0 = g.m_sweep.a;
g.m_sweep.c.x += a.dt * g.m_linearVelocity.x;
g.m_sweep.c.y += a.dt * g.m_linearVelocity.y;
g.m_sweep.a += a.dt * g.m_angularVelocity;
g.SynchronizeTransform()
}
}
for (c = 0; c < a.positionIterations; ++c) {
e = b.SolvePositionConstraints(0.75);
f = true;
for (g = 0; g <
this.m_jointCount; ++g) {
var m = this.m_joints[g].SolvePositionConstraints(A.b2_contactBaumgarte);
f = f && m
}
if (e && f) break
}
this.Report(b.m_constraints)
};
Z.prototype.Report = function (a) {
if (this.m_listener != null)
for (var c = 0; c < this.m_contactCount; ++c) {
for (var g = this.m_contacts[c], b = a[c], e = 0; e < b.pointCount; ++e) {
Z.s_impulse.normalImpulses[e] = b.points[e].normalImpulse;
Z.s_impulse.tangentImpulses[e] = b.points[e].tangentImpulse
}
this.m_listener.PostSolve(g, Z.s_impulse)
}
};
Z.prototype.AddBody = function (a) {
a.m_islandIndex = this.m_bodyCount;
this.m_bodies[this.m_bodyCount++] = a
};
Z.prototype.AddContact = function (a) {
this.m_contacts[this.m_contactCount++] = a
};
Z.prototype.AddJoint = function (a) {
this.m_joints[this.m_jointCount++] = a
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.b2Island.s_impulse = new D
});
d.b2TimeStep = function () {};
d.prototype.Set = function (a) {
this.dt = a.dt;
this.inv_dt = a.inv_dt;
this.positionIterations = a.positionIterations;
this.velocityIterations = a.velocityIterations;
this.warmStarting = a.warmStarting
};
h.b2World = function () {
this.s_stack = new Vector;
this.m_contactManager = new O;
this.m_contactSolver = new o;
this.m_island = new Z
};
h.prototype.b2World = function (a, c) {
this.m_controllerList = this.m_jointList = this.m_contactList = this.m_bodyList = this.m_debugDraw = this.m_destructionListener = null;
this.m_controllerCount = this.m_jointCount = this.m_contactCount = this.m_bodyCount = 0;
h.m_warmStarting = true;
h.m_continuousPhysics = true;
this.m_allowSleep = c;
this.m_gravity = a;
this.m_inv_dt0 = 0;
this.m_contactManager.m_world = this;
this.m_groundBody = this.CreateBody(new z)
};
h.prototype.SetDestructionListener = function (a) {
this.m_destructionListener = a
};
h.prototype.SetContactFilter = function (a) {
this.m_contactManager.m_contactFilter = a
};
h.prototype.SetContactListener = function (a) {
this.m_contactManager.m_contactListener = a
};
h.prototype.SetDebugDraw = function (a) {
this.m_debugDraw = a
};
h.prototype.SetBroadPhase = function (a) {
var c = this.m_contactManager.m_broadPhase;
this.m_contactManager.m_broadPhase = a;
for (var g = this.m_bodyList; g; g = g.m_next)
for (var b = g.m_fixtureList; b; b = b.m_next) b.m_proxy = a.CreateProxy(c.GetFatAABB(b.m_proxy), b)
};
h.prototype.Validate = function () {
this.m_contactManager.m_broadPhase.Validate()
};
h.prototype.GetProxyCount = function () {
return this.m_contactManager.m_broadPhase.GetProxyCount()
};
h.prototype.CreateBody = function (a) {
if (this.IsLocked() == true) return null;
a = new k(a, this);
a.m_prev = null;
if (a.m_next = this.m_bodyList) this.m_bodyList.m_prev = a;
this.m_bodyList = a;
++this.m_bodyCount;
return a
};
h.prototype.DestroyBody = function (a) {
if (this.IsLocked() != true) {
for (var c = a.m_jointList; c;) {
var g = c;
c = c.next;
this.m_destructionListener && this.m_destructionListener.SayGoodbyeJoint(g.joint);
this.DestroyJoint(g.joint)
}
for (c = a.m_controllerList; c;) {
g = c;
c = c.nextController;
g.controller.RemoveBody(a)
}
for (c = a.m_contactList; c;) {
g = c;
c = c.next;
this.m_contactManager.Destroy(g.contact)
}
a.m_contactList = null;
for (c = a.m_fixtureList; c;) {
g = c;
c = c.m_next;
this.m_destructionListener && this.m_destructionListener.SayGoodbyeFixture(g);
g.DestroyProxy(this.m_contactManager.m_broadPhase);
g.Destroy()
}
a.m_fixtureList = null;
a.m_fixtureCount = 0;
if (a.m_prev) a.m_prev.m_next = a.m_next;
if (a.m_next) a.m_next.m_prev = a.m_prev;
if (a == this.m_bodyList) this.m_bodyList = a.m_next;
--this.m_bodyCount
}
};
h.prototype.CreateJoint = function (a) {
var c = q.Create(a, null);
c.m_prev = null;
if (c.m_next = this.m_jointList) this.m_jointList.m_prev = c;
this.m_jointList = c;
++this.m_jointCount;
c.m_edgeA.joint = c;
c.m_edgeA.other = c.m_bodyB;
c.m_edgeA.prev = null;
if (c.m_edgeA.next = c.m_bodyA.m_jointList) c.m_bodyA.m_jointList.prev = c.m_edgeA;
c.m_bodyA.m_jointList = c.m_edgeA;
c.m_edgeB.joint = c;
c.m_edgeB.other = c.m_bodyA;
c.m_edgeB.prev = null;
if (c.m_edgeB.next = c.m_bodyB.m_jointList) c.m_bodyB.m_jointList.prev = c.m_edgeB;
c.m_bodyB.m_jointList = c.m_edgeB;
var g = a.bodyA,
b = a.bodyB;
if (a.collideConnected == false)
for (a = b.GetContactList(); a;) {
a.other == g && a.contact.FlagForFiltering();
a = a.next
}
return c
};
h.prototype.DestroyJoint = function (a) {
var c = a.m_collideConnected;
if (a.m_prev) a.m_prev.m_next = a.m_next;
if (a.m_next) a.m_next.m_prev = a.m_prev;
if (a == this.m_jointList) this.m_jointList = a.m_next;
var g = a.m_bodyA,
b = a.m_bodyB;
g.SetAwake(true);
b.SetAwake(true);
if (a.m_edgeA.prev) a.m_edgeA.prev.next = a.m_edgeA.next;
if (a.m_edgeA.next) a.m_edgeA.next.prev = a.m_edgeA.prev;
if (a.m_edgeA == g.m_jointList) g.m_jointList = a.m_edgeA.next;
a.m_edgeA.prev = null;
a.m_edgeA.next = null;
if (a.m_edgeB.prev) a.m_edgeB.prev.next = a.m_edgeB.next;
if (a.m_edgeB.next) a.m_edgeB.next.prev = a.m_edgeB.prev;
if (a.m_edgeB == b.m_jointList) b.m_jointList = a.m_edgeB.next;
a.m_edgeB.prev = null;
a.m_edgeB.next = null;
q.Destroy(a, null);
--this.m_jointCount;
if (c == false)
for (a = b.GetContactList(); a;) {
a.other == g && a.contact.FlagForFiltering();
a = a.next
}
};
h.prototype.AddController = function (a) {
a.m_next = this.m_controllerList;
a.m_prev = null;
this.m_controllerList = a;
a.m_world = this;
this.m_controllerCount++;
return a
};
h.prototype.RemoveController = function (a) {
if (a.m_prev) a.m_prev.m_next = a.m_next;
if (a.m_next) a.m_next.m_prev = a.m_prev;
if (this.m_controllerList == a) this.m_controllerList = a.m_next;
this.m_controllerCount--
};
h.prototype.CreateController = function (a) {
if (a.m_world != this) throw Error("Controller can only be a member of one world");
a.m_next = this.m_controllerList;
a.m_prev = null;
if (this.m_controllerList) this.m_controllerList.m_prev = a;
this.m_controllerList = a;
++this.m_controllerCount;
a.m_world = this;
return a
};
h.prototype.DestroyController = function (a) {
a.Clear();
if (a.m_next) a.m_next.m_prev = a.m_prev;
if (a.m_prev) a.m_prev.m_next = a.m_next;
if (a == this.m_controllerList) this.m_controllerList = a.m_next;
--this.m_controllerCount
};
h.prototype.SetWarmStarting = function (a) {
h.m_warmStarting = a
};
h.prototype.SetContinuousPhysics = function (a) {
h.m_continuousPhysics = a
};
h.prototype.GetBodyCount = function () {
return this.m_bodyCount
};
h.prototype.GetJointCount = function () {
return this.m_jointCount
};
h.prototype.GetContactCount = function () {
return this.m_contactCount
};
h.prototype.SetGravity = function (a) {
this.m_gravity = a
};
h.prototype.GetGravity = function () {
return this.m_gravity
};
h.prototype.GetGroundBody = function () {
return this.m_groundBody
};
h.prototype.Step = function (a, c, g) {
if (a === undefined) a = 0;
if (c === undefined) c = 0;
if (g === undefined) g = 0;
if (this.m_flags & h.e_newFixture) {
this.m_contactManager.FindNewContacts();
this.m_flags &= ~h.e_newFixture
}
this.m_flags |= h.e_locked;
var b = h.s_timestep2;
b.dt = a;
b.velocityIterations = c;
b.positionIterations = g;
b.inv_dt = a > 0 ? 1 / a : 0;
b.dtRatio = this.m_inv_dt0 * a;
b.warmStarting = h.m_warmStarting;
this.m_contactManager.Collide();
b.dt > 0 && this.Solve(b);
h.m_continuousPhysics && b.dt > 0 && this.SolveTOI(b);
if (b.dt > 0) this.m_inv_dt0 = b.inv_dt;
this.m_flags &= ~h.e_locked
};
h.prototype.ClearForces = function () {
for (var a = this.m_bodyList; a; a = a.m_next) {
a.m_force.SetZero();
a.m_torque = 0
}
};
h.prototype.DrawDebugData = function () {
if (this.m_debugDraw != null) {
this.m_debugDraw.m_sprite.graphics.clear();
var a = this.m_debugDraw.GetFlags(),
c, g, b;
new y;
new y;
new y;
var e;
new U;
new U;
e = [new y, new y, new y, new y];
var f = new w(0, 0, 0);
if (a & E.e_shapeBit)
for (c = this.m_bodyList; c; c = c.m_next) {
e = c.m_xf;
for (g = c.GetFixtureList(); g; g = g.m_next) {
b = g.GetShape();
if (c.IsActive() == false) f.Set(0.5, 0.5, 0.3);
else if (c.GetType() == k.b2_staticBody) f.Set(0.5, 0.9, 0.5);
else if (c.GetType() == k.b2_kinematicBody) f.Set(0.5, 0.5, 0.9);
else c.IsAwake() == false ?
f.Set(0.6, 0.6, 0.6) : f.Set(0.9, 0.7, 0.7);
this.DrawShape(b, e, f)
}
}
if (a & E.e_jointBit)
for (c = this.m_jointList; c; c = c.m_next) this.DrawJoint(c);
if (a & E.e_controllerBit)
for (c = this.m_controllerList; c; c = c.m_next) c.Draw(this.m_debugDraw);
if (a & E.e_pairBit) {
f.Set(0.3, 0.9, 0.9);
for (c = this.m_contactManager.m_contactList; c; c = c.GetNext()) {
b = c.GetFixtureA();
g = c.GetFixtureB();
b = b.GetAABB().GetCenter();
g = g.GetAABB().GetCenter();
this.m_debugDraw.DrawSegment(b, g, f)
}
}
if (a & E.e_aabbBit) {
b = this.m_contactManager.m_broadPhase;
e = [new y,
new y, new y, new y
];
for (c = this.m_bodyList; c; c = c.GetNext())
if (c.IsActive() != false)
for (g = c.GetFixtureList(); g; g = g.GetNext()) {
var m = b.GetFatAABB(g.m_proxy);
e[0].Set(m.lowerBound.x, m.lowerBound.y);
e[1].Set(m.upperBound.x, m.lowerBound.y);
e[2].Set(m.upperBound.x, m.upperBound.y);
e[3].Set(m.lowerBound.x, m.upperBound.y);
this.m_debugDraw.DrawPolygon(e, 4, f)
}
}
if (a & E.e_centerOfMassBit)
for (c = this.m_bodyList; c; c = c.m_next) {
e = h.s_xf;
e.R = c.m_xf.R;
e.position = c.GetWorldCenter();
this.m_debugDraw.DrawTransform(e)
}
}
};
h.prototype.QueryAABB = function (a, c) {
var g = this.m_contactManager.m_broadPhase;
g.Query(function (b) {
return a(g.GetUserData(b))
}, c)
};
h.prototype.QueryShape = function (a, c, g) {
if (g === undefined) g = null;
if (g == null) {
g = new K;
g.SetIdentity()
}
var b = this.m_contactManager.m_broadPhase,
e = new U;
c.ComputeAABB(e, g);
b.Query(function (f) {
f = b.GetUserData(f) instanceof S ? b.GetUserData(f) : null;
if (Y.TestOverlap(c, g, f.GetShape(), f.GetBody().GetTransform())) return a(f);
return true
}, e)
};
h.prototype.QueryPoint = function (a, c) {
var g = this.m_contactManager.m_broadPhase,
b = new U;
b.lowerBound.Set(c.x - A.b2_linearSlop, c.y - A.b2_linearSlop);
b.upperBound.Set(c.x + A.b2_linearSlop, c.y + A.b2_linearSlop);
g.Query(function (e) {
e = g.GetUserData(e) instanceof S ? g.GetUserData(e) : null;
if (e.TestPoint(c)) return a(e);
return true
}, b)
};
h.prototype.RayCast = function (a, c, g) {
var b = this.m_contactManager.m_broadPhase,
e = new V,
f = new Q(c, g);
b.RayCast(function (m, r) {
var s = b.GetUserData(r);
s = s instanceof S ? s : null;
if (s.RayCast(e, m)) {
var v = e.fraction,
t = new y((1 - v) * c.x + v * g.x, (1 - v) * c.y + v * g.y);
return a(s,
t, e.normal, v)
}
return m.maxFraction
}, f)
};
h.prototype.RayCastOne = function (a, c) {
var g;
this.RayCast(function (b, e, f, m) {
if (m === undefined) m = 0;
g = b;
return m
}, a, c);
return g
};
h.prototype.RayCastAll = function (a, c) {
var g = new Vector;
this.RayCast(function (b) {
g[g.length] = b;
return 1
}, a, c);
return g
};
h.prototype.GetBodyList = function () {
return this.m_bodyList
};
h.prototype.GetJointList = function () {
return this.m_jointList
};
h.prototype.GetContactList = function () {
return this.m_contactList
};
h.prototype.IsLocked = function () {
return (this.m_flags &
h.e_locked) > 0
};
h.prototype.Solve = function (a) {
for (var c, g = this.m_controllerList; g; g = g.m_next) g.Step(a);
g = this.m_island;
g.Initialize(this.m_bodyCount, this.m_contactCount, this.m_jointCount, null, this.m_contactManager.m_contactListener, this.m_contactSolver);
for (c = this.m_bodyList; c; c = c.m_next) c.m_flags &= ~k.e_islandFlag;
for (var b = this.m_contactList; b; b = b.m_next) b.m_flags &= ~l.e_islandFlag;
for (b = this.m_jointList; b; b = b.m_next) b.m_islandFlag = false;
parseInt(this.m_bodyCount);
b = this.s_stack;
for (var e = this.m_bodyList; e; e = e.m_next)
if (!(e.m_flags & k.e_islandFlag))
if (!(e.IsAwake() == false || e.IsActive() == false))
if (e.GetType() != k.b2_staticBody) {
g.Clear();
var f = 0;
b[f++] = e;
for (e.m_flags |= k.e_islandFlag; f > 0;) {
c = b[--f];
g.AddBody(c);
c.IsAwake() == false && c.SetAwake(true);
if (c.GetType() != k.b2_staticBody) {
for (var m, r = c.m_contactList; r; r = r.next)
if (!(r.contact.m_flags & l.e_islandFlag))
if (!(r.contact.IsSensor() == true || r.contact.IsEnabled() == false || r.contact.IsTouching() == false)) {
g.AddContact(r.contact);
r.contact.m_flags |= l.e_islandFlag;
m = r.other;
if (!(m.m_flags & k.e_islandFlag)) {
b[f++] = m;
m.m_flags |= k.e_islandFlag
}
}
for (c = c.m_jointList; c; c = c.next)
if (c.joint.m_islandFlag != true) {
m = c.other;
if (m.IsActive() != false) {
g.AddJoint(c.joint);
c.joint.m_islandFlag = true;
if (!(m.m_flags & k.e_islandFlag)) {
b[f++] = m;
m.m_flags |= k.e_islandFlag
}
}
}
}
}
g.Solve(a, this.m_gravity, this.m_allowSleep);
for (f = 0; f < g.m_bodyCount; ++f) {
c = g.m_bodies[f];
if (c.GetType() == k.b2_staticBody) c.m_flags &= ~k.e_islandFlag
}
}
for (f = 0; f < b.length; ++f) {
if (!b[f]) break;
b[f] = null
}
for (c = this.m_bodyList; c; c = c.m_next) c.IsAwake() == false || c.IsActive() == false || c.GetType() != k.b2_staticBody && c.SynchronizeFixtures();
this.m_contactManager.FindNewContacts()
};
h.prototype.SolveTOI = function (a) {
var c, g, b, e = this.m_island;
e.Initialize(this.m_bodyCount, A.b2_maxTOIContactsPerIsland, A.b2_maxTOIJointsPerIsland, null, this.m_contactManager.m_contactListener, this.m_contactSolver);
var f = h.s_queue;
for (c = this.m_bodyList; c; c = c.m_next) {
c.m_flags &= ~k.e_islandFlag;
c.m_sweep.t0 = 0
}
for (b = this.m_contactList; b; b = b.m_next) b.m_flags &= ~(l.e_toiFlag |
l.e_islandFlag);
for (b = this.m_jointList; b; b = b.m_next) b.m_islandFlag = false;
for (;;) {
var m = null,
r = 1;
for (b = this.m_contactList; b; b = b.m_next)
if (!(b.IsSensor() == true || b.IsEnabled() == false || b.IsContinuous() == false)) {
c = 1;
if (b.m_flags & l.e_toiFlag) c = b.m_toi;
else {
c = b.m_fixtureA;
g = b.m_fixtureB;
c = c.m_body;
g = g.m_body;
if ((c.GetType() != k.b2_dynamicBody || c.IsAwake() == false) && (g.GetType() != k.b2_dynamicBody || g.IsAwake() == false)) continue;
var s = c.m_sweep.t0;
if (c.m_sweep.t0 < g.m_sweep.t0) {
s = g.m_sweep.t0;
c.m_sweep.Advance(s)
} else if (g.m_sweep.t0 <
c.m_sweep.t0) {
s = c.m_sweep.t0;
g.m_sweep.Advance(s)
}
c = b.ComputeTOI(c.m_sweep, g.m_sweep);
A.b2Assert(0 <= c && c <= 1);
if (c > 0 && c < 1) {
c = (1 - c) * s + c;
if (c > 1) c = 1
}
b.m_toi = c;
b.m_flags |= l.e_toiFlag
} if (Number.MIN_VALUE < c && c < r) {
m = b;
r = c
}
}
if (m == null || 1 - 100 * Number.MIN_VALUE < r) break;
c = m.m_fixtureA;
g = m.m_fixtureB;
c = c.m_body;
g = g.m_body;
h.s_backupA.Set(c.m_sweep);
h.s_backupB.Set(g.m_sweep);
c.Advance(r);
g.Advance(r);
m.Update(this.m_contactManager.m_contactListener);
m.m_flags &= ~l.e_toiFlag;
if (m.IsSensor() == true || m.IsEnabled() == false) {
c.m_sweep.Set(h.s_backupA);
g.m_sweep.Set(h.s_backupB);
c.SynchronizeTransform();
g.SynchronizeTransform()
} else if (m.IsTouching() != false) {
c = c;
if (c.GetType() != k.b2_dynamicBody) c = g;
e.Clear();
m = b = 0;
f[b + m++] = c;
for (c.m_flags |= k.e_islandFlag; m > 0;) {
c = f[b++];
--m;
e.AddBody(c);
c.IsAwake() == false && c.SetAwake(true);
if (c.GetType() == k.b2_dynamicBody) {
for (g = c.m_contactList; g; g = g.next) {
if (e.m_contactCount == e.m_contactCapacity) break;
if (!(g.contact.m_flags & l.e_islandFlag))
if (!(g.contact.IsSensor() == true || g.contact.IsEnabled() == false || g.contact.IsTouching() == false)) {
e.AddContact(g.contact);
g.contact.m_flags |= l.e_islandFlag;
s = g.other;
if (!(s.m_flags & k.e_islandFlag)) {
if (s.GetType() != k.b2_staticBody) {
s.Advance(r);
s.SetAwake(true)
}
f[b + m] = s;
++m;
s.m_flags |= k.e_islandFlag
}
}
}
for (c = c.m_jointList; c; c = c.next)
if (e.m_jointCount != e.m_jointCapacity)
if (c.joint.m_islandFlag != true) {
s = c.other;
if (s.IsActive() != false) {
e.AddJoint(c.joint);
c.joint.m_islandFlag = true;
if (!(s.m_flags & k.e_islandFlag)) {
if (s.GetType() != k.b2_staticBody) {
s.Advance(r);
s.SetAwake(true)
}
f[b + m] = s;
++m;
s.m_flags |= k.e_islandFlag
}
}
}
}
}
b = h.s_timestep;
b.warmStarting = false;
b.dt = (1 - r) * a.dt;
b.inv_dt = 1 / b.dt;
b.dtRatio = 0;
b.velocityIterations = a.velocityIterations;
b.positionIterations = a.positionIterations;
e.SolveTOI(b);
for (r = r = 0; r < e.m_bodyCount; ++r) {
c = e.m_bodies[r];
c.m_flags &= ~k.e_islandFlag;
if (c.IsAwake() != false)
if (c.GetType() == k.b2_dynamicBody) {
c.SynchronizeFixtures();
for (g = c.m_contactList; g; g = g.next) g.contact.m_flags &= ~l.e_toiFlag
}
}
for (r = 0; r < e.m_contactCount; ++r) {
b = e.m_contacts[r];
b.m_flags &= ~(l.e_toiFlag |
l.e_islandFlag)
}
for (r = 0; r < e.m_jointCount; ++r) {
b = e.m_joints[r];
b.m_islandFlag = false
}
this.m_contactManager.FindNewContacts()
}
}
};
h.prototype.DrawJoint = function (a) {
var c = a.GetBodyA(),
g = a.GetBodyB(),
b = c.m_xf.position,
e = g.m_xf.position,
f = a.GetAnchorA(),
m = a.GetAnchorB(),
r = h.s_jointColor;
switch (a.m_type) {
case q.e_distanceJoint:
this.m_debugDraw.DrawSegment(f, m, r);
break;
case q.e_pulleyJoint:
c = a instanceof n ? a : null;
a = c.GetGroundAnchorA();
c = c.GetGroundAnchorB();
this.m_debugDraw.DrawSegment(a, f, r);
this.m_debugDraw.DrawSegment(c,
m, r);
this.m_debugDraw.DrawSegment(a, c, r);
break;
case q.e_mouseJoint:
this.m_debugDraw.DrawSegment(f, m, r);
break;
default:
c != this.m_groundBody && this.m_debugDraw.DrawSegment(b, f, r);
this.m_debugDraw.DrawSegment(f, m, r);
g != this.m_groundBody && this.m_debugDraw.DrawSegment(e, m, r)
}
};
h.prototype.DrawShape = function (a, c, g) {
switch (a.m_type) {
case Y.e_circleShape:
var b = a instanceof M ? a : null;
this.m_debugDraw.DrawSolidCircle(F.MulX(c, b.m_p), b.m_radius, c.R.col1, g);
break;
case Y.e_polygonShape:
b = 0;
b = a instanceof W ? a : null;
a = parseInt(b.GetVertexCount());
var e = b.GetVertices(),
f = new Vector(a);
for (b = 0; b < a; ++b) f[b] = F.MulX(c, e[b]);
this.m_debugDraw.DrawSolidPolygon(f, a, g);
break;
case Y.e_edgeShape:
b = a instanceof L ? a : null;
this.m_debugDraw.DrawSegment(F.MulX(c, b.GetVertex1()), F.MulX(c, b.GetVertex2()), g)
}
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.b2World.s_timestep2 = new d;
Box2D.Dynamics.b2World.s_xf = new K;
Box2D.Dynamics.b2World.s_backupA = new G;
Box2D.Dynamics.b2World.s_backupB = new G;
Box2D.Dynamics.b2World.s_timestep = new d;
Box2D.Dynamics.b2World.s_queue = new Vector;
Box2D.Dynamics.b2World.s_jointColor = new w(0.5, 0.8, 0.8);
Box2D.Dynamics.b2World.e_newFixture = 1;
Box2D.Dynamics.b2World.e_locked = 2
})
})();
(function () {
var F = Box2D.Collision.Shapes.b2CircleShape,
G = Box2D.Collision.Shapes.b2EdgeShape,
K = Box2D.Collision.Shapes.b2PolygonShape,
y = Box2D.Collision.Shapes.b2Shape,
w = Box2D.Dynamics.Contacts.b2CircleContact,
A = Box2D.Dynamics.Contacts.b2Contact,
U = Box2D.Dynamics.Contacts.b2ContactConstraint,
p = Box2D.Dynamics.Contacts.b2ContactConstraintPoint,
B = Box2D.Dynamics.Contacts.b2ContactEdge,
Q = Box2D.Dynamics.Contacts.b2ContactFactory,
V = Box2D.Dynamics.Contacts.b2ContactRegister,
M = Box2D.Dynamics.Contacts.b2ContactResult,
L = Box2D.Dynamics.Contacts.b2ContactSolver,
I = Box2D.Dynamics.Contacts.b2EdgeAndCircleContact,
W = Box2D.Dynamics.Contacts.b2NullContact,
Y = Box2D.Dynamics.Contacts.b2PolyAndCircleContact,
k = Box2D.Dynamics.Contacts.b2PolyAndEdgeContact,
z = Box2D.Dynamics.Contacts.b2PolygonContact,
u = Box2D.Dynamics.Contacts.b2PositionSolverManifold,
D = Box2D.Dynamics.b2Body,
H = Box2D.Dynamics.b2TimeStep,
O = Box2D.Common.b2Settings,
E = Box2D.Common.Math.b2Mat22,
R = Box2D.Common.Math.b2Math,
N = Box2D.Common.Math.b2Vec2,
S = Box2D.Collision.b2Collision,
aa = Box2D.Collision.b2ContactID,
Z = Box2D.Collision.b2Manifold,
d = Box2D.Collision.b2TimeOfImpact,
h = Box2D.Collision.b2TOIInput,
l = Box2D.Collision.b2WorldManifold;
Box2D.inherit(w, Box2D.Dynamics.Contacts.b2Contact);
w.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
w.b2CircleContact = function () {
Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
};
w.Create = function () {
return new w
};
w.Destroy = function () {};
w.prototype.Reset = function (j, o) {
this.__super.Reset.call(this, j, o)
};
w.prototype.Evaluate = function () {
var j = this.m_fixtureA.GetBody(),
o = this.m_fixtureB.GetBody();
S.CollideCircles(this.m_manifold, this.m_fixtureA.GetShape() instanceof F ? this.m_fixtureA.GetShape() : null, j.m_xf, this.m_fixtureB.GetShape() instanceof F ? this.m_fixtureB.GetShape() : null, o.m_xf)
};
A.b2Contact = function () {
this.m_nodeA = new B;
this.m_nodeB = new B;
this.m_manifold = new Z;
this.m_oldManifold = new Z
};
A.prototype.GetManifold = function () {
return this.m_manifold
};
A.prototype.GetWorldManifold = function (j) {
var o = this.m_fixtureA.GetBody(),
q = this.m_fixtureB.GetBody(),
n = this.m_fixtureA.GetShape(),
a = this.m_fixtureB.GetShape();
j.Initialize(this.m_manifold, o.GetTransform(), n.m_radius, q.GetTransform(), a.m_radius)
};
A.prototype.IsTouching = function () {
return (this.m_flags & A.e_touchingFlag) == A.e_touchingFlag
};
A.prototype.IsContinuous = function () {
return (this.m_flags & A.e_continuousFlag) == A.e_continuousFlag
};
A.prototype.SetSensor = function (j) {
if (j) this.m_flags |= A.e_sensorFlag;
else this.m_flags &= ~A.e_sensorFlag
};
A.prototype.IsSensor = function () {
return (this.m_flags &
A.e_sensorFlag) == A.e_sensorFlag
};
A.prototype.SetEnabled = function (j) {
if (j) this.m_flags |= A.e_enabledFlag;
else this.m_flags &= ~A.e_enabledFlag
};
A.prototype.IsEnabled = function () {
return (this.m_flags & A.e_enabledFlag) == A.e_enabledFlag
};
A.prototype.GetNext = function () {
return this.m_next
};
A.prototype.GetFixtureA = function () {
return this.m_fixtureA
};
A.prototype.GetFixtureB = function () {
return this.m_fixtureB
};
A.prototype.FlagForFiltering = function () {
this.m_flags |= A.e_filterFlag
};
A.prototype.b2Contact = function () {};
A.prototype.Reset = function (j, o) {
if (j === undefined) j = null;
if (o === undefined) o = null;
this.m_flags = A.e_enabledFlag;
if (!j || !o) this.m_fixtureB = this.m_fixtureA = null;
else {
if (j.IsSensor() || o.IsSensor()) this.m_flags |= A.e_sensorFlag;
var q = j.GetBody(),
n = o.GetBody();
if (q.GetType() != D.b2_dynamicBody || q.IsBullet() || n.GetType() != D.b2_dynamicBody || n.IsBullet()) this.m_flags |= A.e_continuousFlag;
this.m_fixtureA = j;
this.m_fixtureB = o;
this.m_manifold.m_pointCount = 0;
this.m_next = this.m_prev = null;
this.m_nodeA.contact = null;
this.m_nodeA.prev = null;
this.m_nodeA.next = null;
this.m_nodeA.other = null;
this.m_nodeB.contact = null;
this.m_nodeB.prev = null;
this.m_nodeB.next = null;
this.m_nodeB.other = null
}
};
A.prototype.Update = function (j) {
var o = this.m_oldManifold;
this.m_oldManifold = this.m_manifold;
this.m_manifold = o;
this.m_flags |= A.e_enabledFlag;
var q = false;
o = (this.m_flags & A.e_touchingFlag) == A.e_touchingFlag;
var n = this.m_fixtureA.m_body,
a = this.m_fixtureB.m_body,
c = this.m_fixtureA.m_aabb.TestOverlap(this.m_fixtureB.m_aabb);
if (this.m_flags & A.e_sensorFlag) {
if (c) {
q = this.m_fixtureA.GetShape();
c = this.m_fixtureB.GetShape();
n = n.GetTransform();
a = a.GetTransform();
q = y.TestOverlap(q, n, c, a)
}
this.m_manifold.m_pointCount = 0
} else {
if (n.GetType() != D.b2_dynamicBody || n.IsBullet() || a.GetType() != D.b2_dynamicBody || a.IsBullet()) this.m_flags |= A.e_continuousFlag;
else this.m_flags &= ~A.e_continuousFlag; if (c) {
this.Evaluate();
q = this.m_manifold.m_pointCount > 0;
for (c = 0; c < this.m_manifold.m_pointCount; ++c) {
var g = this.m_manifold.m_points[c];
g.m_normalImpulse = 0;
g.m_tangentImpulse = 0;
for (var b = g.m_id, e = 0; e < this.m_oldManifold.m_pointCount; ++e) {
var f = this.m_oldManifold.m_points[e];
if (f.m_id.key == b.key) {
g.m_normalImpulse = f.m_normalImpulse;
g.m_tangentImpulse = f.m_tangentImpulse;
break
}
}
}
} else this.m_manifold.m_pointCount = 0; if (q != o) {
n.SetAwake(true);
a.SetAwake(true)
}
} if (q) this.m_flags |= A.e_touchingFlag;
else this.m_flags &= ~A.e_touchingFlag;
o == false && q == true && j.BeginContact(this);
o == true && q == false && j.EndContact(this);
(this.m_flags & A.e_sensorFlag) == 0 && j.PreSolve(this, this.m_oldManifold)
};
A.prototype.Evaluate = function () {};
A.prototype.ComputeTOI = function (j, o) {
A.s_input.proxyA.Set(this.m_fixtureA.GetShape());
A.s_input.proxyB.Set(this.m_fixtureB.GetShape());
A.s_input.sweepA = j;
A.s_input.sweepB = o;
A.s_input.tolerance = O.b2_linearSlop;
return d.TimeOfImpact(A.s_input)
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.Contacts.b2Contact.e_sensorFlag = 1;
Box2D.Dynamics.Contacts.b2Contact.e_continuousFlag = 2;
Box2D.Dynamics.Contacts.b2Contact.e_islandFlag = 4;
Box2D.Dynamics.Contacts.b2Contact.e_toiFlag = 8;
Box2D.Dynamics.Contacts.b2Contact.e_touchingFlag = 16;
Box2D.Dynamics.Contacts.b2Contact.e_enabledFlag = 32;
Box2D.Dynamics.Contacts.b2Contact.e_filterFlag = 64;
Box2D.Dynamics.Contacts.b2Contact.s_input = new h
});
U.b2ContactConstraint = function () {
this.localPlaneNormal = new N;
this.localPoint = new N;
this.normal = new N;
this.normalMass = new E;
this.K = new E
};
U.prototype.b2ContactConstraint = function () {
this.points = new Vector(O.b2_maxManifoldPoints);
for (var j = 0; j < O.b2_maxManifoldPoints; j++) this.points[j] = new p
};
p.b2ContactConstraintPoint = function () {
this.localPoint = new N;
this.rA = new N;
this.rB = new N
};
B.b2ContactEdge = function () {};
Q.b2ContactFactory = function () {};
Q.prototype.b2ContactFactory = function (j) {
this.m_allocator = j;
this.InitializeRegisters()
};
Q.prototype.AddType = function (j, o, q, n) {
if (q === undefined) q = 0;
if (n === undefined) n = 0;
this.m_registers[q][n].createFcn = j;
this.m_registers[q][n].destroyFcn = o;
this.m_registers[q][n].primary = true;
if (q != n) {
this.m_registers[n][q].createFcn = j;
this.m_registers[n][q].destroyFcn = o;
this.m_registers[n][q].primary = false
}
};
Q.prototype.InitializeRegisters = function () {
this.m_registers = new Vector(y.e_shapeTypeCount);
for (var j = 0; j < y.e_shapeTypeCount; j++) {
this.m_registers[j] = new Vector(y.e_shapeTypeCount);
for (var o = 0; o < y.e_shapeTypeCount; o++) this.m_registers[j][o] = new V
}
this.AddType(w.Create, w.Destroy, y.e_circleShape, y.e_circleShape);
this.AddType(Y.Create, Y.Destroy, y.e_polygonShape, y.e_circleShape);
this.AddType(z.Create, z.Destroy, y.e_polygonShape, y.e_polygonShape);
this.AddType(I.Create, I.Destroy, y.e_edgeShape, y.e_circleShape);
this.AddType(k.Create, k.Destroy,
y.e_polygonShape, y.e_edgeShape)
};
Q.prototype.Create = function (j, o) {
var q = parseInt(j.GetType()),
n = parseInt(o.GetType());
q = this.m_registers[q][n];
if (q.pool) {
n = q.pool;
q.pool = n.m_next;
q.poolCount--;
n.Reset(j, o);
return n
}
n = q.createFcn;
if (n != null) {
if (q.primary) {
n = n(this.m_allocator);
n.Reset(j, o)
} else {
n = n(this.m_allocator);
n.Reset(o, j)
}
return n
} else return null
};
Q.prototype.Destroy = function (j) {
if (j.m_manifold.m_pointCount > 0) {
j.m_fixtureA.m_body.SetAwake(true);
j.m_fixtureB.m_body.SetAwake(true)
}
var o = parseInt(j.m_fixtureA.GetType()),
q = parseInt(j.m_fixtureB.GetType());
o = this.m_registers[o][q];
o.poolCount++;
j.m_next = o.pool;
o.pool = j;
o = o.destroyFcn;
o(j, this.m_allocator)
};
V.b2ContactRegister = function () {};
M.b2ContactResult = function () {
this.position = new N;
this.normal = new N;
this.id = new aa
};
L.b2ContactSolver = function () {
this.m_step = new H;
this.m_constraints = new Vector
};
L.prototype.b2ContactSolver = function () {};
L.prototype.Initialize = function (j, o, q, n) {
if (q === undefined) q = 0;
var a;
this.m_step.Set(j);
this.m_allocator = n;
j = 0;
for (this.m_constraintCount = q; this.m_constraints.length < this.m_constraintCount;) this.m_constraints[this.m_constraints.length] = new U;
for (j = 0; j < q; ++j) {
a = o[j];
n = a.m_fixtureA;
var c = a.m_fixtureB,
g = n.m_shape.m_radius,
b = c.m_shape.m_radius,
e = n.m_body,
f = c.m_body,
m = a.GetManifold(),
r = O.b2MixFriction(n.GetFriction(), c.GetFriction()),
s = O.b2MixRestitution(n.GetRestitution(), c.GetRestitution()),
v = e.m_linearVelocity.x,
t = e.m_linearVelocity.y,
x = f.m_linearVelocity.x,
C = f.m_linearVelocity.y,
J = e.m_angularVelocity,
T = f.m_angularVelocity;
O.b2Assert(m.m_pointCount > 0);
L.s_worldManifold.Initialize(m, e.m_xf, g, f.m_xf, b);
c = L.s_worldManifold.m_normal.x;
a = L.s_worldManifold.m_normal.y;
n = this.m_constraints[j];
n.bodyA = e;
n.bodyB = f;
n.manifold = m;
n.normal.x = c;
n.normal.y = a;
n.pointCount = m.m_pointCount;
n.friction = r;
n.restitution = s;
n.localPlaneNormal.x = m.m_localPlaneNormal.x;
n.localPlaneNormal.y = m.m_localPlaneNormal.y;
n.localPoint.x = m.m_localPoint.x;
n.localPoint.y = m.m_localPoint.y;
n.radius = g + b;
n.type = m.m_type;
for (g = 0; g < n.pointCount; ++g) {
r = m.m_points[g];
b = n.points[g];
b.normalImpulse = r.m_normalImpulse;
b.tangentImpulse = r.m_tangentImpulse;
b.localPoint.SetV(r.m_localPoint);
r = b.rA.x = L.s_worldManifold.m_points[g].x - e.m_sweep.c.x;
s = b.rA.y = L.s_worldManifold.m_points[g].y - e.m_sweep.c.y;
var P = b.rB.x = L.s_worldManifold.m_points[g].x - f.m_sweep.c.x,
X = b.rB.y = L.s_worldManifold.m_points[g].y - f.m_sweep.c.y,
$ = r * a - s * c,
ba = P * a - X * c;
$ *= $;
ba *= ba;
b.normalMass = 1 / (e.m_invMass + f.m_invMass + e.m_invI * $ + f.m_invI * ba);
var ca = e.m_mass * e.m_invMass + f.m_mass * f.m_invMass;
ca += e.m_mass * e.m_invI * $ + f.m_mass * f.m_invI * ba;
b.equalizedMass = 1 / ca;
ba = a;
ca = -c;
$ = r * ca - s * ba;
ba = P * ca - X * ba;
$ *= $;
ba *= ba;
b.tangentMass = 1 / (e.m_invMass + f.m_invMass + e.m_invI * $ + f.m_invI * ba);
b.velocityBias = 0;
r = n.normal.x * (x + -T * X - v - -J * s) + n.normal.y * (C + T * P - t - J * r);
if (r < -O.b2_velocityThreshold) b.velocityBias += -n.restitution * r
}
if (n.pointCount == 2) {
C = n.points[0];
x = n.points[1];
m = e.m_invMass;
e = e.m_invI;
v = f.m_invMass;
f = f.m_invI;
t = C.rA.x * a - C.rA.y * c;
C = C.rB.x * a - C.rB.y * c;
J = x.rA.x * a - x.rA.y * c;
x = x.rB.x * a - x.rB.y * c;
c = m + v + e * t * t + f * C * C;
a = m + v + e * J * J + f * x * x;
f = m + v + e * t * J + f * C * x;
if (c * c < 100 * (c * a - f * f)) {
n.K.col1.Set(c, f);
n.K.col2.Set(f, a);
n.K.GetInverse(n.normalMass)
} else n.pointCount = 1
}
}
};
L.prototype.InitVelocityConstraints = function (j) {
for (var o = 0; o < this.m_constraintCount; ++o) {
var q = this.m_constraints[o],
n = q.bodyA,
a = q.bodyB,
c = n.m_invMass,
g = n.m_invI,
b = a.m_invMass,
e = a.m_invI,
f = q.normal.x,
m = q.normal.y,
r = m,
s = -f,
v = 0,
t = 0;
if (j.warmStarting) {
t = q.pointCount;
for (v = 0; v < t; ++v) {
var x = q.points[v];
x.normalImpulse *= j.dtRatio;
x.tangentImpulse *= j.dtRatio;
var C = x.normalImpulse * f + x.tangentImpulse * r,
J = x.normalImpulse * m + x.tangentImpulse * s;
n.m_angularVelocity -= g * (x.rA.x * J - x.rA.y * C);
n.m_linearVelocity.x -= c * C;
n.m_linearVelocity.y -= c * J;
a.m_angularVelocity += e * (x.rB.x * J - x.rB.y * C);
a.m_linearVelocity.x += b * C;
a.m_linearVelocity.y += b * J
}
} else {
t = q.pointCount;
for (v = 0; v < t; ++v) {
n = q.points[v];
n.normalImpulse = 0;
n.tangentImpulse = 0
}
}
}
};
L.prototype.SolveVelocityConstraints = function () {
for (var j = 0, o, q = 0, n = 0, a = 0, c = n = n = q = q = 0, g = q = q = 0, b = q = a = 0, e = 0, f, m = 0; m < this.m_constraintCount; ++m) {
a = this.m_constraints[m];
var r = a.bodyA,
s = a.bodyB,
v = r.m_angularVelocity,
t = s.m_angularVelocity,
x = r.m_linearVelocity,
C = s.m_linearVelocity,
J = r.m_invMass,
T = r.m_invI,
P = s.m_invMass,
X = s.m_invI;
b = a.normal.x;
var $ = e = a.normal.y;
f = -b;
g = a.friction;
for (j = 0; j < a.pointCount; j++) {
o = a.points[j];
q = C.x - t * o.rB.y - x.x + v * o.rA.y;
n = C.y + t * o.rB.x - x.y - v * o.rA.x;
q = q * $ + n * f;
q = o.tangentMass * -q;
n = g * o.normalImpulse;
n = R.Clamp(o.tangentImpulse + q, -n, n);
q = n - o.tangentImpulse;
c = q * $;
q = q * f;
x.x -= J * c;
x.y -= J * q;
v -= T * (o.rA.x * q - o.rA.y * c);
C.x += P * c;
C.y += P * q;
t += X * (o.rB.x * q - o.rB.y * c);
o.tangentImpulse = n
}
parseInt(a.pointCount);
if (a.pointCount == 1) {
o = a.points[0];
q = C.x + -t * o.rB.y - x.x - -v * o.rA.y;
n = C.y + t * o.rB.x - x.y - v * o.rA.x;
a = q * b + n * e;
q = -o.normalMass * (a - o.velocityBias);
n = o.normalImpulse + q;
n = n > 0 ? n : 0;
q = n - o.normalImpulse;
c = q * b;
q = q * e;
x.x -= J * c;
x.y -= J * q;
v -= T * (o.rA.x * q - o.rA.y * c);
C.x += P * c;
C.y += P * q;
t += X * (o.rB.x * q - o.rB.y * c);
o.normalImpulse = n
} else {
o = a.points[0];
j = a.points[1];
q = o.normalImpulse;
g = j.normalImpulse;
var ba = (C.x - t * o.rB.y - x.x + v * o.rA.y) * b + (C.y + t * o.rB.x - x.y - v * o.rA.x) * e,
ca = (C.x - t * j.rB.y - x.x + v * j.rA.y) * b + (C.y + t * j.rB.x - x.y - v * j.rA.x) * e;
n = ba - o.velocityBias;
c = ca - j.velocityBias;
f = a.K;
n -= f.col1.x * q + f.col2.x * g;
for (c -= f.col1.y * q + f.col2.y * g;;) {
f = a.normalMass;
$ = -(f.col1.x * n + f.col2.x * c);
f = -(f.col1.y * n + f.col2.y * c);
if ($ >= 0 && f >= 0) {
q = $ - q;
g = f - g;
a = q * b;
q = q * e;
b = g * b;
e = g * e;
x.x -= J * (a + b);
x.y -= J * (q + e);
v -= T * (o.rA.x * q - o.rA.y * a + j.rA.x * e - j.rA.y * b);
C.x += P * (a + b);
C.y += P * (q + e);
t += X * (o.rB.x * q - o.rB.y * a + j.rB.x * e - j.rB.y * b);
o.normalImpulse = $;
j.normalImpulse = f;
break
}
$ = -o.normalMass * n;
f = 0;
ca = a.K.col1.y * $ + c;
if ($ >= 0 && ca >= 0) {
q = $ - q;
g = f - g;
a = q * b;
q = q * e;
b = g * b;
e = g * e;
x.x -= J * (a + b);
x.y -= J * (q + e);
v -= T * (o.rA.x * q - o.rA.y * a + j.rA.x * e - j.rA.y * b);
C.x += P * (a + b);
C.y += P * (q + e);
t += X * (o.rB.x * q - o.rB.y * a + j.rB.x * e - j.rB.y * b);
o.normalImpulse = $;
j.normalImpulse = f;
break
}
$ = 0;
f = -j.normalMass * c;
ba = a.K.col2.x * f + n;
if (f >= 0 && ba >= 0) {
q = $ - q;
g = f - g;
a = q * b;
q = q * e;
b = g * b;
e = g * e;
x.x -= J * (a + b);
x.y -= J * (q + e);
v -= T * (o.rA.x * q - o.rA.y * a + j.rA.x * e - j.rA.y * b);
C.x += P * (a + b);
C.y += P * (q + e);
t += X * (o.rB.x * q - o.rB.y * a + j.rB.x * e - j.rB.y * b);
o.normalImpulse = $;
j.normalImpulse = f;
break
}
f = $ = 0;
ba = n;
ca = c;
if (ba >= 0 && ca >= 0) {
q = $ - q;
g = f - g;
a = q * b;
q = q * e;
b = g * b;
e = g * e;
x.x -= J * (a + b);
x.y -= J * (q + e);
v -= T * (o.rA.x * q - o.rA.y * a + j.rA.x * e - j.rA.y * b);
C.x += P * (a + b);
C.y += P * (q + e);
t += X * (o.rB.x * q - o.rB.y * a + j.rB.x * e - j.rB.y * b);
o.normalImpulse = $;
j.normalImpulse = f;
break
}
break
}
}
r.m_angularVelocity = v;
s.m_angularVelocity = t
}
};
L.prototype.FinalizeVelocityConstraints = function () {
for (var j = 0; j < this.m_constraintCount; ++j) for (var o = this.m_constraints[j], q = o.manifold, n = 0; n < o.pointCount; ++n) {
var a = q.m_points[n],
c = o.points[n];
a.m_normalImpulse = c.normalImpulse;
a.m_tangentImpulse = c.tangentImpulse
}
};
L.prototype.SolvePositionConstraints = function (j) {
if (j === undefined) j = 0;
for (var o = 0, q = 0; q < this.m_constraintCount; q++) {
var n = this.m_constraints[q],
a = n.bodyA,
c = n.bodyB,
g = a.m_mass * a.m_invMass,
b = a.m_mass * a.m_invI,
e = c.m_mass * c.m_invMass,
f = c.m_mass * c.m_invI;
L.s_psm.Initialize(n);
for (var m = L.s_psm.m_normal, r = 0; r < n.pointCount; r++) {
var s = n.points[r],
v = L.s_psm.m_points[r],
t = L.s_psm.m_separations[r],
x = v.x - a.m_sweep.c.x,
C = v.y - a.m_sweep.c.y,
J = v.x - c.m_sweep.c.x;
v = v.y - c.m_sweep.c.y;
o = o < t ? o : t;
t = R.Clamp(j * (t + O.b2_linearSlop), -O.b2_maxLinearCorrection, 0);
t = -s.equalizedMass * t;
s = t * m.x;
t = t * m.y;
a.m_sweep.c.x -= g * s;
a.m_sweep.c.y -= g * t;
a.m_sweep.a -= b * (x * t - C * s);
a.SynchronizeTransform();
c.m_sweep.c.x += e * s;
c.m_sweep.c.y += e * t;
c.m_sweep.a += f * (J * t - v * s);
c.SynchronizeTransform()
}
}
return o > -1.5 * O.b2_linearSlop
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.Contacts.b2ContactSolver.s_worldManifold = new l;
Box2D.Dynamics.Contacts.b2ContactSolver.s_psm = new u
});
Box2D.inherit(I, Box2D.Dynamics.Contacts.b2Contact);
I.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
I.b2EdgeAndCircleContact = function () {
Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
};
I.Create = function () {
return new I
};
I.Destroy = function () {};
I.prototype.Reset = function (j, o) {
this.__super.Reset.call(this, j, o)
};
I.prototype.Evaluate = function () {
var j = this.m_fixtureA.GetBody(),
o = this.m_fixtureB.GetBody();
this.b2CollideEdgeAndCircle(this.m_manifold, this.m_fixtureA.GetShape() instanceof G ? this.m_fixtureA.GetShape() : null, j.m_xf,
this.m_fixtureB.GetShape() instanceof F ? this.m_fixtureB.GetShape() : null, o.m_xf)
};
I.prototype.b2CollideEdgeAndCircle = function () {};
Box2D.inherit(W, Box2D.Dynamics.Contacts.b2Contact);
W.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
W.b2NullContact = function () {
Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
};
W.prototype.b2NullContact = function () {
this.__super.b2Contact.call(this)
};
W.prototype.Evaluate = function () {};
Box2D.inherit(Y, Box2D.Dynamics.Contacts.b2Contact);
Y.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
Y.b2PolyAndCircleContact = function () {
Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
};
Y.Create = function () {
return new Y
};
Y.Destroy = function () {};
Y.prototype.Reset = function (j, o) {
this.__super.Reset.call(this, j, o);
O.b2Assert(j.GetType() == y.e_polygonShape);
O.b2Assert(o.GetType() == y.e_circleShape)
};
Y.prototype.Evaluate = function () {
var j = this.m_fixtureA.m_body,
o = this.m_fixtureB.m_body;
S.CollidePolygonAndCircle(this.m_manifold, this.m_fixtureA.GetShape() instanceof K ? this.m_fixtureA.GetShape() : null, j.m_xf, this.m_fixtureB.GetShape() instanceof F ? this.m_fixtureB.GetShape() : null, o.m_xf)
};
Box2D.inherit(k, Box2D.Dynamics.Contacts.b2Contact);
k.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
k.b2PolyAndEdgeContact = function () {
Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
};
k.Create = function () {
return new k
};
k.Destroy = function () {};
k.prototype.Reset = function (j, o) {
this.__super.Reset.call(this, j, o);
O.b2Assert(j.GetType() == y.e_polygonShape);
O.b2Assert(o.GetType() == y.e_edgeShape)
};
k.prototype.Evaluate = function () {
var j = this.m_fixtureA.GetBody(),
o = this.m_fixtureB.GetBody();
this.b2CollidePolyAndEdge(this.m_manifold, this.m_fixtureA.GetShape() instanceof K ? this.m_fixtureA.GetShape() : null, j.m_xf, this.m_fixtureB.GetShape() instanceof G ? this.m_fixtureB.GetShape() : null, o.m_xf)
};
k.prototype.b2CollidePolyAndEdge = function () {};
Box2D.inherit(z, Box2D.Dynamics.Contacts.b2Contact);
z.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
z.b2PolygonContact = function () {
Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
};
z.Create = function () {
return new z
};
z.Destroy = function () {};
z.prototype.Reset = function (j, o) {
this.__super.Reset.call(this, j, o)
};
z.prototype.Evaluate = function () {
var j = this.m_fixtureA.GetBody(),
o = this.m_fixtureB.GetBody();
S.CollidePolygons(this.m_manifold, this.m_fixtureA.GetShape() instanceof K ? this.m_fixtureA.GetShape() : null, j.m_xf, this.m_fixtureB.GetShape() instanceof K ? this.m_fixtureB.GetShape() : null, o.m_xf)
};
u.b2PositionSolverManifold = function () {};
u.prototype.b2PositionSolverManifold = function () {
this.m_normal = new N;
this.m_separations = new Vector_a2j_Number(O.b2_maxManifoldPoints);
this.m_points = new Vector(O.b2_maxManifoldPoints);
for (var j = 0; j < O.b2_maxManifoldPoints; j++) this.m_points[j] = new N
};
u.prototype.Initialize = function (j) {
O.b2Assert(j.pointCount > 0);
var o = 0,
q = 0,
n = 0,
a, c = 0,
g = 0;
switch (j.type) {
case Z.e_circles:
a = j.bodyA.m_xf.R;
n = j.localPoint;
o = j.bodyA.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
q = j.bodyA.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
a = j.bodyB.m_xf.R;
n = j.points[0].localPoint;
c = j.bodyB.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
a = j.bodyB.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
n = c - o;
g = a - q;
var b = n * n + g * g;
if (b > Number.MIN_VALUE * Number.MIN_VALUE) {
b = Math.sqrt(b);
this.m_normal.x = n / b;
this.m_normal.y = g / b
} else {
this.m_normal.x = 1;
this.m_normal.y = 0
}
this.m_points[0].x = 0.5 * (o + c);
this.m_points[0].y = 0.5 * (q + a);
this.m_separations[0] = n * this.m_normal.x + g * this.m_normal.y - j.radius;
break;
case Z.e_faceA:
a = j.bodyA.m_xf.R;
n = j.localPlaneNormal;
this.m_normal.x = a.col1.x * n.x + a.col2.x * n.y;
this.m_normal.y = a.col1.y * n.x + a.col2.y * n.y;
a = j.bodyA.m_xf.R;
n = j.localPoint;
c = j.bodyA.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
g = j.bodyA.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
a = j.bodyB.m_xf.R;
for (o = 0; o < j.pointCount; ++o) {
n = j.points[o].localPoint;
q = j.bodyB.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
n = j.bodyB.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
this.m_separations[o] = (q - c) * this.m_normal.x + (n - g) * this.m_normal.y - j.radius;
this.m_points[o].x = q;
this.m_points[o].y = n
}
break;
case Z.e_faceB:
a = j.bodyB.m_xf.R;
n = j.localPlaneNormal;
this.m_normal.x = a.col1.x * n.x + a.col2.x * n.y;
this.m_normal.y = a.col1.y * n.x + a.col2.y * n.y;
a = j.bodyB.m_xf.R;
n = j.localPoint;
c = j.bodyB.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
g = j.bodyB.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
a = j.bodyA.m_xf.R;
for (o = 0; o < j.pointCount; ++o) {
n = j.points[o].localPoint;
q = j.bodyA.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
n = j.bodyA.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
this.m_separations[o] = (q - c) * this.m_normal.x + (n - g) * this.m_normal.y - j.radius;
this.m_points[o].Set(q, n)
}
this.m_normal.x *= -1;
this.m_normal.y *= -1
}
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.Contacts.b2PositionSolverManifold.circlePointA = new N;
Box2D.Dynamics.Contacts.b2PositionSolverManifold.circlePointB = new N
})
})();
(function () {
var F = Box2D.Common.Math.b2Mat22,
G = Box2D.Common.Math.b2Math,
K = Box2D.Common.Math.b2Vec2,
y = Box2D.Common.b2Color,
w = Box2D.Dynamics.Controllers.b2BuoyancyController,
A = Box2D.Dynamics.Controllers.b2ConstantAccelController,
U = Box2D.Dynamics.Controllers.b2ConstantForceController,
p = Box2D.Dynamics.Controllers.b2Controller,
B = Box2D.Dynamics.Controllers.b2ControllerEdge,
Q = Box2D.Dynamics.Controllers.b2GravityController,
V = Box2D.Dynamics.Controllers.b2TensorDampingController;
Box2D.inherit(w, Box2D.Dynamics.Controllers.b2Controller);
w.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
w.b2BuoyancyController = function () {
Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
this.normal = new K(0, -1);
this.density = this.offset = 0;
this.velocity = new K(0, 0);
this.linearDrag = 2;
this.angularDrag = 1;
this.useDensity = false;
this.useWorldGravity = true;
this.gravity = null
};
w.prototype.Step = function () {
if (this.m_bodyList) {
if (this.useWorldGravity) this.gravity = this.GetWorld().GetGravity().Copy();
for (var M = this.m_bodyList; M; M = M.nextBody) {
var L = M.body;
if (L.IsAwake() != false) {
for (var I = new K, W = new K, Y = 0, k = 0, z = L.GetFixtureList(); z; z = z.GetNext()) {
var u = new K,
D = z.GetShape().ComputeSubmergedArea(this.normal, this.offset, L.GetTransform(), u);
Y += D;
I.x += D * u.x;
I.y += D * u.y;
var H = 0;
H = 1;
k += D * H;
W.x += D * u.x * H;
W.y += D * u.y * H
}
I.x /= Y;
I.y /= Y;
W.x /= k;
W.y /= k;
if (!(Y < Number.MIN_VALUE)) {
k = this.gravity.GetNegative();
k.Multiply(this.density * Y);
L.ApplyForce(k, W);
W = L.GetLinearVelocityFromWorldPoint(I);
W.Subtract(this.velocity);
W.Multiply(-this.linearDrag * Y);
L.ApplyForce(W, I);
L.ApplyTorque(-L.GetInertia() / L.GetMass() * Y * L.GetAngularVelocity() * this.angularDrag)
}
}
}
}
};
w.prototype.Draw = function (M) {
var L = new K,
I = new K;
L.x = this.normal.x * this.offset + this.normal.y * 1E3;
L.y = this.normal.y * this.offset - this.normal.x * 1E3;
I.x = this.normal.x * this.offset - this.normal.y * 1E3;
I.y = this.normal.y * this.offset + this.normal.x * 1E3;
var W = new y(0, 0, 1);
M.DrawSegment(L, I, W)
};
Box2D.inherit(A, Box2D.Dynamics.Controllers.b2Controller);
A.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
A.b2ConstantAccelController = function () {
Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
this.A = new K(0, 0)
};
A.prototype.Step = function (M) {
M = new K(this.A.x * M.dt, this.A.y * M.dt);
for (var L = this.m_bodyList; L; L = L.nextBody) {
var I = L.body;
I.IsAwake() && I.SetLinearVelocity(new K(I.GetLinearVelocity().x + M.x, I.GetLinearVelocity().y + M.y))
}
};
Box2D.inherit(U, Box2D.Dynamics.Controllers.b2Controller);
U.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
U.b2ConstantForceController = function () {
Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
this.F = new K(0, 0)
};
U.prototype.Step = function () {
for (var M = this.m_bodyList; M; M = M.nextBody) {
var L = M.body;
L.IsAwake() && L.ApplyForce(this.F, L.GetWorldCenter())
}
};
p.b2Controller = function () {};
p.prototype.Step = function () {};
p.prototype.Draw = function () {};
p.prototype.AddBody = function (M) {
var L = new B;
L.controller = this;
L.body = M;
L.nextBody = this.m_bodyList;
L.prevBody = null;
this.m_bodyList = L;
if (L.nextBody) L.nextBody.prevBody = L;
this.m_bodyCount++;
L.nextController = M.m_controllerList;
L.prevController = null;
M.m_controllerList = L;
if (L.nextController) L.nextController.prevController = L;
M.m_controllerCount++
};
p.prototype.RemoveBody = function (M) {
for (var L = M.m_controllerList; L && L.controller != this;) L = L.nextController;
if (L.prevBody) L.prevBody.nextBody = L.nextBody;
if (L.nextBody) L.nextBody.prevBody = L.prevBody;
if (L.nextController) L.nextController.prevController = L.prevController;
if (L.prevController) L.prevController.nextController = L.nextController;
if (this.m_bodyList == L) this.m_bodyList = L.nextBody;
if (M.m_controllerList == L) M.m_controllerList = L.nextController;
M.m_controllerCount--;
this.m_bodyCount--
};
p.prototype.Clear = function () {
for (; this.m_bodyList;) this.RemoveBody(this.m_bodyList.body)
};
p.prototype.GetNext = function () {
return this.m_next
};
p.prototype.GetWorld = function () {
return this.m_world
};
p.prototype.GetBodyList = function () {
return this.m_bodyList
};
B.b2ControllerEdge = function () {};
Box2D.inherit(Q, Box2D.Dynamics.Controllers.b2Controller);
Q.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
Q.b2GravityController = function () {
Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
this.G = 1;
this.invSqr = true
};
Q.prototype.Step = function () {
var M = null,
L = null,
I = null,
W = 0,
Y = null,
k = null,
z = null,
u = 0,
D = 0,
H = 0;
u = null;
if (this.invSqr) for (M = this.m_bodyList; M; M = M.nextBody) {
L = M.body;
I = L.GetWorldCenter();
W = L.GetMass();
for (Y = this.m_bodyList; Y != M; Y = Y.nextBody) {
k = Y.body;
z = k.GetWorldCenter();
u = z.x - I.x;
D = z.y - I.y;
H = u * u + D * D;
if (!(H < Number.MIN_VALUE)) {
u = new K(u, D);
u.Multiply(this.G / H / Math.sqrt(H) * W * k.GetMass());
L.IsAwake() && L.ApplyForce(u, I);
u.Multiply(-1);
k.IsAwake() && k.ApplyForce(u, z)
}
}
} else
for (M = this.m_bodyList; M; M = M.nextBody) {
L = M.body;
I = L.GetWorldCenter();
W = L.GetMass();
for (Y = this.m_bodyList; Y != M; Y = Y.nextBody) {
k = Y.body;
z = k.GetWorldCenter();
u = z.x - I.x;
D = z.y - I.y;
H = u * u + D * D;
if (!(H < Number.MIN_VALUE)) {
u = new K(u, D);
u.Multiply(this.G / H * W * k.GetMass());
L.IsAwake() && L.ApplyForce(u, I);
u.Multiply(-1);
k.IsAwake() && k.ApplyForce(u, z)
}
}
}
};
Box2D.inherit(V, Box2D.Dynamics.Controllers.b2Controller);
V.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
V.b2TensorDampingController = function () {
Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
this.T = new F;
this.maxTimestep = 0
};
V.prototype.SetAxisAligned = function (M, L) {
if (M === undefined) M = 0;
if (L === undefined) L = 0;
this.T.col1.x = -M;
this.T.col1.y = 0;
this.T.col2.x = 0;
this.T.col2.y = -L;
this.maxTimestep = M > 0 || L > 0 ? 1 / Math.max(M, L) : 0
};
V.prototype.Step = function (M) {
M = M.dt;
if (!(M <= Number.MIN_VALUE)) {
if (M > this.maxTimestep && this.maxTimestep > 0) M = this.maxTimestep;
for (var L = this.m_bodyList; L; L = L.nextBody) {
var I = L.body;
if (I.IsAwake()) {
var W = I.GetWorldVector(G.MulMV(this.T, I.GetLocalVector(I.GetLinearVelocity())));
I.SetLinearVelocity(new K(I.GetLinearVelocity().x + W.x * M, I.GetLinearVelocity().y + W.y * M))
}
}
}
}
})();
(function () {
var F = Box2D.Common.b2Settings,
G = Box2D.Common.Math.b2Mat22,
K = Box2D.Common.Math.b2Mat33,
y = Box2D.Common.Math.b2Math,
w = Box2D.Common.Math.b2Vec2,
A = Box2D.Common.Math.b2Vec3,
U = Box2D.Dynamics.Joints.b2DistanceJoint,
p = Box2D.Dynamics.Joints.b2DistanceJointDef,
B = Box2D.Dynamics.Joints.b2FrictionJoint,
Q = Box2D.Dynamics.Joints.b2FrictionJointDef,
V = Box2D.Dynamics.Joints.b2GearJoint,
M = Box2D.Dynamics.Joints.b2GearJointDef,
L = Box2D.Dynamics.Joints.b2Jacobian,
I = Box2D.Dynamics.Joints.b2Joint,
W = Box2D.Dynamics.Joints.b2JointDef,
Y = Box2D.Dynamics.Joints.b2JointEdge,
k = Box2D.Dynamics.Joints.b2LineJoint,
z = Box2D.Dynamics.Joints.b2LineJointDef,
u = Box2D.Dynamics.Joints.b2MouseJoint,
D = Box2D.Dynamics.Joints.b2MouseJointDef,
H = Box2D.Dynamics.Joints.b2PrismaticJoint,
O = Box2D.Dynamics.Joints.b2PrismaticJointDef,
E = Box2D.Dynamics.Joints.b2PulleyJoint,
R = Box2D.Dynamics.Joints.b2PulleyJointDef,
N = Box2D.Dynamics.Joints.b2RevoluteJoint,
S = Box2D.Dynamics.Joints.b2RevoluteJointDef,
aa = Box2D.Dynamics.Joints.b2WeldJoint,
Z = Box2D.Dynamics.Joints.b2WeldJointDef;
Box2D.inherit(U, Box2D.Dynamics.Joints.b2Joint);
U.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
U.b2DistanceJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.m_localAnchor1 = new w;
this.m_localAnchor2 = new w;
this.m_u = new w
};
U.prototype.GetAnchorA = function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
};
U.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
};
U.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * this.m_impulse * this.m_u.x, d * this.m_impulse * this.m_u.y)
};
U.prototype.GetReactionTorque = function () {
return 0
};
U.prototype.GetLength = function () {
return this.m_length
};
U.prototype.SetLength = function (d) {
if (d === undefined) d = 0;
this.m_length = d
};
U.prototype.GetFrequency = function () {
return this.m_frequencyHz
};
U.prototype.SetFrequency = function (d) {
if (d === undefined) d = 0;
this.m_frequencyHz = d
};
U.prototype.GetDampingRatio = function () {
return this.m_dampingRatio
};
U.prototype.SetDampingRatio = function (d) {
if (d === undefined) d = 0;
this.m_dampingRatio = d
};
U.prototype.b2DistanceJoint = function (d) {
this.__super.b2Joint.call(this, d);
this.m_localAnchor1.SetV(d.localAnchorA);
this.m_localAnchor2.SetV(d.localAnchorB);
this.m_length = d.length;
this.m_frequencyHz = d.frequencyHz;
this.m_dampingRatio = d.dampingRatio;
this.m_bias = this.m_gamma = this.m_impulse = 0
};
U.prototype.InitVelocityConstraints = function (d) {
var h, l = 0,
j = this.m_bodyA,
o = this.m_bodyB;
h = j.m_xf.R;
var q = this.m_localAnchor1.x - j.m_sweep.localCenter.x,
n = this.m_localAnchor1.y - j.m_sweep.localCenter.y;
l = h.col1.x * q + h.col2.x * n;
n = h.col1.y * q + h.col2.y * n;
q = l;
h = o.m_xf.R;
var a = this.m_localAnchor2.x - o.m_sweep.localCenter.x,
c = this.m_localAnchor2.y - o.m_sweep.localCenter.y;
l = h.col1.x * a + h.col2.x * c;
c = h.col1.y * a + h.col2.y * c;
a = l;
this.m_u.x = o.m_sweep.c.x + a - j.m_sweep.c.x - q;
this.m_u.y = o.m_sweep.c.y + c - j.m_sweep.c.y - n;
l = Math.sqrt(this.m_u.x * this.m_u.x + this.m_u.y * this.m_u.y);
l > F.b2_linearSlop ? this.m_u.Multiply(1 / l) : this.m_u.SetZero();
h = q * this.m_u.y - n * this.m_u.x;
var g = a * this.m_u.y - c * this.m_u.x;
h = j.m_invMass + j.m_invI * h * h + o.m_invMass + o.m_invI * g * g;
this.m_mass = h != 0 ? 1 / h : 0;
if (this.m_frequencyHz > 0) {
l = l - this.m_length;
g = 2 * Math.PI * this.m_frequencyHz;
var b = this.m_mass * g * g;
this.m_gamma = d.dt * (2 * this.m_mass * this.m_dampingRatio * g + d.dt * b);
this.m_gamma = this.m_gamma != 0 ? 1 / this.m_gamma : 0;
this.m_bias = l * d.dt * b * this.m_gamma;
this.m_mass = h + this.m_gamma;
this.m_mass = this.m_mass != 0 ? 1 / this.m_mass : 0
}
if (d.warmStarting) {
this.m_impulse *= d.dtRatio;
d = this.m_impulse * this.m_u.x;
h = this.m_impulse * this.m_u.y;
j.m_linearVelocity.x -= j.m_invMass * d;
j.m_linearVelocity.y -= j.m_invMass * h;
j.m_angularVelocity -= j.m_invI * (q * h - n * d);
o.m_linearVelocity.x += o.m_invMass * d;
o.m_linearVelocity.y += o.m_invMass * h;
o.m_angularVelocity += o.m_invI * (a * h - c * d)
} else this.m_impulse = 0
};
U.prototype.SolveVelocityConstraints = function () {
var d, h = this.m_bodyA,
l = this.m_bodyB;
d = h.m_xf.R;
var j = this.m_localAnchor1.x - h.m_sweep.localCenter.x,
o = this.m_localAnchor1.y - h.m_sweep.localCenter.y,
q = d.col1.x * j + d.col2.x * o;
o = d.col1.y * j + d.col2.y * o;
j = q;
d = l.m_xf.R;
var n = this.m_localAnchor2.x - l.m_sweep.localCenter.x,
a = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
q = d.col1.x * n + d.col2.x * a;
a = d.col1.y * n + d.col2.y * a;
n = q;
q = -this.m_mass * (this.m_u.x * (l.m_linearVelocity.x + -l.m_angularVelocity * a - (h.m_linearVelocity.x + -h.m_angularVelocity * o)) + this.m_u.y * (l.m_linearVelocity.y + l.m_angularVelocity * n - (h.m_linearVelocity.y + h.m_angularVelocity * j)) + this.m_bias + this.m_gamma * this.m_impulse);
this.m_impulse += q;
d = q * this.m_u.x;
q = q * this.m_u.y;
h.m_linearVelocity.x -= h.m_invMass * d;
h.m_linearVelocity.y -= h.m_invMass * q;
h.m_angularVelocity -= h.m_invI * (j * q - o * d);
l.m_linearVelocity.x += l.m_invMass * d;
l.m_linearVelocity.y += l.m_invMass * q;
l.m_angularVelocity += l.m_invI * (n * q - a * d)
};
U.prototype.SolvePositionConstraints = function () {
var d;
if (this.m_frequencyHz > 0) return true;
var h = this.m_bodyA,
l = this.m_bodyB;
d = h.m_xf.R;
var j = this.m_localAnchor1.x - h.m_sweep.localCenter.x,
o = this.m_localAnchor1.y - h.m_sweep.localCenter.y,
q = d.col1.x * j + d.col2.x * o;
o = d.col1.y * j + d.col2.y * o;
j = q;
d = l.m_xf.R;
var n = this.m_localAnchor2.x - l.m_sweep.localCenter.x,
a = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
q = d.col1.x * n + d.col2.x * a;
a = d.col1.y * n + d.col2.y * a;
n = q;
q = l.m_sweep.c.x + n - h.m_sweep.c.x - j;
var c = l.m_sweep.c.y + a - h.m_sweep.c.y - o;
d = Math.sqrt(q * q + c * c);
q /= d;
c /= d;
d = d - this.m_length;
d = y.Clamp(d, -F.b2_maxLinearCorrection, F.b2_maxLinearCorrection);
var g = -this.m_mass * d;
this.m_u.Set(q, c);
q = g * this.m_u.x;
c = g * this.m_u.y;
h.m_sweep.c.x -= h.m_invMass * q;
h.m_sweep.c.y -= h.m_invMass * c;
h.m_sweep.a -= h.m_invI * (j * c - o * q);
l.m_sweep.c.x += l.m_invMass * q;
l.m_sweep.c.y += l.m_invMass * c;
l.m_sweep.a += l.m_invI * (n * c - a * q);
h.SynchronizeTransform();
l.SynchronizeTransform();
return y.Abs(d) < F.b2_linearSlop
};
Box2D.inherit(p, Box2D.Dynamics.Joints.b2JointDef);
p.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
p.b2DistanceJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
this.localAnchorA = new w;
this.localAnchorB = new w
};
p.prototype.b2DistanceJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_distanceJoint;
this.length = 1;
this.dampingRatio = this.frequencyHz = 0
};
p.prototype.Initialize = function (d, h, l, j) {
this.bodyA = d;
this.bodyB = h;
this.localAnchorA.SetV(this.bodyA.GetLocalPoint(l));
this.localAnchorB.SetV(this.bodyB.GetLocalPoint(j));
d = j.x - l.x;
l = j.y - l.y;
this.length = Math.sqrt(d * d + l * l);
this.dampingRatio = this.frequencyHz = 0
};
Box2D.inherit(B, Box2D.Dynamics.Joints.b2Joint);
B.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
B.b2FrictionJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.m_localAnchorA = new w;
this.m_localAnchorB = new w;
this.m_linearMass = new G;
this.m_linearImpulse = new w
};
B.prototype.GetAnchorA = function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
};
B.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
};
B.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * this.m_linearImpulse.x, d * this.m_linearImpulse.y)
};
B.prototype.GetReactionTorque = function (d) {
if (d === undefined) d = 0;
return d * this.m_angularImpulse
};
B.prototype.SetMaxForce = function (d) {
if (d === undefined) d = 0;
this.m_maxForce = d
};
B.prototype.GetMaxForce = function () {
return this.m_maxForce
};
B.prototype.SetMaxTorque = function (d) {
if (d === undefined) d = 0;
this.m_maxTorque = d
};
B.prototype.GetMaxTorque = function () {
return this.m_maxTorque
};
B.prototype.b2FrictionJoint = function (d) {
this.__super.b2Joint.call(this, d);
this.m_localAnchorA.SetV(d.localAnchorA);
this.m_localAnchorB.SetV(d.localAnchorB);
this.m_linearMass.SetZero();
this.m_angularMass = 0;
this.m_linearImpulse.SetZero();
this.m_angularImpulse = 0;
this.m_maxForce = d.maxForce;
this.m_maxTorque = d.maxTorque
};
B.prototype.InitVelocityConstraints = function (d) {
var h, l = 0,
j = this.m_bodyA,
o = this.m_bodyB;
h = j.m_xf.R;
var q = this.m_localAnchorA.x - j.m_sweep.localCenter.x,
n = this.m_localAnchorA.y - j.m_sweep.localCenter.y;
l = h.col1.x * q + h.col2.x * n;
n = h.col1.y * q + h.col2.y * n;
q = l;
h = o.m_xf.R;
var a = this.m_localAnchorB.x - o.m_sweep.localCenter.x,
c = this.m_localAnchorB.y - o.m_sweep.localCenter.y;
l = h.col1.x * a + h.col2.x * c;
c = h.col1.y * a + h.col2.y * c;
a = l;
h = j.m_invMass;
l = o.m_invMass;
var g = j.m_invI,
b = o.m_invI,
e = new G;
e.col1.x = h + l;
e.col2.x = 0;
e.col1.y = 0;
e.col2.y = h + l;
e.col1.x += g * n * n;
e.col2.x += -g * q * n;
e.col1.y += -g * q * n;
e.col2.y += g * q * q;
e.col1.x += b * c * c;
e.col2.x += -b * a * c;
e.col1.y += -b * a * c;
e.col2.y += b * a * a;
e.GetInverse(this.m_linearMass);
this.m_angularMass = g + b;
if (this.m_angularMass > 0) this.m_angularMass = 1 / this.m_angularMass;
if (d.warmStarting) {
this.m_linearImpulse.x *= d.dtRatio;
this.m_linearImpulse.y *= d.dtRatio;
this.m_angularImpulse *= d.dtRatio;
d = this.m_linearImpulse;
j.m_linearVelocity.x -= h * d.x;
j.m_linearVelocity.y -= h * d.y;
j.m_angularVelocity -= g * (q * d.y - n * d.x + this.m_angularImpulse);
o.m_linearVelocity.x += l * d.x;
o.m_linearVelocity.y += l * d.y;
o.m_angularVelocity += b * (a * d.y - c * d.x + this.m_angularImpulse)
} else {
this.m_linearImpulse.SetZero();
this.m_angularImpulse = 0
}
};
B.prototype.SolveVelocityConstraints = function (d) {
var h, l = 0,
j = this.m_bodyA,
o = this.m_bodyB,
q = j.m_linearVelocity,
n = j.m_angularVelocity,
a = o.m_linearVelocity,
c = o.m_angularVelocity,
g = j.m_invMass,
b = o.m_invMass,
e = j.m_invI,
f = o.m_invI;
h = j.m_xf.R;
var m = this.m_localAnchorA.x - j.m_sweep.localCenter.x,
r = this.m_localAnchorA.y - j.m_sweep.localCenter.y;
l = h.col1.x * m + h.col2.x * r;
r = h.col1.y * m + h.col2.y * r;
m = l;
h = o.m_xf.R;
var s = this.m_localAnchorB.x - o.m_sweep.localCenter.x,
v = this.m_localAnchorB.y - o.m_sweep.localCenter.y;
l = h.col1.x * s + h.col2.x * v;
v = h.col1.y * s + h.col2.y * v;
s = l;
h = 0;
l = -this.m_angularMass * (c - n);
var t = this.m_angularImpulse;
h = d.dt * this.m_maxTorque;
this.m_angularImpulse = y.Clamp(this.m_angularImpulse + l, -h, h);
l = this.m_angularImpulse - t;
n -= e * l;
c += f * l;
h = y.MulMV(this.m_linearMass,
new w(-(a.x - c * v - q.x + n * r), -(a.y + c * s - q.y - n * m)));
l = this.m_linearImpulse.Copy();
this.m_linearImpulse.Add(h);
h = d.dt * this.m_maxForce;
if (this.m_linearImpulse.LengthSquared() > h * h) {
this.m_linearImpulse.Normalize();
this.m_linearImpulse.Multiply(h)
}
h = y.SubtractVV(this.m_linearImpulse, l);
q.x -= g * h.x;
q.y -= g * h.y;
n -= e * (m * h.y - r * h.x);
a.x += b * h.x;
a.y += b * h.y;
c += f * (s * h.y - v * h.x);
j.m_angularVelocity = n;
o.m_angularVelocity = c
};
B.prototype.SolvePositionConstraints = function () {
return true
};
Box2D.inherit(Q, Box2D.Dynamics.Joints.b2JointDef);
Q.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
Q.b2FrictionJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
this.localAnchorA = new w;
this.localAnchorB = new w
};
Q.prototype.b2FrictionJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_frictionJoint;
this.maxTorque = this.maxForce = 0
};
Q.prototype.Initialize = function (d, h, l) {
this.bodyA = d;
this.bodyB = h;
this.localAnchorA.SetV(this.bodyA.GetLocalPoint(l));
this.localAnchorB.SetV(this.bodyB.GetLocalPoint(l))
};
Box2D.inherit(V, Box2D.Dynamics.Joints.b2Joint);
V.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
V.b2GearJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.m_groundAnchor1 = new w;
this.m_groundAnchor2 = new w;
this.m_localAnchor1 = new w;
this.m_localAnchor2 = new w;
this.m_J = new L
};
V.prototype.GetAnchorA = function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
};
V.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
};
V.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * this.m_impulse * this.m_J.linearB.x, d * this.m_impulse * this.m_J.linearB.y)
};
V.prototype.GetReactionTorque = function (d) {
if (d === undefined) d = 0;
var h = this.m_bodyB.m_xf.R,
l = this.m_localAnchor1.x - this.m_bodyB.m_sweep.localCenter.x,
j = this.m_localAnchor1.y - this.m_bodyB.m_sweep.localCenter.y,
o = h.col1.x * l + h.col2.x * j;
j = h.col1.y * l + h.col2.y * j;
l = o;
return d * (this.m_impulse * this.m_J.angularB - l * this.m_impulse * this.m_J.linearB.y + j * this.m_impulse * this.m_J.linearB.x)
};
V.prototype.GetRatio = function () {
return this.m_ratio
};
V.prototype.SetRatio = function (d) {
if (d === undefined) d = 0;
this.m_ratio = d
};
V.prototype.b2GearJoint = function (d) {
this.__super.b2Joint.call(this, d);
var h = parseInt(d.joint1.m_type),
l = parseInt(d.joint2.m_type);
this.m_prismatic2 = this.m_revolute2 = this.m_prismatic1 = this.m_revolute1 = null;
var j = 0,
o = 0;
this.m_ground1 = d.joint1.GetBodyA();
this.m_bodyA = d.joint1.GetBodyB();
if (h == I.e_revoluteJoint) {
this.m_revolute1 = d.joint1 instanceof N ? d.joint1 : null;
this.m_groundAnchor1.SetV(this.m_revolute1.m_localAnchor1);
this.m_localAnchor1.SetV(this.m_revolute1.m_localAnchor2);
j = this.m_revolute1.GetJointAngle()
} else {
this.m_prismatic1 = d.joint1 instanceof H ? d.joint1 : null;
this.m_groundAnchor1.SetV(this.m_prismatic1.m_localAnchor1);
this.m_localAnchor1.SetV(this.m_prismatic1.m_localAnchor2);
j = this.m_prismatic1.GetJointTranslation()
}
this.m_ground2 = d.joint2.GetBodyA();
this.m_bodyB = d.joint2.GetBodyB();
if (l == I.e_revoluteJoint) {
this.m_revolute2 = d.joint2 instanceof N ? d.joint2 : null;
this.m_groundAnchor2.SetV(this.m_revolute2.m_localAnchor1);
this.m_localAnchor2.SetV(this.m_revolute2.m_localAnchor2);
o = this.m_revolute2.GetJointAngle()
} else {
this.m_prismatic2 = d.joint2 instanceof H ? d.joint2 : null;
this.m_groundAnchor2.SetV(this.m_prismatic2.m_localAnchor1);
this.m_localAnchor2.SetV(this.m_prismatic2.m_localAnchor2);
o = this.m_prismatic2.GetJointTranslation()
}
this.m_ratio = d.ratio;
this.m_constant = j + this.m_ratio * o;
this.m_impulse = 0
};
V.prototype.InitVelocityConstraints = function (d) {
var h = this.m_ground1,
l = this.m_ground2,
j = this.m_bodyA,
o = this.m_bodyB,
q = 0,
n = 0,
a = 0,
c = 0,
g = a = 0,
b = 0;
this.m_J.SetZero();
if (this.m_revolute1) {
this.m_J.angularA = -1;
b += j.m_invI
} else {
h = h.m_xf.R;
n = this.m_prismatic1.m_localXAxis1;
q = h.col1.x * n.x + h.col2.x * n.y;
n = h.col1.y * n.x + h.col2.y * n.y;
h = j.m_xf.R;
a = this.m_localAnchor1.x - j.m_sweep.localCenter.x;
c = this.m_localAnchor1.y - j.m_sweep.localCenter.y;
g = h.col1.x * a + h.col2.x * c;
c = h.col1.y * a + h.col2.y * c;
a = g;
a = a * n - c * q;
this.m_J.linearA.Set(-q, -n);
this.m_J.angularA = -a;
b += j.m_invMass + j.m_invI * a * a
} if (this.m_revolute2) {
this.m_J.angularB = -this.m_ratio;
b += this.m_ratio * this.m_ratio * o.m_invI
} else {
h = l.m_xf.R;
n = this.m_prismatic2.m_localXAxis1;
q = h.col1.x * n.x + h.col2.x * n.y;
n = h.col1.y * n.x + h.col2.y * n.y;
h = o.m_xf.R;
a = this.m_localAnchor2.x - o.m_sweep.localCenter.x;
c = this.m_localAnchor2.y - o.m_sweep.localCenter.y;
g = h.col1.x * a + h.col2.x * c;
c = h.col1.y * a + h.col2.y * c;
a = g;
a = a * n - c * q;
this.m_J.linearB.Set(-this.m_ratio * q, -this.m_ratio * n);
this.m_J.angularB = -this.m_ratio * a;
b += this.m_ratio * this.m_ratio * (o.m_invMass + o.m_invI * a * a)
}
this.m_mass = b > 0 ? 1 / b : 0;
if (d.warmStarting) {
j.m_linearVelocity.x += j.m_invMass * this.m_impulse * this.m_J.linearA.x;
j.m_linearVelocity.y += j.m_invMass * this.m_impulse * this.m_J.linearA.y;
j.m_angularVelocity += j.m_invI * this.m_impulse * this.m_J.angularA;
o.m_linearVelocity.x += o.m_invMass * this.m_impulse * this.m_J.linearB.x;
o.m_linearVelocity.y += o.m_invMass * this.m_impulse * this.m_J.linearB.y;
o.m_angularVelocity += o.m_invI * this.m_impulse * this.m_J.angularB
} else this.m_impulse = 0
};
V.prototype.SolveVelocityConstraints = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l = -this.m_mass * this.m_J.Compute(d.m_linearVelocity,
d.m_angularVelocity, h.m_linearVelocity, h.m_angularVelocity);
this.m_impulse += l;
d.m_linearVelocity.x += d.m_invMass * l * this.m_J.linearA.x;
d.m_linearVelocity.y += d.m_invMass * l * this.m_J.linearA.y;
d.m_angularVelocity += d.m_invI * l * this.m_J.angularA;
h.m_linearVelocity.x += h.m_invMass * l * this.m_J.linearB.x;
h.m_linearVelocity.y += h.m_invMass * l * this.m_J.linearB.y;
h.m_angularVelocity += h.m_invI * l * this.m_J.angularB
};
V.prototype.SolvePositionConstraints = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l = 0,
j = 0;
l = this.m_revolute1 ?
this.m_revolute1.GetJointAngle() : this.m_prismatic1.GetJointTranslation();
j = this.m_revolute2 ? this.m_revolute2.GetJointAngle() : this.m_prismatic2.GetJointTranslation();
l = -this.m_mass * (this.m_constant - (l + this.m_ratio * j));
d.m_sweep.c.x += d.m_invMass * l * this.m_J.linearA.x;
d.m_sweep.c.y += d.m_invMass * l * this.m_J.linearA.y;
d.m_sweep.a += d.m_invI * l * this.m_J.angularA;
h.m_sweep.c.x += h.m_invMass * l * this.m_J.linearB.x;
h.m_sweep.c.y += h.m_invMass * l * this.m_J.linearB.y;
h.m_sweep.a += h.m_invI * l * this.m_J.angularB;
d.SynchronizeTransform();
h.SynchronizeTransform();
return 0 < F.b2_linearSlop
};
Box2D.inherit(M, Box2D.Dynamics.Joints.b2JointDef);
M.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
M.b2GearJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments)
};
M.prototype.b2GearJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_gearJoint;
this.joint2 = this.joint1 = null;
this.ratio = 1
};
L.b2Jacobian = function () {
this.linearA = new w;
this.linearB = new w
};
L.prototype.SetZero = function () {
this.linearA.SetZero();
this.angularA = 0;
this.linearB.SetZero();
this.angularB = 0
};
L.prototype.Set = function (d, h, l, j) {
if (h === undefined) h = 0;
if (j === undefined) j = 0;
this.linearA.SetV(d);
this.angularA = h;
this.linearB.SetV(l);
this.angularB = j
};
L.prototype.Compute = function (d, h, l, j) {
if (h === undefined) h = 0;
if (j === undefined) j = 0;
return this.linearA.x * d.x + this.linearA.y * d.y + this.angularA * h + (this.linearB.x * l.x + this.linearB.y * l.y) + this.angularB * j
};
I.b2Joint = function () {
this.m_edgeA = new Y;
this.m_edgeB = new Y;
this.m_localCenterA = new w;
this.m_localCenterB = new w
};
I.prototype.GetType = function () {
return this.m_type
};
I.prototype.GetAnchorA = function () {
return null
};
I.prototype.GetAnchorB = function () {
return null
};
I.prototype.GetReactionForce = function () {
return null
};
I.prototype.GetReactionTorque = function () {
return 0
};
I.prototype.GetBodyA = function () {
return this.m_bodyA
};
I.prototype.GetBodyB = function () {
return this.m_bodyB
};
I.prototype.GetNext = function () {
return this.m_next
};
I.prototype.GetUserData = function () {
return this.m_userData
};
I.prototype.SetUserData = function (d) {
this.m_userData = d
};
I.prototype.IsActive = function () {
return this.m_bodyA.IsActive() && this.m_bodyB.IsActive()
};
I.Create = function (d) {
var h = null;
switch (d.type) {
case I.e_distanceJoint:
h = new U(d instanceof p ? d : null);
break;
case I.e_mouseJoint:
h = new u(d instanceof D ? d : null);
break;
case I.e_prismaticJoint:
h = new H(d instanceof O ? d : null);
break;
case I.e_revoluteJoint:
h = new N(d instanceof S ? d : null);
break;
case I.e_pulleyJoint:
h = new E(d instanceof R ? d : null);
break;
case I.e_gearJoint:
h = new V(d instanceof M ? d : null);
break;
case I.e_lineJoint:
h = new k(d instanceof z ? d : null);
break;
case I.e_weldJoint:
h = new aa(d instanceof Z ? d : null);
break;
case I.e_frictionJoint:
h = new B(d instanceof Q ? d : null)
}
return h
};
I.Destroy = function () {};
I.prototype.b2Joint = function (d) {
F.b2Assert(d.bodyA != d.bodyB);
this.m_type = d.type;
this.m_next = this.m_prev = null;
this.m_bodyA = d.bodyA;
this.m_bodyB = d.bodyB;
this.m_collideConnected = d.collideConnected;
this.m_islandFlag = false;
this.m_userData = d.userData
};
I.prototype.InitVelocityConstraints = function () {};
I.prototype.SolveVelocityConstraints = function () {};
I.prototype.FinalizeVelocityConstraints = function () {};
I.prototype.SolvePositionConstraints = function () {
return false
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.Joints.b2Joint.e_unknownJoint = 0;
Box2D.Dynamics.Joints.b2Joint.e_revoluteJoint = 1;
Box2D.Dynamics.Joints.b2Joint.e_prismaticJoint = 2;
Box2D.Dynamics.Joints.b2Joint.e_distanceJoint = 3;
Box2D.Dynamics.Joints.b2Joint.e_pulleyJoint = 4;
Box2D.Dynamics.Joints.b2Joint.e_mouseJoint = 5;
Box2D.Dynamics.Joints.b2Joint.e_gearJoint = 6;
Box2D.Dynamics.Joints.b2Joint.e_lineJoint = 7;
Box2D.Dynamics.Joints.b2Joint.e_weldJoint = 8;
Box2D.Dynamics.Joints.b2Joint.e_frictionJoint = 9;
Box2D.Dynamics.Joints.b2Joint.e_inactiveLimit = 0;
Box2D.Dynamics.Joints.b2Joint.e_atLowerLimit = 1;
Box2D.Dynamics.Joints.b2Joint.e_atUpperLimit = 2;
Box2D.Dynamics.Joints.b2Joint.e_equalLimits = 3
});
W.b2JointDef = function () {};
W.prototype.b2JointDef = function () {
this.type = I.e_unknownJoint;
this.bodyB = this.bodyA = this.userData = null;
this.collideConnected = false
};
Y.b2JointEdge = function () {};
Box2D.inherit(k, Box2D.Dynamics.Joints.b2Joint);
k.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
k.b2LineJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.m_localAnchor1 = new w;
this.m_localAnchor2 = new w;
this.m_localXAxis1 = new w;
this.m_localYAxis1 = new w;
this.m_axis = new w;
this.m_perp = new w;
this.m_K = new G;
this.m_impulse = new w
};
k.prototype.GetAnchorA = function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
};
k.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
};
k.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * (this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.x), d * (this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.y))
};
k.prototype.GetReactionTorque = function (d) {
if (d === undefined) d = 0;
return d * this.m_impulse.y
};
k.prototype.GetJointTranslation = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l = d.GetWorldPoint(this.m_localAnchor1),
j = h.GetWorldPoint(this.m_localAnchor2);
h = j.x - l.x;
l = j.y - l.y;
d = d.GetWorldVector(this.m_localXAxis1);
return d.x * h + d.y * l
};
k.prototype.GetJointSpeed = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l;
l = d.m_xf.R;
var j = this.m_localAnchor1.x - d.m_sweep.localCenter.x,
o = this.m_localAnchor1.y - d.m_sweep.localCenter.y,
q = l.col1.x * j + l.col2.x * o;
o = l.col1.y * j + l.col2.y * o;
j = q;
l = h.m_xf.R;
var n = this.m_localAnchor2.x - h.m_sweep.localCenter.x,
a = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
q = l.col1.x * n + l.col2.x * a;
a = l.col1.y * n + l.col2.y * a;
n = q;
l = h.m_sweep.c.x + n - (d.m_sweep.c.x + j);
q = h.m_sweep.c.y + a - (d.m_sweep.c.y + o);
var c = d.GetWorldVector(this.m_localXAxis1),
g = d.m_linearVelocity,
b = h.m_linearVelocity;
d = d.m_angularVelocity;
h = h.m_angularVelocity;
return l * -d * c.y + q * d * c.x + (c.x * (b.x + -h * a - g.x - -d * o) + c.y * (b.y + h * n - g.y - d * j))
};
k.prototype.IsLimitEnabled = function () {
return this.m_enableLimit
};
k.prototype.EnableLimit = function (d) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableLimit = d
};
k.prototype.GetLowerLimit = function () {
return this.m_lowerTranslation
};
k.prototype.GetUpperLimit = function () {
return this.m_upperTranslation
};
k.prototype.SetLimits = function (d,
h) {
if (d === undefined) d = 0;
if (h === undefined) h = 0;
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_lowerTranslation = d;
this.m_upperTranslation = h
};
k.prototype.IsMotorEnabled = function () {
return this.m_enableMotor
};
k.prototype.EnableMotor = function (d) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableMotor = d
};
k.prototype.SetMotorSpeed = function (d) {
if (d === undefined) d = 0;
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_motorSpeed = d
};
k.prototype.GetMotorSpeed = function () {
return this.m_motorSpeed
};
k.prototype.SetMaxMotorForce = function (d) {
if (d === undefined) d = 0;
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_maxMotorForce = d
};
k.prototype.GetMaxMotorForce = function () {
return this.m_maxMotorForce
};
k.prototype.GetMotorForce = function () {
return this.m_motorImpulse
};
k.prototype.b2LineJoint = function (d) {
this.__super.b2Joint.call(this, d);
this.m_localAnchor1.SetV(d.localAnchorA);
this.m_localAnchor2.SetV(d.localAnchorB);
this.m_localXAxis1.SetV(d.localAxisA);
this.m_localYAxis1.x = -this.m_localXAxis1.y;
this.m_localYAxis1.y = this.m_localXAxis1.x;
this.m_impulse.SetZero();
this.m_motorImpulse = this.m_motorMass = 0;
this.m_lowerTranslation = d.lowerTranslation;
this.m_upperTranslation = d.upperTranslation;
this.m_maxMotorForce = d.maxMotorForce;
this.m_motorSpeed = d.motorSpeed;
this.m_enableLimit = d.enableLimit;
this.m_enableMotor = d.enableMotor;
this.m_limitState = I.e_inactiveLimit;
this.m_axis.SetZero();
this.m_perp.SetZero()
};
k.prototype.InitVelocityConstraints = function (d) {
var h = this.m_bodyA,
l = this.m_bodyB,
j, o = 0;
this.m_localCenterA.SetV(h.GetLocalCenter());
this.m_localCenterB.SetV(l.GetLocalCenter());
var q = h.GetTransform();
l.GetTransform();
j = h.m_xf.R;
var n = this.m_localAnchor1.x - this.m_localCenterA.x,
a = this.m_localAnchor1.y - this.m_localCenterA.y;
o = j.col1.x * n + j.col2.x * a;
a = j.col1.y * n + j.col2.y * a;
n = o;
j = l.m_xf.R;
var c = this.m_localAnchor2.x - this.m_localCenterB.x,
g = this.m_localAnchor2.y - this.m_localCenterB.y;
o = j.col1.x * c + j.col2.x * g;
g = j.col1.y * c + j.col2.y * g;
c = o;
j = l.m_sweep.c.x + c - h.m_sweep.c.x - n;
o = l.m_sweep.c.y + g - h.m_sweep.c.y - a;
this.m_invMassA = h.m_invMass;
this.m_invMassB = l.m_invMass;
this.m_invIA = h.m_invI;
this.m_invIB = l.m_invI;
this.m_axis.SetV(y.MulMV(q.R, this.m_localXAxis1));
this.m_a1 = (j + n) * this.m_axis.y - (o + a) * this.m_axis.x;
this.m_a2 = c * this.m_axis.y - g * this.m_axis.x;
this.m_motorMass = this.m_invMassA + this.m_invMassB + this.m_invIA * this.m_a1 * this.m_a1 + this.m_invIB * this.m_a2 * this.m_a2;
this.m_motorMass = this.m_motorMass > Number.MIN_VALUE ? 1 / this.m_motorMass : 0;
this.m_perp.SetV(y.MulMV(q.R, this.m_localYAxis1));
this.m_s1 = (j + n) * this.m_perp.y - (o + a) * this.m_perp.x;
this.m_s2 = c * this.m_perp.y - g * this.m_perp.x;
q = this.m_invMassA;
n = this.m_invMassB;
a = this.m_invIA;
c = this.m_invIB;
this.m_K.col1.x = q + n + a * this.m_s1 * this.m_s1 + c * this.m_s2 * this.m_s2;
this.m_K.col1.y = a * this.m_s1 * this.m_a1 + c * this.m_s2 * this.m_a2;
this.m_K.col2.x = this.m_K.col1.y;
this.m_K.col2.y = q + n + a * this.m_a1 * this.m_a1 + c * this.m_a2 * this.m_a2;
if (this.m_enableLimit) {
j = this.m_axis.x * j + this.m_axis.y * o;
if (y.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * F.b2_linearSlop) this.m_limitState = I.e_equalLimits;
else if (j <= this.m_lowerTranslation) {
if (this.m_limitState != I.e_atLowerLimit) {
this.m_limitState = I.e_atLowerLimit;
this.m_impulse.y = 0
}
} else if (j >= this.m_upperTranslation) {
if (this.m_limitState != I.e_atUpperLimit) {
this.m_limitState = I.e_atUpperLimit;
this.m_impulse.y = 0
}
} else {
this.m_limitState = I.e_inactiveLimit;
this.m_impulse.y = 0
}
} else this.m_limitState = I.e_inactiveLimit; if (this.m_enableMotor == false) this.m_motorImpulse = 0;
if (d.warmStarting) {
this.m_impulse.x *= d.dtRatio;
this.m_impulse.y *= d.dtRatio;
this.m_motorImpulse *= d.dtRatio;
d = this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.x;
j = this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.y;
o = this.m_impulse.x * this.m_s1 + (this.m_motorImpulse + this.m_impulse.y) * this.m_a1;
q = this.m_impulse.x * this.m_s2 + (this.m_motorImpulse + this.m_impulse.y) * this.m_a2;
h.m_linearVelocity.x -= this.m_invMassA * d;
h.m_linearVelocity.y -= this.m_invMassA * j;
h.m_angularVelocity -= this.m_invIA * o;
l.m_linearVelocity.x += this.m_invMassB * d;
l.m_linearVelocity.y += this.m_invMassB * j;
l.m_angularVelocity += this.m_invIB * q
} else {
this.m_impulse.SetZero();
this.m_motorImpulse = 0
}
};
k.prototype.SolveVelocityConstraints = function (d) {
var h = this.m_bodyA,
l = this.m_bodyB,
j = h.m_linearVelocity,
o = h.m_angularVelocity,
q = l.m_linearVelocity,
n = l.m_angularVelocity,
a = 0,
c = 0,
g = 0,
b = 0;
if (this.m_enableMotor && this.m_limitState != I.e_equalLimits) {
b = this.m_motorMass * (this.m_motorSpeed - (this.m_axis.x * (q.x - j.x) + this.m_axis.y * (q.y - j.y) + this.m_a2 * n - this.m_a1 * o));
a = this.m_motorImpulse;
c = d.dt * this.m_maxMotorForce;
this.m_motorImpulse = y.Clamp(this.m_motorImpulse + b, -c, c);
b = this.m_motorImpulse - a;
a = b * this.m_axis.x;
c = b * this.m_axis.y;
g = b * this.m_a1;
b = b * this.m_a2;
j.x -= this.m_invMassA * a;
j.y -= this.m_invMassA * c;
o -= this.m_invIA * g;
q.x += this.m_invMassB * a;
q.y += this.m_invMassB * c;
n += this.m_invIB * b
}
c = this.m_perp.x * (q.x - j.x) + this.m_perp.y * (q.y - j.y) + this.m_s2 * n - this.m_s1 * o;
if (this.m_enableLimit && this.m_limitState != I.e_inactiveLimit) {
g = this.m_axis.x * (q.x - j.x) + this.m_axis.y * (q.y - j.y) + this.m_a2 * n - this.m_a1 * o;
a = this.m_impulse.Copy();
d = this.m_K.Solve(new w, -c, -g);
this.m_impulse.Add(d);
if (this.m_limitState == I.e_atLowerLimit) this.m_impulse.y = y.Max(this.m_impulse.y, 0);
else if (this.m_limitState == I.e_atUpperLimit) this.m_impulse.y = y.Min(this.m_impulse.y, 0);
c = -c - (this.m_impulse.y - a.y) * this.m_K.col2.x;
g = 0;
g = this.m_K.col1.x != 0 ? c / this.m_K.col1.x + a.x : a.x;
this.m_impulse.x = g;
d.x = this.m_impulse.x - a.x;
d.y = this.m_impulse.y - a.y;
a = d.x * this.m_perp.x + d.y * this.m_axis.x;
c = d.x * this.m_perp.y + d.y * this.m_axis.y;
g = d.x * this.m_s1 + d.y * this.m_a1;
b = d.x * this.m_s2 + d.y * this.m_a2
} else {
d = 0;
d = this.m_K.col1.x != 0 ? -c / this.m_K.col1.x : 0;
this.m_impulse.x += d;
a = d * this.m_perp.x;
c = d * this.m_perp.y;
g = d * this.m_s1;
b = d * this.m_s2
}
j.x -= this.m_invMassA * a;
j.y -= this.m_invMassA * c;
o -= this.m_invIA * g;
q.x += this.m_invMassB * a;
q.y += this.m_invMassB * c;
n += this.m_invIB * b;
h.m_linearVelocity.SetV(j);
h.m_angularVelocity = o;
l.m_linearVelocity.SetV(q);
l.m_angularVelocity = n
};
k.prototype.SolvePositionConstraints = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l = d.m_sweep.c,
j = d.m_sweep.a,
o = h.m_sweep.c,
q = h.m_sweep.a,
n, a = 0,
c = 0,
g = 0,
b = 0,
e = n = 0,
f = 0;
c = false;
var m = 0,
r = G.FromAngle(j);
g = G.FromAngle(q);
n = r;
f = this.m_localAnchor1.x - this.m_localCenterA.x;
var s = this.m_localAnchor1.y - this.m_localCenterA.y;
a = n.col1.x * f + n.col2.x * s;
s = n.col1.y * f + n.col2.y * s;
f = a;
n = g;
g = this.m_localAnchor2.x - this.m_localCenterB.x;
b = this.m_localAnchor2.y - this.m_localCenterB.y;
a = n.col1.x * g + n.col2.x * b;
b = n.col1.y * g + n.col2.y * b;
g = a;
n = o.x + g - l.x - f;
a = o.y + b - l.y - s;
if (this.m_enableLimit) {
this.m_axis = y.MulMV(r, this.m_localXAxis1);
this.m_a1 = (n + f) * this.m_axis.y - (a + s) * this.m_axis.x;
this.m_a2 = g * this.m_axis.y - b * this.m_axis.x;
var v = this.m_axis.x * n + this.m_axis.y * a;
if (y.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * F.b2_linearSlop) {
m = y.Clamp(v, -F.b2_maxLinearCorrection, F.b2_maxLinearCorrection);
e = y.Abs(v);
c = true
} else if (v <= this.m_lowerTranslation) {
m = y.Clamp(v - this.m_lowerTranslation + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
e = this.m_lowerTranslation - v;
c = true
} else if (v >= this.m_upperTranslation) {
m = y.Clamp(v - this.m_upperTranslation + F.b2_linearSlop, 0, F.b2_maxLinearCorrection);
e = v - this.m_upperTranslation;
c = true
}
}
this.m_perp = y.MulMV(r, this.m_localYAxis1);
this.m_s1 = (n + f) * this.m_perp.y - (a + s) * this.m_perp.x;
this.m_s2 = g * this.m_perp.y - b * this.m_perp.x;
r = new w;
s = this.m_perp.x * n + this.m_perp.y * a;
e = y.Max(e, y.Abs(s));
f = 0;
if (c) {
c = this.m_invMassA;
g = this.m_invMassB;
b = this.m_invIA;
n = this.m_invIB;
this.m_K.col1.x = c + g + b * this.m_s1 * this.m_s1 + n * this.m_s2 * this.m_s2;
this.m_K.col1.y = b * this.m_s1 * this.m_a1 + n * this.m_s2 * this.m_a2;
this.m_K.col2.x = this.m_K.col1.y;
this.m_K.col2.y = c + g + b * this.m_a1 * this.m_a1 + n * this.m_a2 * this.m_a2;
this.m_K.Solve(r, -s, -m)
} else {
c = this.m_invMassA;
g = this.m_invMassB;
b = this.m_invIA;
n = this.m_invIB;
m = c + g + b * this.m_s1 * this.m_s1 + n * this.m_s2 * this.m_s2;
c = 0;
c = m != 0 ? -s / m : 0;
r.x = c;
r.y = 0
}
m = r.x * this.m_perp.x + r.y * this.m_axis.x;
c = r.x * this.m_perp.y + r.y * this.m_axis.y;
s = r.x * this.m_s1 + r.y * this.m_a1;
r = r.x * this.m_s2 + r.y * this.m_a2;
l.x -= this.m_invMassA * m;
l.y -= this.m_invMassA * c;
j -= this.m_invIA * s;
o.x += this.m_invMassB * m;
o.y += this.m_invMassB * c;
q += this.m_invIB * r;
d.m_sweep.a = j;
h.m_sweep.a = q;
d.SynchronizeTransform();
h.SynchronizeTransform();
return e <= F.b2_linearSlop && f <= F.b2_angularSlop
};
Box2D.inherit(z, Box2D.Dynamics.Joints.b2JointDef);
z.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
z.b2LineJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
this.localAnchorA = new w;
this.localAnchorB = new w;
this.localAxisA = new w
};
z.prototype.b2LineJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_lineJoint;
this.localAxisA.Set(1, 0);
this.enableLimit = false;
this.upperTranslation = this.lowerTranslation = 0;
this.enableMotor = false;
this.motorSpeed = this.maxMotorForce = 0
};
z.prototype.Initialize = function (d, h, l, j) {
this.bodyA = d;
this.bodyB = h;
this.localAnchorA = this.bodyA.GetLocalPoint(l);
this.localAnchorB = this.bodyB.GetLocalPoint(l);
this.localAxisA = this.bodyA.GetLocalVector(j)
};
Box2D.inherit(u, Box2D.Dynamics.Joints.b2Joint);
u.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
u.b2MouseJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.K = new G;
this.K1 = new G;
this.K2 = new G;
this.m_localAnchor = new w;
this.m_target = new w;
this.m_impulse = new w;
this.m_mass = new G;
this.m_C = new w
};
u.prototype.GetAnchorA = function () {
return this.m_target
};
u.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchor)
};
u.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * this.m_impulse.x, d * this.m_impulse.y)
};
u.prototype.GetReactionTorque = function () {
return 0
};
u.prototype.GetTarget = function () {
return this.m_target
};
u.prototype.SetTarget = function (d) {
this.m_bodyB.IsAwake() == false && this.m_bodyB.SetAwake(true);
this.m_target = d
};
u.prototype.GetMaxForce = function () {
return this.m_maxForce
};
u.prototype.SetMaxForce = function (d) {
if (d === undefined) d = 0;
this.m_maxForce = d
};
u.prototype.GetFrequency = function () {
return this.m_frequencyHz
};
u.prototype.SetFrequency = function (d) {
if (d === undefined) d = 0;
this.m_frequencyHz = d
};
u.prototype.GetDampingRatio = function () {
return this.m_dampingRatio
};
u.prototype.SetDampingRatio = function (d) {
if (d === undefined) d = 0;
this.m_dampingRatio = d
};
u.prototype.b2MouseJoint = function (d) {
this.__super.b2Joint.call(this, d);
this.m_target.SetV(d.target);
var h = this.m_target.x - this.m_bodyB.m_xf.position.x,
l = this.m_target.y - this.m_bodyB.m_xf.position.y,
j = this.m_bodyB.m_xf.R;
this.m_localAnchor.x = h * j.col1.x + l * j.col1.y;
this.m_localAnchor.y = h * j.col2.x + l * j.col2.y;
this.m_maxForce = d.maxForce;
this.m_impulse.SetZero();
this.m_frequencyHz = d.frequencyHz;
this.m_dampingRatio = d.dampingRatio;
this.m_gamma = this.m_beta = 0
};
u.prototype.InitVelocityConstraints = function (d) {
var h = this.m_bodyB,
l = h.GetMass(),
j = 2 * Math.PI * this.m_frequencyHz,
o = l * j * j;
this.m_gamma = d.dt * (2 * l * this.m_dampingRatio * j + d.dt * o);
this.m_gamma = this.m_gamma != 0 ? 1 / this.m_gamma : 0;
this.m_beta = d.dt * o * this.m_gamma;
o = h.m_xf.R;
l = this.m_localAnchor.x - h.m_sweep.localCenter.x;
j = this.m_localAnchor.y - h.m_sweep.localCenter.y;
var q = o.col1.x * l + o.col2.x * j;
j = o.col1.y * l + o.col2.y * j;
l = q;
o = h.m_invMass;
q = h.m_invI;
this.K1.col1.x = o;
this.K1.col2.x = 0;
this.K1.col1.y = 0;
this.K1.col2.y = o;
this.K2.col1.x = q * j * j;
this.K2.col2.x = -q * l * j;
this.K2.col1.y = -q * l * j;
this.K2.col2.y = q * l * l;
this.K.SetM(this.K1);
this.K.AddM(this.K2);
this.K.col1.x += this.m_gamma;
this.K.col2.y += this.m_gamma;
this.K.GetInverse(this.m_mass);
this.m_C.x = h.m_sweep.c.x + l - this.m_target.x;
this.m_C.y = h.m_sweep.c.y + j - this.m_target.y;
h.m_angularVelocity *= 0.98;
this.m_impulse.x *= d.dtRatio;
this.m_impulse.y *= d.dtRatio;
h.m_linearVelocity.x += o * this.m_impulse.x;
h.m_linearVelocity.y += o * this.m_impulse.y;
h.m_angularVelocity += q * (l * this.m_impulse.y - j * this.m_impulse.x)
};
u.prototype.SolveVelocityConstraints = function (d) {
var h = this.m_bodyB,
l, j = 0,
o = 0;
l = h.m_xf.R;
var q = this.m_localAnchor.x - h.m_sweep.localCenter.x,
n = this.m_localAnchor.y - h.m_sweep.localCenter.y;
j = l.col1.x * q + l.col2.x * n;
n = l.col1.y * q + l.col2.y * n;
q = j;
j = h.m_linearVelocity.x + -h.m_angularVelocity * n;
var a = h.m_linearVelocity.y + h.m_angularVelocity * q;
l = this.m_mass;
j = j + this.m_beta * this.m_C.x + this.m_gamma * this.m_impulse.x;
o = a + this.m_beta * this.m_C.y + this.m_gamma * this.m_impulse.y;
a = -(l.col1.x * j + l.col2.x * o);
o = -(l.col1.y * j + l.col2.y * o);
l = this.m_impulse.x;
j = this.m_impulse.y;
this.m_impulse.x += a;
this.m_impulse.y += o;
d = d.dt * this.m_maxForce;
this.m_impulse.LengthSquared() > d * d && this.m_impulse.Multiply(d / this.m_impulse.Length());
a = this.m_impulse.x - l;
o = this.m_impulse.y - j;
h.m_linearVelocity.x += h.m_invMass * a;
h.m_linearVelocity.y += h.m_invMass * o;
h.m_angularVelocity += h.m_invI * (q * o - n * a)
};
u.prototype.SolvePositionConstraints = function () {
return true
};
Box2D.inherit(D, Box2D.Dynamics.Joints.b2JointDef);
D.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
D.b2MouseJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this,
arguments);
this.target = new w
};
D.prototype.b2MouseJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_mouseJoint;
this.maxForce = 0;
this.frequencyHz = 5;
this.dampingRatio = 0.7
};
Box2D.inherit(H, Box2D.Dynamics.Joints.b2Joint);
H.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
H.b2PrismaticJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.m_localAnchor1 = new w;
this.m_localAnchor2 = new w;
this.m_localXAxis1 = new w;
this.m_localYAxis1 = new w;
this.m_axis = new w;
this.m_perp = new w;
this.m_K = new K;
this.m_impulse = new A
};
H.prototype.GetAnchorA = function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
};
H.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
};
H.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * (this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.x), d * (this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.y))
};
H.prototype.GetReactionTorque = function (d) {
if (d === undefined) d = 0;
return d * this.m_impulse.y
};
H.prototype.GetJointTranslation = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l = d.GetWorldPoint(this.m_localAnchor1),
j = h.GetWorldPoint(this.m_localAnchor2);
h = j.x - l.x;
l = j.y - l.y;
d = d.GetWorldVector(this.m_localXAxis1);
return d.x * h + d.y * l
};
H.prototype.GetJointSpeed = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l;
l = d.m_xf.R;
var j = this.m_localAnchor1.x - d.m_sweep.localCenter.x,
o = this.m_localAnchor1.y - d.m_sweep.localCenter.y,
q = l.col1.x * j + l.col2.x * o;
o = l.col1.y * j + l.col2.y * o;
j = q;
l = h.m_xf.R;
var n = this.m_localAnchor2.x - h.m_sweep.localCenter.x,
a = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
q = l.col1.x * n + l.col2.x * a;
a = l.col1.y * n + l.col2.y * a;
n = q;
l = h.m_sweep.c.x + n - (d.m_sweep.c.x + j);
q = h.m_sweep.c.y + a - (d.m_sweep.c.y + o);
var c = d.GetWorldVector(this.m_localXAxis1),
g = d.m_linearVelocity,
b = h.m_linearVelocity;
d = d.m_angularVelocity;
h = h.m_angularVelocity;
return l * -d * c.y + q * d * c.x + (c.x * (b.x + -h * a - g.x - -d * o) + c.y * (b.y + h * n - g.y - d * j))
};
H.prototype.IsLimitEnabled = function () {
return this.m_enableLimit
};
H.prototype.EnableLimit = function (d) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableLimit = d
};
H.prototype.GetLowerLimit = function () {
return this.m_lowerTranslation
};
H.prototype.GetUpperLimit = function () {
return this.m_upperTranslation
};
H.prototype.SetLimits = function (d, h) {
if (d === undefined) d = 0;
if (h === undefined) h = 0;
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_lowerTranslation = d;
this.m_upperTranslation = h
};
H.prototype.IsMotorEnabled = function () {
return this.m_enableMotor
};
H.prototype.EnableMotor = function (d) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableMotor = d
};
H.prototype.SetMotorSpeed = function (d) {
if (d === undefined) d = 0;
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_motorSpeed = d
};
H.prototype.GetMotorSpeed = function () {
return this.m_motorSpeed
};
H.prototype.SetMaxMotorForce = function (d) {
if (d === undefined) d = 0;
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_maxMotorForce = d
};
H.prototype.GetMotorForce = function () {
return this.m_motorImpulse
};
H.prototype.b2PrismaticJoint = function (d) {
this.__super.b2Joint.call(this, d);
this.m_localAnchor1.SetV(d.localAnchorA);
this.m_localAnchor2.SetV(d.localAnchorB);
this.m_localXAxis1.SetV(d.localAxisA);
this.m_localYAxis1.x = -this.m_localXAxis1.y;
this.m_localYAxis1.y = this.m_localXAxis1.x;
this.m_refAngle = d.referenceAngle;
this.m_impulse.SetZero();
this.m_motorImpulse = this.m_motorMass = 0;
this.m_lowerTranslation = d.lowerTranslation;
this.m_upperTranslation = d.upperTranslation;
this.m_maxMotorForce = d.maxMotorForce;
this.m_motorSpeed = d.motorSpeed;
this.m_enableLimit = d.enableLimit;
this.m_enableMotor = d.enableMotor;
this.m_limitState = I.e_inactiveLimit;
this.m_axis.SetZero();
this.m_perp.SetZero()
};
H.prototype.InitVelocityConstraints = function (d) {
var h = this.m_bodyA,
l = this.m_bodyB,
j, o = 0;
this.m_localCenterA.SetV(h.GetLocalCenter());
this.m_localCenterB.SetV(l.GetLocalCenter());
var q = h.GetTransform();
l.GetTransform();
j = h.m_xf.R;
var n = this.m_localAnchor1.x - this.m_localCenterA.x,
a = this.m_localAnchor1.y - this.m_localCenterA.y;
o = j.col1.x * n + j.col2.x * a;
a = j.col1.y * n + j.col2.y * a;
n = o;
j = l.m_xf.R;
var c = this.m_localAnchor2.x - this.m_localCenterB.x,
g = this.m_localAnchor2.y - this.m_localCenterB.y;
o = j.col1.x * c + j.col2.x * g;
g = j.col1.y * c + j.col2.y * g;
c = o;
j = l.m_sweep.c.x + c - h.m_sweep.c.x - n;
o = l.m_sweep.c.y + g - h.m_sweep.c.y - a;
this.m_invMassA = h.m_invMass;
this.m_invMassB = l.m_invMass;
this.m_invIA = h.m_invI;
this.m_invIB = l.m_invI;
this.m_axis.SetV(y.MulMV(q.R, this.m_localXAxis1));
this.m_a1 = (j + n) * this.m_axis.y - (o + a) * this.m_axis.x;
this.m_a2 = c * this.m_axis.y - g * this.m_axis.x;
this.m_motorMass = this.m_invMassA + this.m_invMassB + this.m_invIA * this.m_a1 * this.m_a1 + this.m_invIB * this.m_a2 * this.m_a2;
if (this.m_motorMass > Number.MIN_VALUE) this.m_motorMass = 1 / this.m_motorMass;
this.m_perp.SetV(y.MulMV(q.R, this.m_localYAxis1));
this.m_s1 = (j + n) * this.m_perp.y - (o + a) * this.m_perp.x;
this.m_s2 = c * this.m_perp.y - g * this.m_perp.x;
q = this.m_invMassA;
n = this.m_invMassB;
a = this.m_invIA;
c = this.m_invIB;
this.m_K.col1.x = q + n + a * this.m_s1 * this.m_s1 + c * this.m_s2 * this.m_s2;
this.m_K.col1.y = a * this.m_s1 + c * this.m_s2;
this.m_K.col1.z = a * this.m_s1 * this.m_a1 + c * this.m_s2 * this.m_a2;
this.m_K.col2.x = this.m_K.col1.y;
this.m_K.col2.y = a + c;
this.m_K.col2.z = a * this.m_a1 + c * this.m_a2;
this.m_K.col3.x = this.m_K.col1.z;
this.m_K.col3.y = this.m_K.col2.z;
this.m_K.col3.z = q + n + a * this.m_a1 * this.m_a1 + c * this.m_a2 * this.m_a2;
if (this.m_enableLimit) {
j = this.m_axis.x * j + this.m_axis.y * o;
if (y.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * F.b2_linearSlop) this.m_limitState = I.e_equalLimits;
else if (j <= this.m_lowerTranslation) {
if (this.m_limitState != I.e_atLowerLimit) {
this.m_limitState = I.e_atLowerLimit;
this.m_impulse.z = 0
}
} else if (j >= this.m_upperTranslation) {
if (this.m_limitState != I.e_atUpperLimit) {
this.m_limitState = I.e_atUpperLimit;
this.m_impulse.z = 0
}
} else {
this.m_limitState = I.e_inactiveLimit;
this.m_impulse.z = 0
}
} else this.m_limitState = I.e_inactiveLimit; if (this.m_enableMotor == false) this.m_motorImpulse = 0;
if (d.warmStarting) {
this.m_impulse.x *= d.dtRatio;
this.m_impulse.y *= d.dtRatio;
this.m_motorImpulse *= d.dtRatio;
d = this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.x;
j = this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.y;
o = this.m_impulse.x * this.m_s1 + this.m_impulse.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_a1;
q = this.m_impulse.x * this.m_s2 + this.m_impulse.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_a2;
h.m_linearVelocity.x -= this.m_invMassA * d;
h.m_linearVelocity.y -= this.m_invMassA * j;
h.m_angularVelocity -= this.m_invIA * o;
l.m_linearVelocity.x += this.m_invMassB * d;
l.m_linearVelocity.y += this.m_invMassB * j;
l.m_angularVelocity += this.m_invIB * q
} else {
this.m_impulse.SetZero();
this.m_motorImpulse = 0
}
};
H.prototype.SolveVelocityConstraints = function (d) {
var h = this.m_bodyA,
l = this.m_bodyB,
j = h.m_linearVelocity,
o = h.m_angularVelocity,
q = l.m_linearVelocity,
n = l.m_angularVelocity,
a = 0,
c = 0,
g = 0,
b = 0;
if (this.m_enableMotor && this.m_limitState != I.e_equalLimits) {
b = this.m_motorMass * (this.m_motorSpeed - (this.m_axis.x * (q.x - j.x) + this.m_axis.y * (q.y - j.y) + this.m_a2 * n - this.m_a1 * o));
a = this.m_motorImpulse;
d = d.dt * this.m_maxMotorForce;
this.m_motorImpulse = y.Clamp(this.m_motorImpulse + b, -d, d);
b = this.m_motorImpulse - a;
a = b * this.m_axis.x;
c = b * this.m_axis.y;
g = b * this.m_a1;
b = b * this.m_a2;
j.x -= this.m_invMassA * a;
j.y -= this.m_invMassA * c;
o -= this.m_invIA * g;
q.x += this.m_invMassB * a;
q.y += this.m_invMassB * c;
n += this.m_invIB * b
}
g = this.m_perp.x * (q.x - j.x) + this.m_perp.y * (q.y - j.y) + this.m_s2 * n - this.m_s1 * o;
c = n - o;
if (this.m_enableLimit && this.m_limitState != I.e_inactiveLimit) {
d = this.m_axis.x * (q.x - j.x) + this.m_axis.y * (q.y - j.y) + this.m_a2 * n - this.m_a1 * o;
a = this.m_impulse.Copy();
d = this.m_K.Solve33(new A, -g, -c, -d);
this.m_impulse.Add(d);
if (this.m_limitState == I.e_atLowerLimit) this.m_impulse.z = y.Max(this.m_impulse.z, 0);
else if (this.m_limitState == I.e_atUpperLimit) this.m_impulse.z = y.Min(this.m_impulse.z, 0);
g = -g - (this.m_impulse.z - a.z) * this.m_K.col3.x;
c = -c - (this.m_impulse.z - a.z) * this.m_K.col3.y;
c = this.m_K.Solve22(new w, g, c);
c.x += a.x;
c.y += a.y;
this.m_impulse.x = c.x;
this.m_impulse.y = c.y;
d.x = this.m_impulse.x - a.x;
d.y = this.m_impulse.y - a.y;
d.z = this.m_impulse.z - a.z;
a = d.x * this.m_perp.x + d.z * this.m_axis.x;
c = d.x * this.m_perp.y + d.z * this.m_axis.y;
g = d.x * this.m_s1 + d.y + d.z * this.m_a1;
b = d.x * this.m_s2 + d.y + d.z * this.m_a2
} else {
d = this.m_K.Solve22(new w, -g, -c);
this.m_impulse.x += d.x;
this.m_impulse.y += d.y;
a = d.x * this.m_perp.x;
c = d.x * this.m_perp.y;
g = d.x * this.m_s1 + d.y;
b = d.x * this.m_s2 + d.y
}
j.x -= this.m_invMassA * a;
j.y -= this.m_invMassA * c;
o -= this.m_invIA * g;
q.x += this.m_invMassB * a;
q.y += this.m_invMassB * c;
n += this.m_invIB * b;
h.m_linearVelocity.SetV(j);
h.m_angularVelocity = o;
l.m_linearVelocity.SetV(q);
l.m_angularVelocity = n
};
H.prototype.SolvePositionConstraints = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l = d.m_sweep.c,
j = d.m_sweep.a,
o = h.m_sweep.c,
q = h.m_sweep.a,
n, a = 0,
c = 0,
g = 0,
b = a = n = 0,
e = 0;
c = false;
var f = 0,
m = G.FromAngle(j),
r = G.FromAngle(q);
n = m;
e = this.m_localAnchor1.x - this.m_localCenterA.x;
var s = this.m_localAnchor1.y - this.m_localCenterA.y;
a = n.col1.x * e + n.col2.x * s;
s = n.col1.y * e + n.col2.y * s;
e = a;
n = r;
r = this.m_localAnchor2.x - this.m_localCenterB.x;
g = this.m_localAnchor2.y - this.m_localCenterB.y;
a = n.col1.x * r + n.col2.x * g;
g = n.col1.y * r + n.col2.y * g;
r = a;
n = o.x + r - l.x - e;
a = o.y + g - l.y - s;
if (this.m_enableLimit) {
this.m_axis = y.MulMV(m, this.m_localXAxis1);
this.m_a1 = (n + e) * this.m_axis.y - (a + s) * this.m_axis.x;
this.m_a2 = r * this.m_axis.y - g * this.m_axis.x;
var v = this.m_axis.x * n + this.m_axis.y * a;
if (y.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * F.b2_linearSlop) {
f = y.Clamp(v, -F.b2_maxLinearCorrection, F.b2_maxLinearCorrection);
b = y.Abs(v);
c = true
} else if (v <= this.m_lowerTranslation) {
f = y.Clamp(v - this.m_lowerTranslation + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
b = this.m_lowerTranslation - v;
c = true
} else if (v >= this.m_upperTranslation) {
f = y.Clamp(v - this.m_upperTranslation + F.b2_linearSlop, 0, F.b2_maxLinearCorrection);
b = v - this.m_upperTranslation;
c = true
}
}
this.m_perp = y.MulMV(m, this.m_localYAxis1);
this.m_s1 = (n + e) * this.m_perp.y - (a + s) * this.m_perp.x;
this.m_s2 = r * this.m_perp.y - g * this.m_perp.x;
m = new A;
s = this.m_perp.x * n + this.m_perp.y * a;
r = q - j - this.m_refAngle;
b = y.Max(b, y.Abs(s));
e = y.Abs(r);
if (c) {
c = this.m_invMassA;
g = this.m_invMassB;
n = this.m_invIA;
a = this.m_invIB;
this.m_K.col1.x = c + g + n * this.m_s1 * this.m_s1 + a * this.m_s2 * this.m_s2;
this.m_K.col1.y = n * this.m_s1 + a * this.m_s2;
this.m_K.col1.z = n * this.m_s1 * this.m_a1 + a * this.m_s2 * this.m_a2;
this.m_K.col2.x = this.m_K.col1.y;
this.m_K.col2.y = n + a;
this.m_K.col2.z = n * this.m_a1 + a * this.m_a2;
this.m_K.col3.x = this.m_K.col1.z;
this.m_K.col3.y = this.m_K.col2.z;
this.m_K.col3.z = c + g + n * this.m_a1 * this.m_a1 + a * this.m_a2 * this.m_a2;
this.m_K.Solve33(m, -s, -r, -f)
} else {
c = this.m_invMassA;
g = this.m_invMassB;
n = this.m_invIA;
a = this.m_invIB;
f = n * this.m_s1 + a * this.m_s2;
v = n + a;
this.m_K.col1.Set(c + g + n * this.m_s1 * this.m_s1 + a * this.m_s2 * this.m_s2, f, 0);
this.m_K.col2.Set(f,
v, 0);
f = this.m_K.Solve22(new w, -s, -r);
m.x = f.x;
m.y = f.y;
m.z = 0
}
f = m.x * this.m_perp.x + m.z * this.m_axis.x;
c = m.x * this.m_perp.y + m.z * this.m_axis.y;
s = m.x * this.m_s1 + m.y + m.z * this.m_a1;
m = m.x * this.m_s2 + m.y + m.z * this.m_a2;
l.x -= this.m_invMassA * f;
l.y -= this.m_invMassA * c;
j -= this.m_invIA * s;
o.x += this.m_invMassB * f;
o.y += this.m_invMassB * c;
q += this.m_invIB * m;
d.m_sweep.a = j;
h.m_sweep.a = q;
d.SynchronizeTransform();
h.SynchronizeTransform();
return b <= F.b2_linearSlop && e <= F.b2_angularSlop
};
Box2D.inherit(O, Box2D.Dynamics.Joints.b2JointDef);
O.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
O.b2PrismaticJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
this.localAnchorA = new w;
this.localAnchorB = new w;
this.localAxisA = new w
};
O.prototype.b2PrismaticJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_prismaticJoint;
this.localAxisA.Set(1, 0);
this.referenceAngle = 0;
this.enableLimit = false;
this.upperTranslation = this.lowerTranslation = 0;
this.enableMotor = false;
this.motorSpeed = this.maxMotorForce = 0
};
O.prototype.Initialize = function (d, h, l, j) {
this.bodyA = d;
this.bodyB = h;
this.localAnchorA = this.bodyA.GetLocalPoint(l);
this.localAnchorB = this.bodyB.GetLocalPoint(l);
this.localAxisA = this.bodyA.GetLocalVector(j);
this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle()
};
Box2D.inherit(E, Box2D.Dynamics.Joints.b2Joint);
E.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
E.b2PulleyJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.m_groundAnchor1 = new w;
this.m_groundAnchor2 = new w;
this.m_localAnchor1 = new w;
this.m_localAnchor2 = new w;
this.m_u1 = new w;
this.m_u2 = new w
};
E.prototype.GetAnchorA = function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
};
E.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
};
E.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * this.m_impulse * this.m_u2.x, d * this.m_impulse * this.m_u2.y)
};
E.prototype.GetReactionTorque = function () {
return 0
};
E.prototype.GetGroundAnchorA = function () {
var d = this.m_ground.m_xf.position.Copy();
d.Add(this.m_groundAnchor1);
return d
};
E.prototype.GetGroundAnchorB = function () {
var d = this.m_ground.m_xf.position.Copy();
d.Add(this.m_groundAnchor2);
return d
};
E.prototype.GetLength1 = function () {
var d = this.m_bodyA.GetWorldPoint(this.m_localAnchor1),
h = d.x - (this.m_ground.m_xf.position.x + this.m_groundAnchor1.x);
d = d.y - (this.m_ground.m_xf.position.y + this.m_groundAnchor1.y);
return Math.sqrt(h * h + d * d)
};
E.prototype.GetLength2 = function () {
var d = this.m_bodyB.GetWorldPoint(this.m_localAnchor2),
h = d.x - (this.m_ground.m_xf.position.x + this.m_groundAnchor2.x);
d = d.y - (this.m_ground.m_xf.position.y + this.m_groundAnchor2.y);
return Math.sqrt(h * h + d * d)
};
E.prototype.GetRatio = function () {
return this.m_ratio
};
E.prototype.b2PulleyJoint = function (d) {
this.__super.b2Joint.call(this, d);
this.m_ground = this.m_bodyA.m_world.m_groundBody;
this.m_groundAnchor1.x = d.groundAnchorA.x - this.m_ground.m_xf.position.x;
this.m_groundAnchor1.y = d.groundAnchorA.y - this.m_ground.m_xf.position.y;
this.m_groundAnchor2.x = d.groundAnchorB.x - this.m_ground.m_xf.position.x;
this.m_groundAnchor2.y = d.groundAnchorB.y - this.m_ground.m_xf.position.y;
this.m_localAnchor1.SetV(d.localAnchorA);
this.m_localAnchor2.SetV(d.localAnchorB);
this.m_ratio = d.ratio;
this.m_constant = d.lengthA + this.m_ratio * d.lengthB;
this.m_maxLength1 = y.Min(d.maxLengthA, this.m_constant - this.m_ratio * E.b2_minPulleyLength);
this.m_maxLength2 = y.Min(d.maxLengthB, (this.m_constant - E.b2_minPulleyLength) / this.m_ratio);
this.m_limitImpulse2 = this.m_limitImpulse1 = this.m_impulse = 0
};
E.prototype.InitVelocityConstraints = function (d) {
var h = this.m_bodyA,
l = this.m_bodyB,
j;
j = h.m_xf.R;
var o = this.m_localAnchor1.x - h.m_sweep.localCenter.x,
q = this.m_localAnchor1.y - h.m_sweep.localCenter.y,
n = j.col1.x * o + j.col2.x * q;
q = j.col1.y * o + j.col2.y * q;
o = n;
j = l.m_xf.R;
var a = this.m_localAnchor2.x - l.m_sweep.localCenter.x,
c = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
n = j.col1.x * a + j.col2.x * c;
c = j.col1.y * a + j.col2.y * c;
a = n;
j = l.m_sweep.c.x + a;
n = l.m_sweep.c.y + c;
var g = this.m_ground.m_xf.position.x + this.m_groundAnchor2.x,
b = this.m_ground.m_xf.position.y + this.m_groundAnchor2.y;
this.m_u1.Set(h.m_sweep.c.x + o - (this.m_ground.m_xf.position.x + this.m_groundAnchor1.x), h.m_sweep.c.y + q - (this.m_ground.m_xf.position.y + this.m_groundAnchor1.y));
this.m_u2.Set(j - g, n - b);
j = this.m_u1.Length();
n = this.m_u2.Length();
j > F.b2_linearSlop ? this.m_u1.Multiply(1 / j) : this.m_u1.SetZero();
n > F.b2_linearSlop ? this.m_u2.Multiply(1 / n) : this.m_u2.SetZero();
if (this.m_constant - j - this.m_ratio * n > 0) {
this.m_state = I.e_inactiveLimit;
this.m_impulse = 0
} else this.m_state = I.e_atUpperLimit; if (j < this.m_maxLength1) {
this.m_limitState1 = I.e_inactiveLimit;
this.m_limitImpulse1 = 0
} else this.m_limitState1 = I.e_atUpperLimit; if (n < this.m_maxLength2) {
this.m_limitState2 = I.e_inactiveLimit;
this.m_limitImpulse2 = 0
} else this.m_limitState2 = I.e_atUpperLimit;
j = o * this.m_u1.y - q * this.m_u1.x;
n = a * this.m_u2.y - c * this.m_u2.x;
this.m_limitMass1 = h.m_invMass + h.m_invI * j * j;
this.m_limitMass2 = l.m_invMass + l.m_invI * n * n;
this.m_pulleyMass = this.m_limitMass1 + this.m_ratio * this.m_ratio * this.m_limitMass2;
this.m_limitMass1 = 1 / this.m_limitMass1;
this.m_limitMass2 = 1 / this.m_limitMass2;
this.m_pulleyMass = 1 / this.m_pulleyMass;
if (d.warmStarting) {
this.m_impulse *= d.dtRatio;
this.m_limitImpulse1 *= d.dtRatio;
this.m_limitImpulse2 *= d.dtRatio;
d = (-this.m_impulse - this.m_limitImpulse1) * this.m_u1.x;
j = (-this.m_impulse - this.m_limitImpulse1) * this.m_u1.y;
n = (-this.m_ratio * this.m_impulse - this.m_limitImpulse2) * this.m_u2.x;
g = (-this.m_ratio * this.m_impulse - this.m_limitImpulse2) * this.m_u2.y;
h.m_linearVelocity.x += h.m_invMass * d;
h.m_linearVelocity.y += h.m_invMass * j;
h.m_angularVelocity += h.m_invI * (o * j - q * d);
l.m_linearVelocity.x += l.m_invMass * n;
l.m_linearVelocity.y += l.m_invMass * g;
l.m_angularVelocity += l.m_invI * (a * g - c * n)
} else this.m_limitImpulse2 = this.m_limitImpulse1 = this.m_impulse = 0
};
E.prototype.SolveVelocityConstraints = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l;
l = d.m_xf.R;
var j = this.m_localAnchor1.x - d.m_sweep.localCenter.x,
o = this.m_localAnchor1.y - d.m_sweep.localCenter.y,
q = l.col1.x * j + l.col2.x * o;
o = l.col1.y * j + l.col2.y * o;
j = q;
l = h.m_xf.R;
var n = this.m_localAnchor2.x - h.m_sweep.localCenter.x,
a = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
q = l.col1.x * n + l.col2.x * a;
a = l.col1.y * n + l.col2.y * a;
n = q;
var c = q = l = 0,
g = 0;
l = g = l = g = c = q = l = 0;
if (this.m_state == I.e_atUpperLimit) {
l = d.m_linearVelocity.x + -d.m_angularVelocity * o;
q = d.m_linearVelocity.y + d.m_angularVelocity * j;
c = h.m_linearVelocity.x + -h.m_angularVelocity * a;
g = h.m_linearVelocity.y + h.m_angularVelocity * n;
l = -(this.m_u1.x * l + this.m_u1.y * q) - this.m_ratio * (this.m_u2.x * c + this.m_u2.y * g);
g = this.m_pulleyMass * -l;
l = this.m_impulse;
this.m_impulse = y.Max(0, this.m_impulse + g);
g = this.m_impulse - l;
l = -g * this.m_u1.x;
q = -g * this.m_u1.y;
c = -this.m_ratio * g * this.m_u2.x;
g = -this.m_ratio * g * this.m_u2.y;
d.m_linearVelocity.x += d.m_invMass * l;
d.m_linearVelocity.y += d.m_invMass * q;
d.m_angularVelocity += d.m_invI * (j * q - o * l);
h.m_linearVelocity.x += h.m_invMass * c;
h.m_linearVelocity.y += h.m_invMass * g;
h.m_angularVelocity += h.m_invI * (n * g - a * c)
}
if (this.m_limitState1 == I.e_atUpperLimit) {
l = d.m_linearVelocity.x + -d.m_angularVelocity * o;
q = d.m_linearVelocity.y + d.m_angularVelocity * j;
l = -(this.m_u1.x * l + this.m_u1.y * q);
g = -this.m_limitMass1 * l;
l = this.m_limitImpulse1;
this.m_limitImpulse1 = y.Max(0, this.m_limitImpulse1 + g);
g = this.m_limitImpulse1 - l;
l = -g * this.m_u1.x;
q = -g * this.m_u1.y;
d.m_linearVelocity.x += d.m_invMass * l;
d.m_linearVelocity.y += d.m_invMass * q;
d.m_angularVelocity += d.m_invI * (j * q - o * l)
}
if (this.m_limitState2 == I.e_atUpperLimit) {
c = h.m_linearVelocity.x + -h.m_angularVelocity * a;
g = h.m_linearVelocity.y + h.m_angularVelocity * n;
l = -(this.m_u2.x * c + this.m_u2.y * g);
g = -this.m_limitMass2 * l;
l = this.m_limitImpulse2;
this.m_limitImpulse2 = y.Max(0, this.m_limitImpulse2 + g);
g = this.m_limitImpulse2 - l;
c = -g * this.m_u2.x;
g = -g * this.m_u2.y;
h.m_linearVelocity.x += h.m_invMass * c;
h.m_linearVelocity.y += h.m_invMass * g;
h.m_angularVelocity += h.m_invI * (n * g - a * c)
}
};
E.prototype.SolvePositionConstraints = function () {
var d = this.m_bodyA,
h = this.m_bodyB,
l, j = this.m_ground.m_xf.position.x + this.m_groundAnchor1.x,
o = this.m_ground.m_xf.position.y + this.m_groundAnchor1.y,
q = this.m_ground.m_xf.position.x + this.m_groundAnchor2.x,
n = this.m_ground.m_xf.position.y + this.m_groundAnchor2.y,
a = 0,
c = 0,
g = 0,
b = 0,
e = l = 0,
f = 0,
m = 0,
r = e = m = l = e = l = 0;
if (this.m_state == I.e_atUpperLimit) {
l = d.m_xf.R;
a = this.m_localAnchor1.x - d.m_sweep.localCenter.x;
c = this.m_localAnchor1.y - d.m_sweep.localCenter.y;
e = l.col1.x * a + l.col2.x * c;
c = l.col1.y * a + l.col2.y * c;
a = e;
l = h.m_xf.R;
g = this.m_localAnchor2.x - h.m_sweep.localCenter.x;
b = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
e = l.col1.x * g + l.col2.x * b;
b = l.col1.y * g + l.col2.y * b;
g = e;
l = d.m_sweep.c.x + a;
e = d.m_sweep.c.y + c;
f = h.m_sweep.c.x + g;
m = h.m_sweep.c.y + b;
this.m_u1.Set(l - j, e - o);
this.m_u2.Set(f - q, m - n);
l = this.m_u1.Length();
e = this.m_u2.Length();
l > F.b2_linearSlop ? this.m_u1.Multiply(1 / l) : this.m_u1.SetZero();
e > F.b2_linearSlop ? this.m_u2.Multiply(1 / e) : this.m_u2.SetZero();
l = this.m_constant - l - this.m_ratio * e;
r = y.Max(r, -l);
l = y.Clamp(l + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
m = -this.m_pulleyMass * l;
l = -m * this.m_u1.x;
e = -m * this.m_u1.y;
f = -this.m_ratio * m * this.m_u2.x;
m = -this.m_ratio * m * this.m_u2.y;
d.m_sweep.c.x += d.m_invMass * l;
d.m_sweep.c.y += d.m_invMass * e;
d.m_sweep.a += d.m_invI * (a * e - c * l);
h.m_sweep.c.x += h.m_invMass * f;
h.m_sweep.c.y += h.m_invMass * m;
h.m_sweep.a += h.m_invI * (g * m - b * f);
d.SynchronizeTransform();
h.SynchronizeTransform()
}
if (this.m_limitState1 == I.e_atUpperLimit) {
l = d.m_xf.R;
a = this.m_localAnchor1.x - d.m_sweep.localCenter.x;
c = this.m_localAnchor1.y - d.m_sweep.localCenter.y;
e = l.col1.x * a + l.col2.x * c;
c = l.col1.y * a + l.col2.y * c;
a = e;
l = d.m_sweep.c.x + a;
e = d.m_sweep.c.y + c;
this.m_u1.Set(l - j, e - o);
l = this.m_u1.Length();
if (l > F.b2_linearSlop) {
this.m_u1.x *= 1 / l;
this.m_u1.y *= 1 / l
} else this.m_u1.SetZero();
l = this.m_maxLength1 - l;
r = y.Max(r, -l);
l = y.Clamp(l + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
m = -this.m_limitMass1 * l;
l = -m * this.m_u1.x;
e = -m * this.m_u1.y;
d.m_sweep.c.x += d.m_invMass * l;
d.m_sweep.c.y += d.m_invMass * e;
d.m_sweep.a += d.m_invI * (a * e - c * l);
d.SynchronizeTransform()
}
if (this.m_limitState2 == I.e_atUpperLimit) {
l = h.m_xf.R;
g = this.m_localAnchor2.x - h.m_sweep.localCenter.x;
b = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
e = l.col1.x * g + l.col2.x * b;
b = l.col1.y * g + l.col2.y * b;
g = e;
f = h.m_sweep.c.x + g;
m = h.m_sweep.c.y + b;
this.m_u2.Set(f - q, m - n);
e = this.m_u2.Length();
if (e > F.b2_linearSlop) {
this.m_u2.x *= 1 / e;
this.m_u2.y *= 1 / e
} else this.m_u2.SetZero();
l = this.m_maxLength2 - e;
r = y.Max(r, -l);
l = y.Clamp(l + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
m = -this.m_limitMass2 * l;
f = -m * this.m_u2.x;
m = -m * this.m_u2.y;
h.m_sweep.c.x += h.m_invMass * f;
h.m_sweep.c.y += h.m_invMass * m;
h.m_sweep.a += h.m_invI * (g * m - b * f);
h.SynchronizeTransform()
}
return r < F.b2_linearSlop
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.Joints.b2PulleyJoint.b2_minPulleyLength = 2
});
Box2D.inherit(R, Box2D.Dynamics.Joints.b2JointDef);
R.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
R.b2PulleyJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
this.groundAnchorA = new w;
this.groundAnchorB = new w;
this.localAnchorA = new w;
this.localAnchorB = new w
};
R.prototype.b2PulleyJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_pulleyJoint;
this.groundAnchorA.Set(-1, 1);
this.groundAnchorB.Set(1, 1);
this.localAnchorA.Set(-1, 0);
this.localAnchorB.Set(1, 0);
this.maxLengthB = this.lengthB = this.maxLengthA = this.lengthA = 0;
this.ratio = 1;
this.collideConnected = true
};
R.prototype.Initialize = function (d, h, l, j, o, q, n) {
if (n === undefined) n = 0;
this.bodyA = d;
this.bodyB = h;
this.groundAnchorA.SetV(l);
this.groundAnchorB.SetV(j);
this.localAnchorA = this.bodyA.GetLocalPoint(o);
this.localAnchorB = this.bodyB.GetLocalPoint(q);
d = o.x - l.x;
l = o.y - l.y;
this.lengthA = Math.sqrt(d * d + l * l);
l = q.x - j.x;
j = q.y - j.y;
this.lengthB = Math.sqrt(l * l + j * j);
this.ratio = n;
n = this.lengthA + this.ratio * this.lengthB;
this.maxLengthA = n - this.ratio * E.b2_minPulleyLength;
this.maxLengthB = (n - E.b2_minPulleyLength) / this.ratio
};
Box2D.inherit(N, Box2D.Dynamics.Joints.b2Joint);
N.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
N.b2RevoluteJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.K = new G;
this.K1 = new G;
this.K2 = new G;
this.K3 = new G;
this.impulse3 = new A;
this.impulse2 = new w;
this.reduced = new w;
this.m_localAnchor1 = new w;
this.m_localAnchor2 = new w;
this.m_impulse = new A;
this.m_mass = new K
};
N.prototype.GetAnchorA = function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
};
N.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
};
N.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * this.m_impulse.x, d * this.m_impulse.y)
};
N.prototype.GetReactionTorque = function (d) {
if (d === undefined) d = 0;
return d * this.m_impulse.z
};
N.prototype.GetJointAngle = function () {
return this.m_bodyB.m_sweep.a - this.m_bodyA.m_sweep.a - this.m_referenceAngle
};
N.prototype.GetJointSpeed = function () {
return this.m_bodyB.m_angularVelocity - this.m_bodyA.m_angularVelocity
};
N.prototype.IsLimitEnabled = function () {
return this.m_enableLimit
};
N.prototype.EnableLimit = function (d) {
this.m_enableLimit = d
};
N.prototype.GetLowerLimit = function () {
return this.m_lowerAngle
};
N.prototype.GetUpperLimit = function () {
return this.m_upperAngle
};
N.prototype.SetLimits = function (d, h) {
if (d === undefined) d = 0;
if (h === undefined) h = 0;
this.m_lowerAngle = d;
this.m_upperAngle = h
};
N.prototype.IsMotorEnabled = function () {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
return this.m_enableMotor
};
N.prototype.EnableMotor = function (d) {
this.m_enableMotor = d
};
N.prototype.SetMotorSpeed = function (d) {
if (d === undefined) d = 0;
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_motorSpeed = d
};
N.prototype.GetMotorSpeed = function () {
return this.m_motorSpeed
};
N.prototype.SetMaxMotorTorque = function (d) {
if (d === undefined) d = 0;
this.m_maxMotorTorque = d
};
N.prototype.GetMotorTorque = function () {
return this.m_maxMotorTorque
};
N.prototype.b2RevoluteJoint = function (d) {
this.__super.b2Joint.call(this, d);
this.m_localAnchor1.SetV(d.localAnchorA);
this.m_localAnchor2.SetV(d.localAnchorB);
this.m_referenceAngle = d.referenceAngle;
this.m_impulse.SetZero();
this.m_motorImpulse = 0;
this.m_lowerAngle = d.lowerAngle;
this.m_upperAngle = d.upperAngle;
this.m_maxMotorTorque = d.maxMotorTorque;
this.m_motorSpeed = d.motorSpeed;
this.m_enableLimit = d.enableLimit;
this.m_enableMotor = d.enableMotor;
this.m_limitState = I.e_inactiveLimit
};
N.prototype.InitVelocityConstraints = function (d) {
var h = this.m_bodyA,
l = this.m_bodyB,
j, o = 0;
j = h.m_xf.R;
var q = this.m_localAnchor1.x - h.m_sweep.localCenter.x,
n = this.m_localAnchor1.y - h.m_sweep.localCenter.y;
o = j.col1.x * q + j.col2.x * n;
n = j.col1.y * q + j.col2.y * n;
q = o;
j = l.m_xf.R;
var a = this.m_localAnchor2.x - l.m_sweep.localCenter.x,
c = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
o = j.col1.x * a + j.col2.x * c;
c = j.col1.y * a + j.col2.y * c;
a = o;
j = h.m_invMass;
o = l.m_invMass;
var g = h.m_invI,
b = l.m_invI;
this.m_mass.col1.x = j + o + n * n * g + c * c * b;
this.m_mass.col2.x = -n * q * g - c * a * b;
this.m_mass.col3.x = -n * g - c * b;
this.m_mass.col1.y = this.m_mass.col2.x;
this.m_mass.col2.y = j + o + q * q * g + a * a * b;
this.m_mass.col3.y = q * g + a * b;
this.m_mass.col1.z = this.m_mass.col3.x;
this.m_mass.col2.z = this.m_mass.col3.y;
this.m_mass.col3.z = g + b;
this.m_motorMass = 1 / (g + b);
if (this.m_enableMotor == false) this.m_motorImpulse = 0;
if (this.m_enableLimit) {
var e = l.m_sweep.a - h.m_sweep.a - this.m_referenceAngle;
if (y.Abs(this.m_upperAngle - this.m_lowerAngle) < 2 * F.b2_angularSlop) this.m_limitState = I.e_equalLimits;
else if (e <= this.m_lowerAngle) {
if (this.m_limitState != I.e_atLowerLimit) this.m_impulse.z = 0;
this.m_limitState = I.e_atLowerLimit
} else if (e >= this.m_upperAngle) {
if (this.m_limitState != I.e_atUpperLimit) this.m_impulse.z = 0;
this.m_limitState = I.e_atUpperLimit
} else {
this.m_limitState = I.e_inactiveLimit;
this.m_impulse.z = 0
}
} else this.m_limitState = I.e_inactiveLimit; if (d.warmStarting) {
this.m_impulse.x *= d.dtRatio;
this.m_impulse.y *= d.dtRatio;
this.m_motorImpulse *= d.dtRatio;
d = this.m_impulse.x;
e = this.m_impulse.y;
h.m_linearVelocity.x -= j * d;
h.m_linearVelocity.y -= j * e;
h.m_angularVelocity -= g * (q * e - n * d + this.m_motorImpulse + this.m_impulse.z);
l.m_linearVelocity.x += o * d;
l.m_linearVelocity.y += o * e;
l.m_angularVelocity += b * (a * e - c * d + this.m_motorImpulse + this.m_impulse.z)
} else {
this.m_impulse.SetZero();
this.m_motorImpulse = 0
}
};
N.prototype.SolveVelocityConstraints = function (d) {
var h = this.m_bodyA,
l = this.m_bodyB,
j = 0,
o = j = 0,
q = 0,
n = 0,
a = 0,
c = h.m_linearVelocity,
g = h.m_angularVelocity,
b = l.m_linearVelocity,
e = l.m_angularVelocity,
f = h.m_invMass,
m = l.m_invMass,
r = h.m_invI,
s = l.m_invI;
if (this.m_enableMotor && this.m_limitState != I.e_equalLimits) {
o = this.m_motorMass * -(e - g - this.m_motorSpeed);
q = this.m_motorImpulse;
n = d.dt * this.m_maxMotorTorque;
this.m_motorImpulse = y.Clamp(this.m_motorImpulse + o, -n, n);
o = this.m_motorImpulse - q;
g -= r * o;
e += s * o
}
if (this.m_enableLimit && this.m_limitState != I.e_inactiveLimit) {
d = h.m_xf.R;
o = this.m_localAnchor1.x - h.m_sweep.localCenter.x;
q = this.m_localAnchor1.y - h.m_sweep.localCenter.y;
j = d.col1.x * o + d.col2.x * q;
q = d.col1.y * o + d.col2.y * q;
o = j;
d = l.m_xf.R;
n = this.m_localAnchor2.x - l.m_sweep.localCenter.x;
a = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
j = d.col1.x * n + d.col2.x * a;
a = d.col1.y * n + d.col2.y * a;
n = j;
d = b.x + -e * a - c.x - -g * q;
var v = b.y + e * n - c.y - g * o;
this.m_mass.Solve33(this.impulse3, -d, -v, -(e - g));
if (this.m_limitState == I.e_equalLimits) this.m_impulse.Add(this.impulse3);
else if (this.m_limitState == I.e_atLowerLimit) {
j = this.m_impulse.z + this.impulse3.z;
if (j < 0) {
this.m_mass.Solve22(this.reduced, -d, -v);
this.impulse3.x = this.reduced.x;
this.impulse3.y = this.reduced.y;
this.impulse3.z = -this.m_impulse.z;
this.m_impulse.x += this.reduced.x;
this.m_impulse.y += this.reduced.y;
this.m_impulse.z = 0
}
} else if (this.m_limitState == I.e_atUpperLimit) {
j = this.m_impulse.z + this.impulse3.z;
if (j > 0) {
this.m_mass.Solve22(this.reduced, -d, -v);
this.impulse3.x = this.reduced.x;
this.impulse3.y = this.reduced.y;
this.impulse3.z = -this.m_impulse.z;
this.m_impulse.x += this.reduced.x;
this.m_impulse.y += this.reduced.y;
this.m_impulse.z = 0
}
}
c.x -= f * this.impulse3.x;
c.y -= f * this.impulse3.y;
g -= r * (o * this.impulse3.y - q * this.impulse3.x + this.impulse3.z);
b.x += m * this.impulse3.x;
b.y += m * this.impulse3.y;
e += s * (n * this.impulse3.y - a * this.impulse3.x + this.impulse3.z)
} else {
d = h.m_xf.R;
o = this.m_localAnchor1.x - h.m_sweep.localCenter.x;
q = this.m_localAnchor1.y - h.m_sweep.localCenter.y;
j = d.col1.x * o + d.col2.x * q;
q = d.col1.y * o + d.col2.y * q;
o = j;
d = l.m_xf.R;
n = this.m_localAnchor2.x - l.m_sweep.localCenter.x;
a = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
j = d.col1.x * n + d.col2.x * a;
a = d.col1.y * n + d.col2.y * a;
n = j;
this.m_mass.Solve22(this.impulse2, -(b.x + -e * a - c.x - -g * q), -(b.y + e * n - c.y - g * o));
this.m_impulse.x += this.impulse2.x;
this.m_impulse.y += this.impulse2.y;
c.x -= f * this.impulse2.x;
c.y -= f * this.impulse2.y;
g -= r * (o * this.impulse2.y - q * this.impulse2.x);
b.x += m * this.impulse2.x;
b.y += m * this.impulse2.y;
e += s * (n * this.impulse2.y - a * this.impulse2.x)
}
h.m_linearVelocity.SetV(c);
h.m_angularVelocity = g;
l.m_linearVelocity.SetV(b);
l.m_angularVelocity = e
};
N.prototype.SolvePositionConstraints = function () {
var d = 0,
h, l = this.m_bodyA,
j = this.m_bodyB,
o = 0,
q = h = 0,
n = 0,
a = 0;
if (this.m_enableLimit && this.m_limitState != I.e_inactiveLimit) {
d = j.m_sweep.a - l.m_sweep.a - this.m_referenceAngle;
var c = 0;
if (this.m_limitState == I.e_equalLimits) {
d = y.Clamp(d - this.m_lowerAngle, -F.b2_maxAngularCorrection, F.b2_maxAngularCorrection);
c = -this.m_motorMass * d;
o = y.Abs(d)
} else if (this.m_limitState == I.e_atLowerLimit) {
d = d - this.m_lowerAngle;
o = -d;
d = y.Clamp(d + F.b2_angularSlop, -F.b2_maxAngularCorrection, 0);
c = -this.m_motorMass * d
} else if (this.m_limitState == I.e_atUpperLimit) {
o = d = d - this.m_upperAngle;
d = y.Clamp(d - F.b2_angularSlop, 0, F.b2_maxAngularCorrection);
c = -this.m_motorMass * d
}
l.m_sweep.a -= l.m_invI * c;
j.m_sweep.a += j.m_invI * c;
l.SynchronizeTransform();
j.SynchronizeTransform()
}
h = l.m_xf.R;
c = this.m_localAnchor1.x - l.m_sweep.localCenter.x;
d = this.m_localAnchor1.y - l.m_sweep.localCenter.y;
q = h.col1.x * c + h.col2.x * d;
d = h.col1.y * c + h.col2.y * d;
c = q;
h = j.m_xf.R;
var g = this.m_localAnchor2.x - j.m_sweep.localCenter.x,
b = this.m_localAnchor2.y - j.m_sweep.localCenter.y;
q = h.col1.x * g + h.col2.x * b;
b = h.col1.y * g + h.col2.y * b;
g = q;
n = j.m_sweep.c.x + g - l.m_sweep.c.x - c;
a = j.m_sweep.c.y + b - l.m_sweep.c.y - d;
var e = n * n + a * a;
h = Math.sqrt(e);
q = l.m_invMass;
var f = j.m_invMass,
m = l.m_invI,
r = j.m_invI,
s = 10 * F.b2_linearSlop;
if (e > s * s) {
e = 1 / (q + f);
n = e * -n;
a = e * -a;
l.m_sweep.c.x -= 0.5 * q * n;
l.m_sweep.c.y -= 0.5 * q * a;
j.m_sweep.c.x += 0.5 * f * n;
j.m_sweep.c.y += 0.5 * f * a;
n = j.m_sweep.c.x + g - l.m_sweep.c.x - c;
a = j.m_sweep.c.y + b - l.m_sweep.c.y - d
}
this.K1.col1.x = q + f;
this.K1.col2.x = 0;
this.K1.col1.y = 0;
this.K1.col2.y = q + f;
this.K2.col1.x = m * d * d;
this.K2.col2.x = -m * c * d;
this.K2.col1.y = -m * c * d;
this.K2.col2.y = m * c * c;
this.K3.col1.x = r * b * b;
this.K3.col2.x = -r * g * b;
this.K3.col1.y = -r * g * b;
this.K3.col2.y = r * g * g;
this.K.SetM(this.K1);
this.K.AddM(this.K2);
this.K.AddM(this.K3);
this.K.Solve(N.tImpulse, -n, -a);
n = N.tImpulse.x;
a = N.tImpulse.y;
l.m_sweep.c.x -= l.m_invMass * n;
l.m_sweep.c.y -= l.m_invMass * a;
l.m_sweep.a -= l.m_invI * (c * a - d * n);
j.m_sweep.c.x += j.m_invMass * n;
j.m_sweep.c.y += j.m_invMass * a;
j.m_sweep.a += j.m_invI * (g * a - b * n);
l.SynchronizeTransform();
j.SynchronizeTransform();
return h <= F.b2_linearSlop && o <= F.b2_angularSlop
};
Box2D.postDefs.push(function () {
Box2D.Dynamics.Joints.b2RevoluteJoint.tImpulse = new w
});
Box2D.inherit(S, Box2D.Dynamics.Joints.b2JointDef);
S.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
S.b2RevoluteJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
this.localAnchorA = new w;
this.localAnchorB = new w
};
S.prototype.b2RevoluteJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_revoluteJoint;
this.localAnchorA.Set(0, 0);
this.localAnchorB.Set(0, 0);
this.motorSpeed = this.maxMotorTorque = this.upperAngle = this.lowerAngle = this.referenceAngle = 0;
this.enableMotor = this.enableLimit = false
};
S.prototype.Initialize = function (d, h, l) {
this.bodyA = d;
this.bodyB = h;
this.localAnchorA = this.bodyA.GetLocalPoint(l);
this.localAnchorB = this.bodyB.GetLocalPoint(l);
this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle()
};
Box2D.inherit(aa, Box2D.Dynamics.Joints.b2Joint);
aa.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
aa.b2WeldJoint = function () {
Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
this.m_localAnchorA = new w;
this.m_localAnchorB = new w;
this.m_impulse = new A;
this.m_mass = new K
};
aa.prototype.GetAnchorA = function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
};
aa.prototype.GetAnchorB = function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
};
aa.prototype.GetReactionForce = function (d) {
if (d === undefined) d = 0;
return new w(d * this.m_impulse.x, d * this.m_impulse.y)
};
aa.prototype.GetReactionTorque = function (d) {
if (d === undefined) d = 0;
return d * this.m_impulse.z
};
aa.prototype.b2WeldJoint = function (d) {
this.__super.b2Joint.call(this, d);
this.m_localAnchorA.SetV(d.localAnchorA);
this.m_localAnchorB.SetV(d.localAnchorB);
this.m_referenceAngle = d.referenceAngle;
this.m_impulse.SetZero();
this.m_mass = new K
};
aa.prototype.InitVelocityConstraints = function (d) {
var h, l = 0,
j = this.m_bodyA,
o = this.m_bodyB;
h = j.m_xf.R;
var q = this.m_localAnchorA.x - j.m_sweep.localCenter.x,
n = this.m_localAnchorA.y - j.m_sweep.localCenter.y;
l = h.col1.x * q + h.col2.x * n;
n = h.col1.y * q + h.col2.y * n;
q = l;
h = o.m_xf.R;
var a = this.m_localAnchorB.x - o.m_sweep.localCenter.x,
c = this.m_localAnchorB.y - o.m_sweep.localCenter.y;
l = h.col1.x * a + h.col2.x * c;
c = h.col1.y * a + h.col2.y * c;
a = l;
h = j.m_invMass;
l = o.m_invMass;
var g = j.m_invI,
b = o.m_invI;
this.m_mass.col1.x = h + l + n * n * g + c * c * b;
this.m_mass.col2.x = -n * q * g - c * a * b;
this.m_mass.col3.x = -n * g - c * b;
this.m_mass.col1.y = this.m_mass.col2.x;
this.m_mass.col2.y = h + l + q * q * g + a * a * b;
this.m_mass.col3.y = q * g + a * b;
this.m_mass.col1.z = this.m_mass.col3.x;
this.m_mass.col2.z = this.m_mass.col3.y;
this.m_mass.col3.z = g + b;
if (d.warmStarting) {
this.m_impulse.x *= d.dtRatio;
this.m_impulse.y *= d.dtRatio;
this.m_impulse.z *= d.dtRatio;
j.m_linearVelocity.x -= h * this.m_impulse.x;
j.m_linearVelocity.y -= h * this.m_impulse.y;
j.m_angularVelocity -= g * (q * this.m_impulse.y - n * this.m_impulse.x + this.m_impulse.z);
o.m_linearVelocity.x += l * this.m_impulse.x;
o.m_linearVelocity.y += l * this.m_impulse.y;
o.m_angularVelocity += b * (a * this.m_impulse.y - c * this.m_impulse.x + this.m_impulse.z)
} else this.m_impulse.SetZero()
};
aa.prototype.SolveVelocityConstraints = function () {
var d, h = 0,
l = this.m_bodyA,
j = this.m_bodyB,
o = l.m_linearVelocity,
q = l.m_angularVelocity,
n = j.m_linearVelocity,
a = j.m_angularVelocity,
c = l.m_invMass,
g = j.m_invMass,
b = l.m_invI,
e = j.m_invI;
d = l.m_xf.R;
var f = this.m_localAnchorA.x - l.m_sweep.localCenter.x,
m = this.m_localAnchorA.y - l.m_sweep.localCenter.y;
h = d.col1.x * f + d.col2.x * m;
m = d.col1.y * f + d.col2.y * m;
f = h;
d = j.m_xf.R;
var r = this.m_localAnchorB.x - j.m_sweep.localCenter.x,
s = this.m_localAnchorB.y - j.m_sweep.localCenter.y;
h = d.col1.x * r + d.col2.x * s;
s = d.col1.y * r + d.col2.y * s;
r = h;
d = n.x - a * s - o.x + q * m;
h = n.y + a * r - o.y - q * f;
var v = a - q,
t = new A;
this.m_mass.Solve33(t, -d, -h, -v);
this.m_impulse.Add(t);
o.x -= c * t.x;
o.y -= c * t.y;
q -= b * (f * t.y - m * t.x + t.z);
n.x += g * t.x;
n.y += g * t.y;
a += e * (r * t.y - s * t.x + t.z);
l.m_angularVelocity = q;
j.m_angularVelocity = a
};
aa.prototype.SolvePositionConstraints = function () {
var d, h = 0,
l = this.m_bodyA,
j = this.m_bodyB;
d = l.m_xf.R;
var o = this.m_localAnchorA.x - l.m_sweep.localCenter.x,
q = this.m_localAnchorA.y - l.m_sweep.localCenter.y;
h = d.col1.x * o + d.col2.x * q;
q = d.col1.y * o + d.col2.y * q;
o = h;
d = j.m_xf.R;
var n = this.m_localAnchorB.x - j.m_sweep.localCenter.x,
a = this.m_localAnchorB.y - j.m_sweep.localCenter.y;
h = d.col1.x * n + d.col2.x * a;
a = d.col1.y * n + d.col2.y * a;
n = h;
d = l.m_invMass;
h = j.m_invMass;
var c = l.m_invI,
g = j.m_invI,
b = j.m_sweep.c.x + n - l.m_sweep.c.x - o,
e = j.m_sweep.c.y + a - l.m_sweep.c.y - q,
f = j.m_sweep.a - l.m_sweep.a - this.m_referenceAngle,
m = 10 * F.b2_linearSlop,
r = Math.sqrt(b * b + e * e),
s = y.Abs(f);
if (r > m) {
c *= 1;
g *= 1
}
this.m_mass.col1.x = d + h + q * q * c + a * a * g;
this.m_mass.col2.x = -q * o * c - a * n * g;
this.m_mass.col3.x = -q * c - a * g;
this.m_mass.col1.y = this.m_mass.col2.x;
this.m_mass.col2.y = d + h + o * o * c + n * n * g;
this.m_mass.col3.y = o * c + n * g;
this.m_mass.col1.z = this.m_mass.col3.x;
this.m_mass.col2.z = this.m_mass.col3.y;
this.m_mass.col3.z = c + g;
m = new A;
this.m_mass.Solve33(m, -b, -e, -f);
l.m_sweep.c.x -= d * m.x;
l.m_sweep.c.y -= d * m.y;
l.m_sweep.a -= c * (o * m.y - q * m.x + m.z);
j.m_sweep.c.x += h * m.x;
j.m_sweep.c.y += h * m.y;
j.m_sweep.a += g * (n * m.y - a * m.x + m.z);
l.SynchronizeTransform();
j.SynchronizeTransform();
return r <= F.b2_linearSlop && s <= F.b2_angularSlop
};
Box2D.inherit(Z, Box2D.Dynamics.Joints.b2JointDef);
Z.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
Z.b2WeldJointDef = function () {
Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
this.localAnchorA = new w;
this.localAnchorB = new w
};
Z.prototype.b2WeldJointDef = function () {
this.__super.b2JointDef.call(this);
this.type = I.e_weldJoint;
this.referenceAngle = 0
};
Z.prototype.Initialize = function (d, h, l) {
this.bodyA = d;
this.bodyB = h;
this.localAnchorA.SetV(this.bodyA.GetLocalPoint(l));
this.localAnchorB.SetV(this.bodyB.GetLocalPoint(l));
this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle()
}
})();
(function () {
var F = Box2D.Dynamics.b2DebugDraw;
F.b2DebugDraw = function () {
this.m_xformScale = this.m_fillAlpha = this.m_alpha = this.m_lineThickness = this.m_drawScale = 1;
var G = this;
this.m_sprite = {
graphics: {
clear: function () {
G.m_ctx.clearRect(0, 0, G.m_ctx.canvas.width, G.m_ctx.canvas.height)
}
}
}
};
F.prototype._color = function (G, K) {
return "rgba(" + ((G & 16711680) >> 16) + "," + ((G & 65280) >> 8) + "," + (G & 255) + "," + K + ")"
};
F.prototype.b2DebugDraw = function () {
this.m_drawFlags = 0
};
F.prototype.SetFlags = function (G) {
if (G === undefined) G = 0;
this.m_drawFlags = G
};
F.prototype.GetFlags = function () {
return this.m_drawFlags
};
F.prototype.AppendFlags = function (G) {
if (G === undefined) G = 0;
this.m_drawFlags |= G
};
F.prototype.ClearFlags = function (G) {
if (G === undefined) G = 0;
this.m_drawFlags &= ~G
};
F.prototype.SetSprite = function (G) {
this.m_ctx = G
};
F.prototype.GetSprite = function () {
return this.m_ctx
};
F.prototype.SetDrawScale = function (G) {
if (G === undefined) G = 0;
this.m_drawScale = G
};
F.prototype.GetDrawScale = function () {
return this.m_drawScale
};
F.prototype.SetLineThickness = function (G) {
if (G === undefined) G = 0;
this.m_lineThickness = G;
this.m_ctx.strokeWidth = G
};
F.prototype.GetLineThickness = function () {
return this.m_lineThickness
};
F.prototype.SetAlpha = function (G) {
if (G === undefined) G = 0;
this.m_alpha = G
};
F.prototype.GetAlpha = function () {
return this.m_alpha
};
F.prototype.SetFillAlpha = function (G) {
if (G === undefined) G = 0;
this.m_fillAlpha = G
};
F.prototype.GetFillAlpha = function () {
return this.m_fillAlpha
};
F.prototype.SetXFormScale = function (G) {
if (G === undefined) G = 0;
this.m_xformScale = G
};
F.prototype.GetXFormScale = function () {
return this.m_xformScale
};
F.prototype.DrawPolygon = function (G, K, y) {
if (K) {
var w = this.m_ctx,
A = this.m_drawScale;
w.beginPath();
w.strokeStyle = this._color(y.color, this.m_alpha);
w.moveTo(G[0].x * A, G[0].y * A);
for (y = 1; y < K; y++) w.lineTo(G[y].x * A, G[y].y * A);
w.lineTo(G[0].x * A, G[0].y * A);
w.closePath();
w.stroke()
}
};
F.prototype.DrawSolidPolygon = function (G, K, y) {
if (K) {
var w = this.m_ctx,
A = this.m_drawScale;
w.beginPath();
w.strokeStyle = this._color(y.color, this.m_alpha);
w.fillStyle = this._color(y.color, this.m_fillAlpha);
w.moveTo(G[0].x * A, G[0].y * A);
for (y = 1; y < K; y++) w.lineTo(G[y].x * A, G[y].y * A);
w.lineTo(G[0].x * A, G[0].y * A);
w.closePath();
w.fill();
w.stroke()
}
};
F.prototype.DrawCircle = function (G, K, y) {
if (K) {
var w = this.m_ctx,
A = this.m_drawScale;
w.beginPath();
w.strokeStyle = this._color(y.color, this.m_alpha);
w.arc(G.x * A, G.y * A, K * A, 0, Math.PI * 2, true);
w.closePath();
w.stroke()
}
};
F.prototype.DrawSolidCircle = function (G, K, y, w) {
if (K) {
var A = this.m_ctx,
U = this.m_drawScale,
p = G.x * U,
B = G.y * U;
A.moveTo(0, 0);
A.beginPath();
A.strokeStyle = this._color(w.color, this.m_alpha);
A.fillStyle = this._color(w.color, this.m_fillAlpha);
A.arc(p, B, K * U, 0, Math.PI * 2, true);
A.moveTo(p, B);
A.lineTo((G.x + y.x * K) * U, (G.y + y.y * K) * U);
A.closePath();
A.fill();
A.stroke()
}
};
F.prototype.DrawSegment = function (G, K, y) {
var w = this.m_ctx,
A = this.m_drawScale;
w.strokeStyle = this._color(y.color, this.m_alpha);
w.beginPath();
w.moveTo(G.x * A, G.y * A);
w.lineTo(K.x * A, K.y * A);
w.closePath();
w.stroke()
};
F.prototype.DrawTransform = function (G) {
var K = this.m_ctx,
y = this.m_drawScale;
K.beginPath();
K.strokeStyle = this._color(16711680, this.m_alpha);
K.moveTo(G.position.x * y, G.position.y * y);
K.lineTo((G.position.x + this.m_xformScale * G.R.col1.x) * y, (G.position.y + this.m_xformScale * G.R.col1.y) * y);
K.strokeStyle = this._color(65280, this.m_alpha);
K.moveTo(G.position.x * y, G.position.y * y);
K.lineTo((G.position.x + this.m_xformScale * G.R.col2.x) * y, (G.position.y + this.m_xformScale * G.R.col2.y) * y);
K.closePath();
K.stroke()
}
})();
var i;
for (i = 0; i < Box2D.postDefs.length; ++i) Box2D.postDefs[i]();
delete Box2D.postDefs;
// Copyright 2013 the V8 project authors. All rights reserved.
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
function MakeNewWorld () {
var Vec2 = Box2D.Common.Math.b2Vec2,
BodyDef = Box2D.Dynamics.b2BodyDef,
Body = Box2D.Dynamics.b2Body,
FixtureDef = Box2D.Dynamics.b2FixtureDef,
Fixture = Box2D.Dynamics.b2Fixture,
World = Box2D.Dynamics.b2World,
MassData = Box2D.Collision.Shapes.b2MassData,
PolygonShape = Box2D.Collision.Shapes.b2PolygonShape,
CircleShape = Box2D.Collision.Shapes.b2CircleShape;
var gravity = new Vec2(0, -10);
var world = new World(gravity, true);
var shape = new PolygonShape();
shape.SetAsEdge(new Vec2(-40.0, 0), new Vec2(40.0, 0));
var fd = new FixtureDef();
fd.density = 0.0;
fd.shape = shape;
var bd = new BodyDef();
var ground = world.CreateBody(bd);
ground.CreateFixture(fd);
var a = .5;
var shape = new PolygonShape();
shape.SetAsBox(a, a);
var x = new Vec2(-7.0, 0.75);
var y = new Vec2();
var deltaX = new Vec2(0.5625, 1);
var deltaY = new Vec2(1.125, 0.0);
for (var i = 0; i < 10; ++i) {
y.Set(x.x, x.y);
for (var j = 0; j < 5; ++j) {
var fd = new FixtureDef();
fd.density = 5.0;
fd.shape = shape;
var bd = new BodyDef();
bd.type = Body.b2_dynamicBody;
bd.position.Set(y.x, y.y);
var body = world.CreateBody(bd);
body.CreateFixture(fd);
y.Add(deltaY);
}
x.Add(deltaX);
}
return world;
}
var world = null;
var Box2DBenchmark = new BenchmarkSuite('Box2D', [5432788],
[new Benchmark('Box2D',
false,
false,
60,
runBox2D,
setupBox2D,
tearDownBox2D,
null,
8)]);
function runBox2D() {
var world = MakeNewWorld();
for (var i = 0; i < 20; i++) {
world.Step(1 / 60, 10, 3);
}
}
function setupBox2D() {
}
function tearDownBox2D() {
world = null;
Box2D = null;
}
////////////////////////////////////////////////////////////////////////////////
// Runner
////////////////////////////////////////////////////////////////////////////////
var success = true;
function NotifyStart(name) {
}
function NotifyError(name, error) {
WScript.Echo(name + " : ERROR : " +error.stack);
success = false;
}
function NotifyResult(name, score) {
if (success) {
WScript.Echo("### SCORE:", score);
}
}
function NotifyScore(score) {
}
BenchmarkSuite.RunSuites({
NotifyStart : NotifyStart,
NotifyError : NotifyError,
NotifyResult : NotifyResult,
NotifyScore : NotifyScore
});