├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── SAT.js
├── examples
    ├── dynamic_collision.html
    ├── examples.js
    └── simple_collision.html
├── package.json
└── test
    └── test.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | ## 0.9.0 (April 4, 2021)
 4 | 
 5 | - Add `getAABBAsBox` methods to `Polygon` and `Circle` that returns a `Box` (`getAABB` returns a `Polygon`) - thanks [getkey](https://github.com/getkey)!
 6 | 
 7 | ## 0.8.0 (Sept 7, 2019)
 8 | 
 9 | - Combine consecutive duplicate points in polygons to remove zero-length edges. (Fixes #55)
10 | - Add the ability to set an offset for circles - thanks [funnisimo](https://github.com/funnisimo)!
11 | 
12 | ## 0.7.1 (May 23, 2018)
13 | 
14 | - Check explicitly for `undefined` `y` param when scaling vectors. (Fixes #52)
15 | 
16 | ## O.7.0 (Feb 17, 2018)
17 | 
18 | - Add `getCentroid` method to `Polygon` that computes the [centroid](https://en.wikipedia.org/wiki/Centroid#Centroid_of_a_polygon). (Fixes #50)
19 |   - Useful for computing the center of a polygon if you want to rotate around it.
20 | 
21 | ## 0.6.0 (Sept 11, 2016)
22 | 
23 |  - Fix "Vornoi" -> "Voronoi" everywhere. Changes are all in private code, no functional changes. (Fixes #27)
24 |  - Exposed isSeparatingAxis() function - thanks [hexus](https://github.com/hexus)!
25 |  - Allow pointInPolygon to work with small polygons. (Fixes #41)
26 | 
27 | ## 0.5.0 (Dec 26, 2014)
28 | 
29 |  - **(POTENTIALLY BREAKING CHANGE)** Make `recalc` on `Polygon` more memory efficient. It no longer does any allocations. The `calcPoints`,`edges` and `normals` vector arrays are reused and only created in `setPoints` when the number of new points is different than the current ones. (Fixes #15)
30 |    - `points`, `angle` and `offset` can no longer be manually changed. The `setPoints`, `setAngle`, and `setOffset` methods **must** be used.
31 |    - As a result of this, the `recalc` method is no longer part of the API.
32 |  - Add `getAABB` to `Polygon` and `Circle` that calculate Axis-Aligned Bounding Boxes - thanks [TuurDutoit](https://github.com/TuurDutoit)! (Fixes #17)
33 | 
34 | ## 0.4.1 (Mar 23, 2014)
35 | 
36 |  - Fix missing `T_VECTORS.push()` - thanks [shakiba](https://github.com/shakiba)! (Fixes #8)
37 |  - Add `package.json` - released as `npm` module (Fixes #11, Fixes #12)
38 | 
39 | ## 0.4 (Mar 2, 2014)
40 | 
41 |  - Add `clone` method to `Vector` that returns a new vector with the same coordinates.
42 |  - Add `angle` and `offset` to `Polygon` that are used to modify the computed collision polygon (Fixes #3, Fixes #4)
43 |    - The `rotate` and `translate` methods still exist on `Polygon` but they modify the original `points` of the polygon, wheras `angle` and `offset` do not modify the original points, and are instead applied as computed values.
44 |  - Add `setPoints`, `setAngle`, and `setOffset` methods to `Polygon`
45 | 
46 | ## 0.3 (Feb 11, 2014)
47 | 
48 |  - Add `pointInCircle` and `pointInPolygon` functions for performing "hit tests" (Fixes #2)
49 | 
50 | ## 0.2 (Dec 8, 2013)
51 | 
52 |  - Reformat comments so that they can be run through `docco` to create an annotated source file.
53 |  - Fix/optimize compilation with the Closure Compiler in advanced mode (previously it was mangling some important properties)
54 |  - Wrap the code in a UMD declaration so that it works:
55 |     - Just inserting it as a `<script>`
56 |     - Using an AMD loader
57 |     - In Node.js
58 |  - Add `rotate` method to `Vector` and `Polygon`.
59 |  - Add `translate` method to `Polygon`
60 |  - Add some examples (using Raphael.js for display)
61 | 
62 | ## 0.1
63 | 
64 |  - Initial release


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2012 - 2015 by Jim Riecken
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # SAT.js
  2 | 
  3 |  - [Classes](#classes)
  4 |  - [Collision Tests](#collision-tests)
  5 |  - [Examples](#examples)
  6 | 
  7 | ## About
  8 | 
  9 | SAT.js is a simple JavaScript library for performing collision detection (and projection-based collision response) of simple 2D shapes.  It uses the [Separating Axis Theorem](http://en.wikipedia.org/wiki/Hyperplane_separation_theorem) (hence the name)
 10 | 
 11 | It supports detecting collisions between:
 12 |  - Circles (using Voronoi Regions.)
 13 |  - Convex Polygons (and simple Axis-Aligned Boxes, which are of course, convex polygons.)
 14 | 
 15 | It also supports checking whether a point is inside a circle or polygon.
 16 | 
 17 | It's released under the [MIT](http://en.wikipedia.org/wiki/MIT_License) license.
 18 | 
 19 | Current version: `0.9.0`.
 20 | 
 21 | Nicely compresses with the [Google Closure Compiler](https://developers.google.com/closure/compiler/) in **Advanced** mode to about 6KB (2KB gzipped)
 22 | 
 23 | To use it in node.js, you can run `npm install sat` and then use it with `var SAT = require('sat');`
 24 | 
 25 | ## Classes
 26 | 
 27 | SAT.js contains the following JavaScript classes:
 28 | 
 29 | ### SAT.Vector (aliased as SAT.V)
 30 | 
 31 | This is a simple 2D vector/point class.  It is created by calling:
 32 | ```javascript
 33 | // Create the vector (10,10) - If (x,y) not specified, defaults to (0,0).
 34 | var v = new SAT.Vector(10, 10)
 35 | ```
 36 | 
 37 | It has the following properties:
 38 | 
 39 |  - `x` - The x-coordinate of the Vector.
 40 |  - `y` - The y-coordinate of the Vector.
 41 | 
 42 | It contains the following methods:
 43 | 
 44 |  - `copy(other)` - Copy the value of another Vector to this one.
 45 |  - `clone()` - Return a new vector with the same coordinates as this one.
 46 |  - `perp()` - Change this vector to be perpendicular to what it was before.
 47 |  - `rotate(angle)` - Rotate this vector counter-clockwise by the specified number of radians.
 48 |  - `reverse()` - Reverse this Vector.
 49 |  - `normalize()` - Make the Vector unit-lengthed.
 50 |  - `add(other)` - Add another Vector to this one.
 51 |  - `sub(other)` - Subtract another Vector from this one.
 52 |  - `scale(x,y)` - Scale this Vector in the X and Y directions.
 53 |  - `project(other)` - Project this Vector onto another one.
 54 |  - `projectN(other)` - Project this Vector onto a unit Vector.
 55 |  - `reflect(axis)` - Reflect this Vector on an arbitrary axis Vector.
 56 |  - `reflectN(axis)` - Reflect this Vector on an arbitrary axis unit Vector.
 57 |  - `dot(other)` - Get the dot product of this Vector and another.
 58 |  - `len2()` - Get the length squared of this Vector.
 59 |  - `len()` - Get the length of this Vector
 60 | 
 61 | ### SAT.Circle
 62 | 
 63 | This is a simple circle with a center position and a radius.  It is created by calling:
 64 | ```javascript
 65 | // Create a circle whose center is (10,10) with radius of 20
 66 | var c = new SAT.Circle(new SAT.Vector(10,10), 20);
 67 | ```
 68 | 
 69 | It has the following properties:
 70 | 
 71 |  - `pos` - A Vector representing the center of the circle.
 72 |  - `r` - The radius of the circle
 73 |  - `offset` - Offset of center of circle from `pos`.
 74 | 
 75 |  It has the following methods:
 76 | 
 77 |  - `setOffset(offset)` - Set the current offset
 78 |  - `getAABB()` - Compute the axis-aligned bounding box. Returns a new Polygon every time it is called.
 79 |  - `getAABBAsBox()` - Compute the axis-aligned bounding box. Returns a new Box every time it is called.
 80 | 
 81 | ### SAT.Polygon
 82 | 
 83 | This is a **convex** polygon, whose points are specified in a counter-clockwise fashion.  It is created by calling:
 84 | ```javascript
 85 | // Create a triangle at (0,0)
 86 | var p = new SAT.Polygon(new SAT.Vector(), [
 87 |   new SAT.Vector(),
 88 |   new SAT.Vector(100,0),
 89 |   new SAT.Vector(50,75)
 90 | ]);
 91 | ```
 92 | 
 93 | Note: The points are counter-clockwise *with respect to the coordinate system*. If you directly draw the points on a screen that has the origin at the top-left corner it will _appear_ visually that the points are being specified clockwise. This is just because of the inversion of the Y-axis when being displayed.
 94 | 
 95 | You can create a line segment by creating a `Polygon` that contains only 2 points.
 96 | 
 97 | Any identical consecutive points will be combined. (this can happen if you convert a `Box` with zero width or height into a `Polygon`)
 98 | 
 99 | It has the following properties:
100 | 
101 |  - `pos` - The position of the polygon (all points are relative to this).
102 |  - `points` - Array of vectors representing the original points of the polygon.
103 |  - `angle` - Angle to rotate the polgon (affects `calcPoints`)
104 |  - `offset` - Translation to apply to the polygon before the `angle` rotation (affects `calcPoints`)
105 |  - `calcPoints` - (Calculated) The collision polygon - effectively `points` with `angle` and `offset` applied.
106 |  - `edges` - (Calculated) Array of Vectors representing the edges of the calculated polygon
107 |  - `normals` - (Calculated) Array of Vectors representing the edge normals of the calculated polygon (perpendiculars)
108 | 
109 | You should _not_ manually change any of the properties except `pos` - use the `setPoints`, `setAngle`, and `setOffset` methods to ensure that the calculated properties are updated correctly.
110 | 
111 | It has the following methods:
112 | 
113 |  - `setPoints(points)` - Set the original points
114 |  - `setAngle(angle)` - Set the current rotation angle (in radians)
115 |  - `setOffset(offset)` - Set the current offset
116 |  - `rotate(angle)` - Rotate the original points of this polygon counter-clockwise (around its local coordinate system) by the specified number of radians. The `angle` rotation will be applied on top of this rotation.
117 |  - `translate(x, y)` - Translate the original points of this polygon (relative to the local coordinate system) by the specified amounts. The `offset` translation will be applied on top of this translation.
118 |  - `getAABB()` - Compute the axis-aligned bounding box. Returns a new Polygon every time it is called. Is performed based on the `calcPoints`.
119 |  - `getAABBAsBox()` - Compute the axis-aligned bounding box. Returns a new Box every time it is called. Is performed based on the `calcPoints`.
120 |  - `getCentroid()` - Compute the [Centroid](https://en.wikipedia.org/wiki/Centroid#Centroid_of_a_polygon) of the polygon. Is performed based on the `calcPoints`.
121 | 
122 | ### SAT.Box
123 | 
124 | This is a simple Box with a position, width, and height.  It is created by calling:
125 | ```javascript
126 | // Create a box at (10,10) with width 20 and height 40.
127 | var b = new SAT.Box(new SAT.Vector(10,10), 20, 40);
128 | ```
129 | 
130 | It has the following properties:
131 | 
132 |  - `pos` - The bottom-left coordinate of the box (i.e the smallest `x` value and the smallest `y` value).
133 |  - `w` - The width of the box.
134 |  - `h` - The height of the box.
135 | 
136 | It has the following methods:
137 | 
138 |  - `toPolygon()` - Returns a new Polygon whose edges are the edges of the box.
139 | 
140 | ### SAT.Response
141 | 
142 | This is the object representing the result of a collision between two objects.  It just has a simple `new Response()` constructor.
143 | 
144 | It has the following properties:
145 | 
146 |  - `a` - The first object in the collision.
147 |  - `b` - The second object in the collison.
148 |  - `overlap` - Magnitude of the overlap on the shortest colliding axis.
149 |  - `overlapN` - The shortest colliding axis (unit-vector)
150 |  - `overlapV` - The overlap vector (i.e. `overlapN.scale(overlap, overlap)`).  If this vector is subtracted from the position of `a`, `a` and `b` will no longer be colliding.
151 |  - `aInB` - Whether the first object is completely inside the second.
152 |  - `bInA` - Whether the second object is completely inside the first.
153 | 
154 | It has the following methods:
155 | 
156 | - `clear()` - Clear the response so that it is ready to be reused for another collision test.
157 | 
158 | Note: The `clear`ed value for a `Response` has what may seem to be strange looking values:
159 | 
160 | ```javascript
161 | {
162 |   a: null,
163 |   b: null,
164 |   overlap: 1.7976931348623157e+308,
165 |   overlapV: Vector(0, 0),
166 |   overlapN: Vector(0, 0),
167 |   aInB: true,
168 |   bInA: true
169 | }
170 | ```
171 | 
172 | These just make calculating the response simpler in the collision tests. If the collision test functions return `false` the values that are in the response should not be examined, and `clear()` should be called before using it for another collision test.
173 | 
174 | ## Collision Tests
175 | 
176 | SAT.js contains the following collision tests:
177 | 
178 | ### `SAT.pointInCircle(p, c)`
179 | 
180 | Checks whether a given point is inside the specified circle.
181 | 
182 | ### `SAT.pointInPolygon(p, poly)`
183 | 
184 | Checks whether a given point is inside a specified convex polygon.
185 | 
186 | ### `SAT.testCircleCircle(a, b, response)`
187 | 
188 | Tests for a collision between two `Circle`s, `a`, and `b`.  If a response is to be calculated in the event of collision, pass in a `clear`ed `Response` object.
189 | 
190 | Returns `true` if the circles collide, `false` otherwise.
191 | 
192 | If it returns `false` you should not use any values that are in the `response` (if one is passed in)
193 | 
194 | ### `SAT.testPolygonCircle(polygon, circle, response)`
195 | 
196 | Tests for a collision between a `Polygon` and a `Circle`.  If a response is to be calculated in the event of a collision, pass in a `clear`ed `Response` object.
197 | 
198 | Returns `true` if there is a collision, `false` otherwise.
199 | 
200 | If it returns `false` you should not use any values that are in the `response` (if one is passed in)
201 | 
202 | ### `SAT.testCirclePolygon(circle, polygon, response)`
203 | 
204 | The same thing as `SAT.testPolygonCircle`, but in the other direction.
205 | 
206 | Returns `true` if there is a collision, `false` otherwise.
207 | 
208 | If it returns `false` you should not use any values that are in the `response` (if one is passed in)
209 | 
210 | *Note: This is slightly slower than `SAT.testPolygonCircle` as it just calls that and reverses the result*
211 | 
212 | ### `SAT.testPolygonPolygon(a, b, response)`
213 | 
214 | Tests whether two polygons `a` and `b` collide. If a response is to be calculated in the event of collision, pass in a `clear`ed `Response` object.
215 | 
216 | Returns `true` if there is a collision, `false` otherwise.
217 | 
218 | If it returns `false` you should not use any values that are in the `response` (if one is passed in)
219 | 
220 | *Note: If you want to detect a collision between `Box`es, use the `toPolygon()` method*
221 | 
222 | ## Examples
223 | 
224 | Test two circles
225 | ```javascript
226 | var V = SAT.Vector;
227 | var C = SAT.Circle;
228 | 
229 | var circle1 = new C(new V(0,0), 20);
230 | var circle2 = new C(new V(30,0), 20);
231 | var response = new SAT.Response();
232 | var collided = SAT.testCircleCircle(circle1, circle2, response);
233 | 
234 | // collided => true
235 | // response.overlap => 10
236 | // response.overlapV => (10, 0)
237 | ```
238 | 
239 | Test a circle and a polygon
240 | ```javascript
241 | var V = SAT.Vector;
242 | var C = SAT.Circle;
243 | var P = SAT.Polygon;
244 | 
245 | var circle = new C(new V(50,50), 20);
246 | // A square
247 | var polygon = new P(new V(0,0), [
248 |   new V(0,0), new V(40,0), new V(40,40), new V(0,40)
249 | ]);
250 | var response = new SAT.Response();
251 | var collided = SAT.testPolygonCircle(polygon, circle, response);
252 | 
253 | // collided => true
254 | // response.overlap ~> 5.86
255 | // response.overlapV ~> (4.14, 4.14) - i.e. on a diagonal
256 | ```
257 | 
258 | Test two polygons
259 | ```javascript
260 | var V = SAT.Vector;
261 | var P = SAT.Polygon;
262 | 
263 | // A square
264 | var polygon1 = new P(new V(0,0), [
265 |   new V(0,0), new V(40,0), new V(40,40), new V(0,40)
266 | ]);
267 | // A triangle
268 | var polygon2 = new P(new V(30,0), [
269 |   new V(0,0), new V(30, 0), new V(0, 30)
270 | ]);
271 | var response = new SAT.Response();
272 | var collided = SAT.testPolygonPolygon(polygon1, polygon2, response);
273 | 
274 | // collided => true
275 | // response.overlap => 10
276 | // response.overlapV => (10, 0)
277 | ```
278 | 
279 | No collision between two Boxes
280 | ```javascript
281 | var V = SAT.Vector;
282 | var B = SAT.Box;
283 | 
284 | var box1 = new B(new V(0,0), 20, 20).toPolygon();
285 | var box2 = new B(new V(100,100), 20, 20).toPolygon();
286 | var collided = SAT.testPolygonPolygon(box1, box2);
287 | 
288 | // collided => false
289 | ```
290 | 
291 | Hit testing a circle and polygon
292 | ```javascript
293 | var V = SAT.Vector;
294 | var C = SAT.Circle;
295 | var P = SAT.Polygon;
296 | 
297 | var triangle = new P(new V(30,0), [
298 |   new V(0,0), new V(30, 0), new V(0, 30)
299 | ]);
300 | var circle = new C(new V(100,100), 20);
301 | 
302 | SAT.pointInPolygon(new V(0,0), triangle); // false
303 | SAT.pointInPolygon(new V(35, 5), triangle); // true
304 | SAT.pointInCircle(new V(0,0), circle); // false
305 | SAT.pointInCircle(new V(110,110), circle); // true
306 | ```
307 | 
308 | ## Tests
309 | 
310 | To run the tests from your console:
311 | 
312 | ```
313 | npm install
314 | npm run test
315 | ```
316 | 


--------------------------------------------------------------------------------
/SAT.js:
--------------------------------------------------------------------------------
   1 | // Version 0.9.0 - Copyright 2012 - 2021 -  Jim Riecken <jimr@jimr.ca>
   2 | //
   3 | // Released under the MIT License - https://github.com/jriecken/sat-js
   4 | //
   5 | // A simple library for determining intersections of circles and
   6 | // polygons using the Separating Axis Theorem.
   7 | /** @preserve SAT.js - Version 0.9.0 - Copyright 2012 - 2021 - Jim Riecken <jimr@jimr.ca> - released under the MIT License. https://github.com/jriecken/sat-js */
   8 | 
   9 | /*global define: false, module: false*/
  10 | /*jshint shadow:true, sub:true, forin:true, noarg:true, noempty:true,
  11 |   eqeqeq:true, bitwise:true, strict:true, undef:true,
  12 |   curly:true, browser:true */
  13 | 
  14 | // Create a UMD wrapper for SAT. Works in:
  15 | //
  16 | //  - Plain browser via global SAT variable
  17 | //  - AMD loader (like require.js)
  18 | //  - Node.js
  19 | //
  20 | // The quoted properties all over the place are used so that the Closure Compiler
  21 | // does not mangle the exposed API in advanced mode.
  22 | /**
  23 |  * @param {*} root - The global scope
  24 |  * @param {Function} factory - Factory that creates SAT module
  25 |  */
  26 | (function (root, factory) {
  27 |   "use strict";
  28 |   if (typeof define === 'function' && define['amd']) {
  29 |     define(factory);
  30 |   } else if (typeof exports === 'object') {
  31 |     module['exports'] = factory();
  32 |   } else {
  33 |     root['SAT'] = factory();
  34 |   }
  35 | }(this, function () {
  36 |   "use strict";
  37 | 
  38 |   var SAT = {};
  39 | 
  40 |   //
  41 |   // ## Vector
  42 |   //
  43 |   // Represents a vector in two dimensions with `x` and `y` properties.
  44 | 
  45 | 
  46 |   // Create a new Vector, optionally passing in the `x` and `y` coordinates. If
  47 |   // a coordinate is not specified, it will be set to `0`
  48 |   /**
  49 |    * @param {?number=} x The x position.
  50 |    * @param {?number=} y The y position.
  51 |    * @constructor
  52 |    */
  53 |   function Vector(x, y) {
  54 |     this['x'] = x || 0;
  55 |     this['y'] = y || 0;
  56 |   }
  57 |   SAT['Vector'] = Vector;
  58 |   // Alias `Vector` as `V`
  59 |   SAT['V'] = Vector;
  60 | 
  61 | 
  62 |   // Copy the values of another Vector into this one.
  63 |   /**
  64 |    * @param {Vector} other The other Vector.
  65 |    * @return {Vector} This for chaining.
  66 |    */
  67 |   Vector.prototype['copy'] = Vector.prototype.copy = function (other) {
  68 |     this['x'] = other['x'];
  69 |     this['y'] = other['y'];
  70 |     return this;
  71 |   };
  72 | 
  73 |   // Create a new vector with the same coordinates as this on.
  74 |   /**
  75 |    * @return {Vector} The new cloned vector
  76 |    */
  77 |   Vector.prototype['clone'] = Vector.prototype.clone = function () {
  78 |     return new Vector(this['x'], this['y']);
  79 |   };
  80 | 
  81 |   // Change this vector to be perpendicular to what it was before. (Effectively
  82 |   // roatates it 90 degrees in a clockwise direction)
  83 |   /**
  84 |    * @return {Vector} This for chaining.
  85 |    */
  86 |   Vector.prototype['perp'] = Vector.prototype.perp = function () {
  87 |     var x = this['x'];
  88 |     this['x'] = this['y'];
  89 |     this['y'] = -x;
  90 |     return this;
  91 |   };
  92 | 
  93 |   // Rotate this vector (counter-clockwise) by the specified angle (in radians).
  94 |   /**
  95 |    * @param {number} angle The angle to rotate (in radians)
  96 |    * @return {Vector} This for chaining.
  97 |    */
  98 |   Vector.prototype['rotate'] = Vector.prototype.rotate = function (angle) {
  99 |     var x = this['x'];
 100 |     var y = this['y'];
 101 |     this['x'] = x * Math.cos(angle) - y * Math.sin(angle);
 102 |     this['y'] = x * Math.sin(angle) + y * Math.cos(angle);
 103 |     return this;
 104 |   };
 105 | 
 106 |   // Reverse this vector.
 107 |   /**
 108 |    * @return {Vector} This for chaining.
 109 |    */
 110 |   Vector.prototype['reverse'] = Vector.prototype.reverse = function () {
 111 |     this['x'] = -this['x'];
 112 |     this['y'] = -this['y'];
 113 |     return this;
 114 |   };
 115 | 
 116 | 
 117 |   // Normalize this vector.  (make it have length of `1`)
 118 |   /**
 119 |    * @return {Vector} This for chaining.
 120 |    */
 121 |   Vector.prototype['normalize'] = Vector.prototype.normalize = function () {
 122 |     var d = this.len();
 123 |     if (d > 0) {
 124 |       this['x'] = this['x'] / d;
 125 |       this['y'] = this['y'] / d;
 126 |     }
 127 |     return this;
 128 |   };
 129 | 
 130 |   // Add another vector to this one.
 131 |   /**
 132 |    * @param {Vector} other The other Vector.
 133 |    * @return {Vector} This for chaining.
 134 |    */
 135 |   Vector.prototype['add'] = Vector.prototype.add = function (other) {
 136 |     this['x'] += other['x'];
 137 |     this['y'] += other['y'];
 138 |     return this;
 139 |   };
 140 | 
 141 |   // Subtract another vector from this one.
 142 |   /**
 143 |    * @param {Vector} other The other Vector.
 144 |    * @return {Vector} This for chaiing.
 145 |    */
 146 |   Vector.prototype['sub'] = Vector.prototype.sub = function (other) {
 147 |     this['x'] -= other['x'];
 148 |     this['y'] -= other['y'];
 149 |     return this;
 150 |   };
 151 | 
 152 |   // Scale this vector. An independent scaling factor can be provided
 153 |   // for each axis, or a single scaling factor that will scale both `x` and `y`.
 154 |   /**
 155 |    * @param {number} x The scaling factor in the x direction.
 156 |    * @param {?number=} y The scaling factor in the y direction.  If this
 157 |    *   is not specified, the x scaling factor will be used.
 158 |    * @return {Vector} This for chaining.
 159 |    */
 160 |   Vector.prototype['scale'] = Vector.prototype.scale = function (x, y) {
 161 |     this['x'] *= x;
 162 |     this['y'] *= typeof y != 'undefined' ? y : x;
 163 |     return this;
 164 |   };
 165 | 
 166 |   // Project this vector on to another vector.
 167 |   /**
 168 |    * @param {Vector} other The vector to project onto.
 169 |    * @return {Vector} This for chaining.
 170 |    */
 171 |   Vector.prototype['project'] = Vector.prototype.project = function (other) {
 172 |     var amt = this.dot(other) / other.len2();
 173 |     this['x'] = amt * other['x'];
 174 |     this['y'] = amt * other['y'];
 175 |     return this;
 176 |   };
 177 | 
 178 |   // Project this vector onto a vector of unit length. This is slightly more efficient
 179 |   // than `project` when dealing with unit vectors.
 180 |   /**
 181 |    * @param {Vector} other The unit vector to project onto.
 182 |    * @return {Vector} This for chaining.
 183 |    */
 184 |   Vector.prototype['projectN'] = Vector.prototype.projectN = function (other) {
 185 |     var amt = this.dot(other);
 186 |     this['x'] = amt * other['x'];
 187 |     this['y'] = amt * other['y'];
 188 |     return this;
 189 |   };
 190 | 
 191 |   // Reflect this vector on an arbitrary axis.
 192 |   /**
 193 |    * @param {Vector} axis The vector representing the axis.
 194 |    * @return {Vector} This for chaining.
 195 |    */
 196 |   Vector.prototype['reflect'] = Vector.prototype.reflect = function (axis) {
 197 |     var x = this['x'];
 198 |     var y = this['y'];
 199 |     this.project(axis).scale(2);
 200 |     this['x'] -= x;
 201 |     this['y'] -= y;
 202 |     return this;
 203 |   };
 204 | 
 205 |   // Reflect this vector on an arbitrary axis (represented by a unit vector). This is
 206 |   // slightly more efficient than `reflect` when dealing with an axis that is a unit vector.
 207 |   /**
 208 |    * @param {Vector} axis The unit vector representing the axis.
 209 |    * @return {Vector} This for chaining.
 210 |    */
 211 |   Vector.prototype['reflectN'] = Vector.prototype.reflectN = function (axis) {
 212 |     var x = this['x'];
 213 |     var y = this['y'];
 214 |     this.projectN(axis).scale(2);
 215 |     this['x'] -= x;
 216 |     this['y'] -= y;
 217 |     return this;
 218 |   };
 219 | 
 220 |   // Get the dot product of this vector and another.
 221 |   /**
 222 |    * @param {Vector}  other The vector to dot this one against.
 223 |    * @return {number} The dot product.
 224 |    */
 225 |   Vector.prototype['dot'] = Vector.prototype.dot = function (other) {
 226 |     return this['x'] * other['x'] + this['y'] * other['y'];
 227 |   };
 228 | 
 229 |   // Get the squared length of this vector.
 230 |   /**
 231 |    * @return {number} The length^2 of this vector.
 232 |    */
 233 |   Vector.prototype['len2'] = Vector.prototype.len2 = function () {
 234 |     return this.dot(this);
 235 |   };
 236 | 
 237 |   // Get the length of this vector.
 238 |   /**
 239 |    * @return {number} The length of this vector.
 240 |    */
 241 |   Vector.prototype['len'] = Vector.prototype.len = function () {
 242 |     return Math.sqrt(this.len2());
 243 |   };
 244 | 
 245 |   // ## Circle
 246 |   //
 247 |   // Represents a circle with a position and a radius.
 248 | 
 249 |   // Create a new circle, optionally passing in a position and/or radius. If no position
 250 |   // is given, the circle will be at `(0,0)`. If no radius is provided, the circle will
 251 |   // have a radius of `0`.
 252 |   /**
 253 |    * @param {Vector=} pos A vector representing the position of the center of the circle
 254 |    * @param {?number=} r The radius of the circle
 255 |    * @constructor
 256 |    */
 257 |   function Circle(pos, r) {
 258 |     this['pos'] = pos || new Vector();
 259 |     this['r'] = r || 0;
 260 |     this['offset'] = new Vector();
 261 |   }
 262 |   SAT['Circle'] = Circle;
 263 | 
 264 |   // Compute the axis-aligned bounding box (AABB) of this Circle.
 265 |   //
 266 |   // Note: Returns a _new_ `Box` each time you call this.
 267 |   /**
 268 |    * @return {Polygon} The AABB
 269 |    */
 270 |   Circle.prototype['getAABBAsBox'] = Circle.prototype.getAABBAsBox = function () {
 271 |     var r = this['r'];
 272 |     var corner = this['pos'].clone().add(this['offset']).sub(new Vector(r, r));
 273 |     return new Box(corner, r * 2, r * 2);
 274 |   };
 275 | 
 276 |   // Compute the axis-aligned bounding box (AABB) of this Circle.
 277 |   //
 278 |   // Note: Returns a _new_ `Polygon` each time you call this.
 279 |   /**
 280 |    * @return {Polygon} The AABB
 281 |    */
 282 |   Circle.prototype['getAABB'] = Circle.prototype.getAABB = function () {
 283 |     return this.getAABBAsBox().toPolygon();
 284 |   };
 285 | 
 286 |   // Set the current offset to apply to the radius.
 287 |   /**
 288 |    * @param {Vector} offset The new offset vector.
 289 |    * @return {Circle} This for chaining.
 290 |    */
 291 |   Circle.prototype['setOffset'] = Circle.prototype.setOffset = function (offset) {
 292 |     this['offset'] = offset;
 293 |     return this;
 294 |   };
 295 | 
 296 |   // ## Polygon
 297 |   //
 298 |   // Represents a *convex* polygon with any number of points (specified in counter-clockwise order)
 299 |   //
 300 |   // Note: Do _not_ manually change the `points`, `angle`, or `offset` properties. Use the
 301 |   // provided setters. Otherwise the calculated properties will not be updated correctly.
 302 |   //
 303 |   // `pos` can be changed directly.
 304 | 
 305 |   // Create a new polygon, passing in a position vector, and an array of points (represented
 306 |   // by vectors relative to the position vector). If no position is passed in, the position
 307 |   // of the polygon will be `(0,0)`.
 308 |   /**
 309 |    * @param {Vector=} pos A vector representing the origin of the polygon. (all other
 310 |    *   points are relative to this one)
 311 |    * @param {Array<Vector>=} points An array of vectors representing the points in the polygon,
 312 |    *   in counter-clockwise order.
 313 |    * @constructor
 314 |    */
 315 |   function Polygon(pos, points) {
 316 |     this['pos'] = pos || new Vector();
 317 |     this['angle'] = 0;
 318 |     this['offset'] = new Vector();
 319 |     this.setPoints(points || []);
 320 |   }
 321 |   SAT['Polygon'] = Polygon;
 322 | 
 323 |   // Set the points of the polygon. Any consecutive duplicate points will be combined.
 324 |   //
 325 |   // Note: The points are counter-clockwise *with respect to the coordinate system*.
 326 |   // If you directly draw the points on a screen that has the origin at the top-left corner
 327 |   // it will _appear_ visually that the points are being specified clockwise. This is just
 328 |   // because of the inversion of the Y-axis when being displayed.
 329 |   /**
 330 |    * @param {Array<Vector>=} points An array of vectors representing the points in the polygon,
 331 |    *   in counter-clockwise order.
 332 |    * @return {Polygon} This for chaining.
 333 |    */
 334 |   Polygon.prototype['setPoints'] = Polygon.prototype.setPoints = function (points) {
 335 |     // Only re-allocate if this is a new polygon or the number of points has changed.
 336 |     var lengthChanged = !this['points'] || this['points'].length !== points.length;
 337 |     if (lengthChanged) {
 338 |       var i;
 339 |       var calcPoints = this['calcPoints'] = [];
 340 |       var edges = this['edges'] = [];
 341 |       var normals = this['normals'] = [];
 342 |       // Allocate the vector arrays for the calculated properties
 343 |       for (i = 0; i < points.length; i++) {
 344 |         // Remove consecutive duplicate points
 345 |         var p1 = points[i];
 346 |         var p2 = i < points.length - 1 ? points[i + 1] : points[0];
 347 |         if (p1 !== p2 && p1.x === p2.x && p1.y === p2.y) {
 348 |           points.splice(i, 1);
 349 |           i -= 1;
 350 |           continue;
 351 |         }
 352 |         calcPoints.push(new Vector());
 353 |         edges.push(new Vector());
 354 |         normals.push(new Vector());
 355 |       }
 356 |     }
 357 |     this['points'] = points;
 358 |     this._recalc();
 359 |     return this;
 360 |   };
 361 | 
 362 |   // Set the current rotation angle of the polygon.
 363 |   /**
 364 |    * @param {number} angle The current rotation angle (in radians).
 365 |    * @return {Polygon} This for chaining.
 366 |    */
 367 |   Polygon.prototype['setAngle'] = Polygon.prototype.setAngle = function (angle) {
 368 |     this['angle'] = angle;
 369 |     this._recalc();
 370 |     return this;
 371 |   };
 372 | 
 373 |   // Set the current offset to apply to the `points` before applying the `angle` rotation.
 374 |   /**
 375 |    * @param {Vector} offset The new offset vector.
 376 |    * @return {Polygon} This for chaining.
 377 |    */
 378 |   Polygon.prototype['setOffset'] = Polygon.prototype.setOffset = function (offset) {
 379 |     this['offset'] = offset;
 380 |     this._recalc();
 381 |     return this;
 382 |   };
 383 | 
 384 |   // Rotates this polygon counter-clockwise around the origin of *its local coordinate system* (i.e. `pos`).
 385 |   //
 386 |   // Note: This changes the **original** points (so any `angle` will be applied on top of this rotation).
 387 |   /**
 388 |    * @param {number} angle The angle to rotate (in radians)
 389 |    * @return {Polygon} This for chaining.
 390 |    */
 391 |   Polygon.prototype['rotate'] = Polygon.prototype.rotate = function (angle) {
 392 |     var points = this['points'];
 393 |     var len = points.length;
 394 |     for (var i = 0; i < len; i++) {
 395 |       points[i].rotate(angle);
 396 |     }
 397 |     this._recalc();
 398 |     return this;
 399 |   };
 400 | 
 401 |   // Translates the points of this polygon by a specified amount relative to the origin of *its own coordinate
 402 |   // system* (i.e. `pos`).
 403 |   //
 404 |   // This is most useful to change the "center point" of a polygon. If you just want to move the whole polygon, change
 405 |   // the coordinates of `pos`.
 406 |   //
 407 |   // Note: This changes the **original** points (so any `offset` will be applied on top of this translation)
 408 |   /**
 409 |    * @param {number} x The horizontal amount to translate.
 410 |    * @param {number} y The vertical amount to translate.
 411 |    * @return {Polygon} This for chaining.
 412 |    */
 413 |   Polygon.prototype['translate'] = Polygon.prototype.translate = function (x, y) {
 414 |     var points = this['points'];
 415 |     var len = points.length;
 416 |     for (var i = 0; i < len; i++) {
 417 |       points[i]['x'] += x;
 418 |       points[i]['y'] += y;
 419 |     }
 420 |     this._recalc();
 421 |     return this;
 422 |   };
 423 | 
 424 | 
 425 |   // Computes the calculated collision polygon. Applies the `angle` and `offset` to the original points then recalculates the
 426 |   // edges and normals of the collision polygon.
 427 |   /**
 428 |    * @return {Polygon} This for chaining.
 429 |    */
 430 |   Polygon.prototype._recalc = function () {
 431 |     // Calculated points - this is what is used for underlying collisions and takes into account
 432 |     // the angle/offset set on the polygon.
 433 |     var calcPoints = this['calcPoints'];
 434 |     // The edges here are the direction of the `n`th edge of the polygon, relative to
 435 |     // the `n`th point. If you want to draw a given edge from the edge value, you must
 436 |     // first translate to the position of the starting point.
 437 |     var edges = this['edges'];
 438 |     // The normals here are the direction of the normal for the `n`th edge of the polygon, relative
 439 |     // to the position of the `n`th point. If you want to draw an edge normal, you must first
 440 |     // translate to the position of the starting point.
 441 |     var normals = this['normals'];
 442 |     // Copy the original points array and apply the offset/angle
 443 |     var points = this['points'];
 444 |     var offset = this['offset'];
 445 |     var angle = this['angle'];
 446 |     var len = points.length;
 447 |     var i;
 448 |     for (i = 0; i < len; i++) {
 449 |       var calcPoint = calcPoints[i].copy(points[i]);
 450 |       calcPoint['x'] += offset['x'];
 451 |       calcPoint['y'] += offset['y'];
 452 |       if (angle !== 0) {
 453 |         calcPoint.rotate(angle);
 454 |       }
 455 |     }
 456 |     // Calculate the edges/normals
 457 |     for (i = 0; i < len; i++) {
 458 |       var p1 = calcPoints[i];
 459 |       var p2 = i < len - 1 ? calcPoints[i + 1] : calcPoints[0];
 460 |       var e = edges[i].copy(p2).sub(p1);
 461 |       normals[i].copy(e).perp().normalize();
 462 |     }
 463 |     return this;
 464 |   };
 465 | 
 466 | 
 467 |   // Compute the axis-aligned bounding box. Any current state
 468 |   // (translations/rotations) will be applied before constructing the AABB.
 469 |   //
 470 |   // Note: Returns a _new_ `Box` each time you call this.
 471 |   /**
 472 |    * @return {Polygon} The AABB
 473 |    */
 474 |   Polygon.prototype['getAABBAsBox'] = Polygon.prototype.getAABBAsBox = function () {
 475 |     var points = this['calcPoints'];
 476 |     var len = points.length;
 477 |     var xMin = points[0]['x'];
 478 |     var yMin = points[0]['y'];
 479 |     var xMax = points[0]['x'];
 480 |     var yMax = points[0]['y'];
 481 |     for (var i = 1; i < len; i++) {
 482 |       var point = points[i];
 483 |       if (point['x'] < xMin) {
 484 |         xMin = point['x'];
 485 |       }
 486 |       else if (point['x'] > xMax) {
 487 |         xMax = point['x'];
 488 |       }
 489 |       if (point['y'] < yMin) {
 490 |         yMin = point['y'];
 491 |       }
 492 |       else if (point['y'] > yMax) {
 493 |         yMax = point['y'];
 494 |       }
 495 |     }
 496 |     return new Box(this['pos'].clone().add(new Vector(xMin, yMin)), xMax - xMin, yMax - yMin);
 497 |   };
 498 | 
 499 | 
 500 |   // Compute the axis-aligned bounding box. Any current state
 501 |   // (translations/rotations) will be applied before constructing the AABB.
 502 |   //
 503 |   // Note: Returns a _new_ `Polygon` each time you call this.
 504 |   /**
 505 |    * @return {Polygon} The AABB
 506 |    */
 507 |   Polygon.prototype['getAABB'] = Polygon.prototype.getAABB = function () {
 508 |     return this.getAABBAsBox().toPolygon();
 509 |   };
 510 | 
 511 |   // Compute the centroid (geometric center) of the polygon. Any current state
 512 |   // (translations/rotations) will be applied before computing the centroid.
 513 |   //
 514 |   // See https://en.wikipedia.org/wiki/Centroid#Centroid_of_a_polygon
 515 |   //
 516 |   // Note: Returns a _new_ `Vector` each time you call this.
 517 |   /**
 518 |    * @return {Vector} A Vector that contains the coordinates of the Centroid.
 519 |    */
 520 |   Polygon.prototype['getCentroid'] = Polygon.prototype.getCentroid = function () {
 521 |     var points = this['calcPoints'];
 522 |     var len = points.length;
 523 |     var cx = 0;
 524 |     var cy = 0;
 525 |     var ar = 0;
 526 |     for (var i = 0; i < len; i++) {
 527 |       var p1 = points[i];
 528 |       var p2 = i === len - 1 ? points[0] : points[i + 1]; // Loop around if last point
 529 |       var a = p1['x'] * p2['y'] - p2['x'] * p1['y'];
 530 |       cx += (p1['x'] + p2['x']) * a;
 531 |       cy += (p1['y'] + p2['y']) * a;
 532 |       ar += a;
 533 |     }
 534 |     ar = ar * 3; // we want 1 / 6 the area and we currently have 2*area
 535 |     cx = cx / ar;
 536 |     cy = cy / ar;
 537 |     return new Vector(cx, cy);
 538 |   };
 539 | 
 540 | 
 541 |   // ## Box
 542 |   //
 543 |   // Represents an axis-aligned box, with a width and height.
 544 | 
 545 | 
 546 |   // Create a new box, with the specified position, width, and height. If no position
 547 |   // is given, the position will be `(0,0)`. If no width or height are given, they will
 548 |   // be set to `0`.
 549 |   /**
 550 |    * @param {Vector=} pos A vector representing the bottom-left of the box (i.e. the smallest x and smallest y value).
 551 |    * @param {?number=} w The width of the box.
 552 |    * @param {?number=} h The height of the box.
 553 |    * @constructor
 554 |    */
 555 |   function Box(pos, w, h) {
 556 |     this['pos'] = pos || new Vector();
 557 |     this['w'] = w || 0;
 558 |     this['h'] = h || 0;
 559 |   }
 560 |   SAT['Box'] = Box;
 561 | 
 562 |   // Returns a polygon whose edges are the same as this box.
 563 |   /**
 564 |    * @return {Polygon} A new Polygon that represents this box.
 565 |    */
 566 |   Box.prototype['toPolygon'] = Box.prototype.toPolygon = function () {
 567 |     var pos = this['pos'];
 568 |     var w = this['w'];
 569 |     var h = this['h'];
 570 |     return new Polygon(new Vector(pos['x'], pos['y']), [
 571 |       new Vector(), new Vector(w, 0),
 572 |       new Vector(w, h), new Vector(0, h)
 573 |     ]);
 574 |   };
 575 | 
 576 |   // ## Response
 577 |   //
 578 |   // An object representing the result of an intersection. Contains:
 579 |   //  - The two objects participating in the intersection
 580 |   //  - The vector representing the minimum change necessary to extract the first object
 581 |   //    from the second one (as well as a unit vector in that direction and the magnitude
 582 |   //    of the overlap)
 583 |   //  - Whether the first object is entirely inside the second, and vice versa.
 584 |   /**
 585 |    * @constructor
 586 |    */
 587 |   function Response() {
 588 |     this['a'] = null;
 589 |     this['b'] = null;
 590 |     this['overlapN'] = new Vector();
 591 |     this['overlapV'] = new Vector();
 592 |     this.clear();
 593 |   }
 594 |   SAT['Response'] = Response;
 595 | 
 596 |   // Set some values of the response back to their defaults.  Call this between tests if
 597 |   // you are going to reuse a single Response object for multiple intersection tests (recommented
 598 |   // as it will avoid allcating extra memory)
 599 |   /**
 600 |    * @return {Response} This for chaining
 601 |    */
 602 |   Response.prototype['clear'] = Response.prototype.clear = function () {
 603 |     this['aInB'] = true;
 604 |     this['bInA'] = true;
 605 |     this['overlap'] = Number.MAX_VALUE;
 606 |     return this;
 607 |   };
 608 | 
 609 |   // ## Object Pools
 610 | 
 611 |   // A pool of `Vector` objects that are used in calculations to avoid
 612 |   // allocating memory.
 613 |   /**
 614 |    * @type {Array<Vector>}
 615 |    */
 616 |   var T_VECTORS = [];
 617 |   for (var i = 0; i < 10; i++) { T_VECTORS.push(new Vector()); }
 618 | 
 619 |   // A pool of arrays of numbers used in calculations to avoid allocating
 620 |   // memory.
 621 |   /**
 622 |    * @type {Array<Array<number>>}
 623 |    */
 624 |   var T_ARRAYS = [];
 625 |   for (var i = 0; i < 5; i++) { T_ARRAYS.push([]); }
 626 | 
 627 |   // Temporary response used for polygon hit detection.
 628 |   /**
 629 |    * @type {Response}
 630 |    */
 631 |   var T_RESPONSE = new Response();
 632 | 
 633 |   // Tiny "point" polygon used for polygon hit detection.
 634 |   /**
 635 |    * @type {Polygon}
 636 |    */
 637 |   var TEST_POINT = new Box(new Vector(), 0.000001, 0.000001).toPolygon();
 638 | 
 639 |   // ## Helper Functions
 640 | 
 641 |   // Flattens the specified array of points onto a unit vector axis,
 642 |   // resulting in a one dimensional range of the minimum and
 643 |   // maximum value on that axis.
 644 |   /**
 645 |    * @param {Array<Vector>} points The points to flatten.
 646 |    * @param {Vector} normal The unit vector axis to flatten on.
 647 |    * @param {Array<number>} result An array.  After calling this function,
 648 |    *   result[0] will be the minimum value,
 649 |    *   result[1] will be the maximum value.
 650 |    */
 651 |   function flattenPointsOn(points, normal, result) {
 652 |     var min = Number.MAX_VALUE;
 653 |     var max = -Number.MAX_VALUE;
 654 |     var len = points.length;
 655 |     for (var i = 0; i < len; i++) {
 656 |       // The magnitude of the projection of the point onto the normal
 657 |       var dot = points[i].dot(normal);
 658 |       if (dot < min) { min = dot; }
 659 |       if (dot > max) { max = dot; }
 660 |     }
 661 |     result[0] = min; result[1] = max;
 662 |   }
 663 | 
 664 |   // Check whether two convex polygons are separated by the specified
 665 |   // axis (must be a unit vector).
 666 |   /**
 667 |    * @param {Vector} aPos The position of the first polygon.
 668 |    * @param {Vector} bPos The position of the second polygon.
 669 |    * @param {Array<Vector>} aPoints The points in the first polygon.
 670 |    * @param {Array<Vector>} bPoints The points in the second polygon.
 671 |    * @param {Vector} axis The axis (unit sized) to test against.  The points of both polygons
 672 |    *   will be projected onto this axis.
 673 |    * @param {Response=} response A Response object (optional) which will be populated
 674 |    *   if the axis is not a separating axis.
 675 |    * @return {boolean} true if it is a separating axis, false otherwise.  If false,
 676 |    *   and a response is passed in, information about how much overlap and
 677 |    *   the direction of the overlap will be populated.
 678 |    */
 679 |   function isSeparatingAxis(aPos, bPos, aPoints, bPoints, axis, response) {
 680 |     var rangeA = T_ARRAYS.pop();
 681 |     var rangeB = T_ARRAYS.pop();
 682 |     // The magnitude of the offset between the two polygons
 683 |     var offsetV = T_VECTORS.pop().copy(bPos).sub(aPos);
 684 |     var projectedOffset = offsetV.dot(axis);
 685 |     // Project the polygons onto the axis.
 686 |     flattenPointsOn(aPoints, axis, rangeA);
 687 |     flattenPointsOn(bPoints, axis, rangeB);
 688 |     // Move B's range to its position relative to A.
 689 |     rangeB[0] += projectedOffset;
 690 |     rangeB[1] += projectedOffset;
 691 |     // Check if there is a gap. If there is, this is a separating axis and we can stop
 692 |     if (rangeA[0] > rangeB[1] || rangeB[0] > rangeA[1]) {
 693 |       T_VECTORS.push(offsetV);
 694 |       T_ARRAYS.push(rangeA);
 695 |       T_ARRAYS.push(rangeB);
 696 |       return true;
 697 |     }
 698 |     // This is not a separating axis. If we're calculating a response, calculate the overlap.
 699 |     if (response) {
 700 |       var overlap = 0;
 701 |       // A starts further left than B
 702 |       if (rangeA[0] < rangeB[0]) {
 703 |         response['aInB'] = false;
 704 |         // A ends before B does. We have to pull A out of B
 705 |         if (rangeA[1] < rangeB[1]) {
 706 |           overlap = rangeA[1] - rangeB[0];
 707 |           response['bInA'] = false;
 708 |           // B is fully inside A.  Pick the shortest way out.
 709 |         } else {
 710 |           var option1 = rangeA[1] - rangeB[0];
 711 |           var option2 = rangeB[1] - rangeA[0];
 712 |           overlap = option1 < option2 ? option1 : -option2;
 713 |         }
 714 |         // B starts further left than A
 715 |       } else {
 716 |         response['bInA'] = false;
 717 |         // B ends before A ends. We have to push A out of B
 718 |         if (rangeA[1] > rangeB[1]) {
 719 |           overlap = rangeA[0] - rangeB[1];
 720 |           response['aInB'] = false;
 721 |           // A is fully inside B.  Pick the shortest way out.
 722 |         } else {
 723 |           var option1 = rangeA[1] - rangeB[0];
 724 |           var option2 = rangeB[1] - rangeA[0];
 725 |           overlap = option1 < option2 ? option1 : -option2;
 726 |         }
 727 |       }
 728 |       // If this is the smallest amount of overlap we've seen so far, set it as the minimum overlap.
 729 |       var absOverlap = Math.abs(overlap);
 730 |       if (absOverlap < response['overlap']) {
 731 |         response['overlap'] = absOverlap;
 732 |         response['overlapN'].copy(axis);
 733 |         if (overlap < 0) {
 734 |           response['overlapN'].reverse();
 735 |         }
 736 |       }
 737 |     }
 738 |     T_VECTORS.push(offsetV);
 739 |     T_ARRAYS.push(rangeA);
 740 |     T_ARRAYS.push(rangeB);
 741 |     return false;
 742 |   }
 743 |   SAT['isSeparatingAxis'] = isSeparatingAxis;
 744 | 
 745 |   // Calculates which Voronoi region a point is on a line segment.
 746 |   // It is assumed that both the line and the point are relative to `(0,0)`
 747 |   //
 748 |   //            |       (0)      |
 749 |   //     (-1)  [S]--------------[E]  (1)
 750 |   //            |       (0)      |
 751 |   /**
 752 |    * @param {Vector} line The line segment.
 753 |    * @param {Vector} point The point.
 754 |    * @return  {number} LEFT_VORONOI_REGION (-1) if it is the left region,
 755 |    *          MIDDLE_VORONOI_REGION (0) if it is the middle region,
 756 |    *          RIGHT_VORONOI_REGION (1) if it is the right region.
 757 |    */
 758 |   function voronoiRegion(line, point) {
 759 |     var len2 = line.len2();
 760 |     var dp = point.dot(line);
 761 |     // If the point is beyond the start of the line, it is in the
 762 |     // left voronoi region.
 763 |     if (dp < 0) { return LEFT_VORONOI_REGION; }
 764 |     // If the point is beyond the end of the line, it is in the
 765 |     // right voronoi region.
 766 |     else if (dp > len2) { return RIGHT_VORONOI_REGION; }
 767 |     // Otherwise, it's in the middle one.
 768 |     else { return MIDDLE_VORONOI_REGION; }
 769 |   }
 770 |   // Constants for Voronoi regions
 771 |   /**
 772 |    * @const
 773 |    */
 774 |   var LEFT_VORONOI_REGION = -1;
 775 |   /**
 776 |    * @const
 777 |    */
 778 |   var MIDDLE_VORONOI_REGION = 0;
 779 |   /**
 780 |    * @const
 781 |    */
 782 |   var RIGHT_VORONOI_REGION = 1;
 783 | 
 784 |   // ## Collision Tests
 785 | 
 786 |   // Check if a point is inside a circle.
 787 |   /**
 788 |    * @param {Vector} p The point to test.
 789 |    * @param {Circle} c The circle to test.
 790 |    * @return {boolean} true if the point is inside the circle, false if it is not.
 791 |    */
 792 |   function pointInCircle(p, c) {
 793 |     var differenceV = T_VECTORS.pop().copy(p).sub(c['pos']).sub(c['offset']);
 794 |     var radiusSq = c['r'] * c['r'];
 795 |     var distanceSq = differenceV.len2();
 796 |     T_VECTORS.push(differenceV);
 797 |     // If the distance between is smaller than the radius then the point is inside the circle.
 798 |     return distanceSq <= radiusSq;
 799 |   }
 800 |   SAT['pointInCircle'] = pointInCircle;
 801 | 
 802 |   // Check if a point is inside a convex polygon.
 803 |   /**
 804 |    * @param {Vector} p The point to test.
 805 |    * @param {Polygon} poly The polygon to test.
 806 |    * @return {boolean} true if the point is inside the polygon, false if it is not.
 807 |    */
 808 |   function pointInPolygon(p, poly) {
 809 |     TEST_POINT['pos'].copy(p);
 810 |     T_RESPONSE.clear();
 811 |     var result = testPolygonPolygon(TEST_POINT, poly, T_RESPONSE);
 812 |     if (result) {
 813 |       result = T_RESPONSE['aInB'];
 814 |     }
 815 |     return result;
 816 |   }
 817 |   SAT['pointInPolygon'] = pointInPolygon;
 818 | 
 819 |   // Check if two circles collide.
 820 |   /**
 821 |    * @param {Circle} a The first circle.
 822 |    * @param {Circle} b The second circle.
 823 |    * @param {Response=} response Response object (optional) that will be populated if
 824 |    *   the circles intersect.
 825 |    * @return {boolean} true if the circles intersect, false if they don't.
 826 |    */
 827 |   function testCircleCircle(a, b, response) {
 828 |     // Check if the distance between the centers of the two
 829 |     // circles is greater than their combined radius.
 830 |     var differenceV = T_VECTORS.pop().copy(b['pos']).add(b['offset']).sub(a['pos']).sub(a['offset']);
 831 |     var totalRadius = a['r'] + b['r'];
 832 |     var totalRadiusSq = totalRadius * totalRadius;
 833 |     var distanceSq = differenceV.len2();
 834 |     // If the distance is bigger than the combined radius, they don't intersect.
 835 |     if (distanceSq > totalRadiusSq) {
 836 |       T_VECTORS.push(differenceV);
 837 |       return false;
 838 |     }
 839 |     // They intersect.  If we're calculating a response, calculate the overlap.
 840 |     if (response) {
 841 |       var dist = Math.sqrt(distanceSq);
 842 |       response['a'] = a;
 843 |       response['b'] = b;
 844 |       response['overlap'] = totalRadius - dist;
 845 |       response['overlapN'].copy(differenceV.normalize());
 846 |       response['overlapV'].copy(differenceV).scale(response['overlap']);
 847 |       response['aInB'] = a['r'] <= b['r'] && dist <= b['r'] - a['r'];
 848 |       response['bInA'] = b['r'] <= a['r'] && dist <= a['r'] - b['r'];
 849 |     }
 850 |     T_VECTORS.push(differenceV);
 851 |     return true;
 852 |   }
 853 |   SAT['testCircleCircle'] = testCircleCircle;
 854 | 
 855 |   // Check if a polygon and a circle collide.
 856 |   /**
 857 |    * @param {Polygon} polygon The polygon.
 858 |    * @param {Circle} circle The circle.
 859 |    * @param {Response=} response Response object (optional) that will be populated if
 860 |    *   they interset.
 861 |    * @return {boolean} true if they intersect, false if they don't.
 862 |    */
 863 |   function testPolygonCircle(polygon, circle, response) {
 864 |     // Get the position of the circle relative to the polygon.
 865 |     var circlePos = T_VECTORS.pop().copy(circle['pos']).add(circle['offset']).sub(polygon['pos']);
 866 |     var radius = circle['r'];
 867 |     var radius2 = radius * radius;
 868 |     var points = polygon['calcPoints'];
 869 |     var len = points.length;
 870 |     var edge = T_VECTORS.pop();
 871 |     var point = T_VECTORS.pop();
 872 | 
 873 |     // For each edge in the polygon:
 874 |     for (var i = 0; i < len; i++) {
 875 |       var next = i === len - 1 ? 0 : i + 1;
 876 |       var prev = i === 0 ? len - 1 : i - 1;
 877 |       var overlap = 0;
 878 |       var overlapN = null;
 879 | 
 880 |       // Get the edge.
 881 |       edge.copy(polygon['edges'][i]);
 882 |       // Calculate the center of the circle relative to the starting point of the edge.
 883 |       point.copy(circlePos).sub(points[i]);
 884 | 
 885 |       // If the distance between the center of the circle and the point
 886 |       // is bigger than the radius, the polygon is definitely not fully in
 887 |       // the circle.
 888 |       if (response && point.len2() > radius2) {
 889 |         response['aInB'] = false;
 890 |       }
 891 | 
 892 |       // Calculate which Voronoi region the center of the circle is in.
 893 |       var region = voronoiRegion(edge, point);
 894 |       // If it's the left region:
 895 |       if (region === LEFT_VORONOI_REGION) {
 896 |         // We need to make sure we're in the RIGHT_VORONOI_REGION of the previous edge.
 897 |         edge.copy(polygon['edges'][prev]);
 898 |         // Calculate the center of the circle relative the starting point of the previous edge
 899 |         var point2 = T_VECTORS.pop().copy(circlePos).sub(points[prev]);
 900 |         region = voronoiRegion(edge, point2);
 901 |         if (region === RIGHT_VORONOI_REGION) {
 902 |           // It's in the region we want.  Check if the circle intersects the point.
 903 |           var dist = point.len();
 904 |           if (dist > radius) {
 905 |             // No intersection
 906 |             T_VECTORS.push(circlePos);
 907 |             T_VECTORS.push(edge);
 908 |             T_VECTORS.push(point);
 909 |             T_VECTORS.push(point2);
 910 |             return false;
 911 |           } else if (response) {
 912 |             // It intersects, calculate the overlap.
 913 |             response['bInA'] = false;
 914 |             overlapN = point.normalize();
 915 |             overlap = radius - dist;
 916 |           }
 917 |         }
 918 |         T_VECTORS.push(point2);
 919 |         // If it's the right region:
 920 |       } else if (region === RIGHT_VORONOI_REGION) {
 921 |         // We need to make sure we're in the left region on the next edge
 922 |         edge.copy(polygon['edges'][next]);
 923 |         // Calculate the center of the circle relative to the starting point of the next edge.
 924 |         point.copy(circlePos).sub(points[next]);
 925 |         region = voronoiRegion(edge, point);
 926 |         if (region === LEFT_VORONOI_REGION) {
 927 |           // It's in the region we want.  Check if the circle intersects the point.
 928 |           var dist = point.len();
 929 |           if (dist > radius) {
 930 |             // No intersection
 931 |             T_VECTORS.push(circlePos);
 932 |             T_VECTORS.push(edge);
 933 |             T_VECTORS.push(point);
 934 |             return false;
 935 |           } else if (response) {
 936 |             // It intersects, calculate the overlap.
 937 |             response['bInA'] = false;
 938 |             overlapN = point.normalize();
 939 |             overlap = radius - dist;
 940 |           }
 941 |         }
 942 |         // Otherwise, it's the middle region:
 943 |       } else {
 944 |         // Need to check if the circle is intersecting the edge,
 945 |         // Change the edge into its "edge normal".
 946 |         var normal = edge.perp().normalize();
 947 |         // Find the perpendicular distance between the center of the
 948 |         // circle and the edge.
 949 |         var dist = point.dot(normal);
 950 |         var distAbs = Math.abs(dist);
 951 |         // If the circle is on the outside of the edge, there is no intersection.
 952 |         if (dist > 0 && distAbs > radius) {
 953 |           // No intersection
 954 |           T_VECTORS.push(circlePos);
 955 |           T_VECTORS.push(normal);
 956 |           T_VECTORS.push(point);
 957 |           return false;
 958 |         } else if (response) {
 959 |           // It intersects, calculate the overlap.
 960 |           overlapN = normal;
 961 |           overlap = radius - dist;
 962 |           // If the center of the circle is on the outside of the edge, or part of the
 963 |           // circle is on the outside, the circle is not fully inside the polygon.
 964 |           if (dist >= 0 || overlap < 2 * radius) {
 965 |             response['bInA'] = false;
 966 |           }
 967 |         }
 968 |       }
 969 | 
 970 |       // If this is the smallest overlap we've seen, keep it.
 971 |       // (overlapN may be null if the circle was in the wrong Voronoi region).
 972 |       if (overlapN && response && Math.abs(overlap) < Math.abs(response['overlap'])) {
 973 |         response['overlap'] = overlap;
 974 |         response['overlapN'].copy(overlapN);
 975 |       }
 976 |     }
 977 | 
 978 |     // Calculate the final overlap vector - based on the smallest overlap.
 979 |     if (response) {
 980 |       response['a'] = polygon;
 981 |       response['b'] = circle;
 982 |       response['overlapV'].copy(response['overlapN']).scale(response['overlap']);
 983 |     }
 984 |     T_VECTORS.push(circlePos);
 985 |     T_VECTORS.push(edge);
 986 |     T_VECTORS.push(point);
 987 |     return true;
 988 |   }
 989 |   SAT['testPolygonCircle'] = testPolygonCircle;
 990 | 
 991 |   // Check if a circle and a polygon collide.
 992 |   //
 993 |   // **NOTE:** This is slightly less efficient than polygonCircle as it just
 994 |   // runs polygonCircle and reverses everything at the end.
 995 |   /**
 996 |    * @param {Circle} circle The circle.
 997 |    * @param {Polygon} polygon The polygon.
 998 |    * @param {Response=} response Response object (optional) that will be populated if
 999 |    *   they interset.
1000 |    * @return {boolean} true if they intersect, false if they don't.
1001 |    */
1002 |   function testCirclePolygon(circle, polygon, response) {
1003 |     // Test the polygon against the circle.
1004 |     var result = testPolygonCircle(polygon, circle, response);
1005 |     if (result && response) {
1006 |       // Swap A and B in the response.
1007 |       var a = response['a'];
1008 |       var aInB = response['aInB'];
1009 |       response['overlapN'].reverse();
1010 |       response['overlapV'].reverse();
1011 |       response['a'] = response['b'];
1012 |       response['b'] = a;
1013 |       response['aInB'] = response['bInA'];
1014 |       response['bInA'] = aInB;
1015 |     }
1016 |     return result;
1017 |   }
1018 |   SAT['testCirclePolygon'] = testCirclePolygon;
1019 | 
1020 |   // Checks whether polygons collide.
1021 |   /**
1022 |    * @param {Polygon} a The first polygon.
1023 |    * @param {Polygon} b The second polygon.
1024 |    * @param {Response=} response Response object (optional) that will be populated if
1025 |    *   they interset.
1026 |    * @return {boolean} true if they intersect, false if they don't.
1027 |    */
1028 |   function testPolygonPolygon(a, b, response) {
1029 |     var aPoints = a['calcPoints'];
1030 |     var aLen = aPoints.length;
1031 |     var bPoints = b['calcPoints'];
1032 |     var bLen = bPoints.length;
1033 |     // If any of the edge normals of A is a separating axis, no intersection.
1034 |     for (var i = 0; i < aLen; i++) {
1035 |       if (isSeparatingAxis(a['pos'], b['pos'], aPoints, bPoints, a['normals'][i], response)) {
1036 |         return false;
1037 |       }
1038 |     }
1039 |     // If any of the edge normals of B is a separating axis, no intersection.
1040 |     for (var i = 0; i < bLen; i++) {
1041 |       if (isSeparatingAxis(a['pos'], b['pos'], aPoints, bPoints, b['normals'][i], response)) {
1042 |         return false;
1043 |       }
1044 |     }
1045 |     // Since none of the edge normals of A or B are a separating axis, there is an intersection
1046 |     // and we've already calculated the smallest overlap (in isSeparatingAxis).  Calculate the
1047 |     // final overlap vector.
1048 |     if (response) {
1049 |       response['a'] = a;
1050 |       response['b'] = b;
1051 |       response['overlapV'].copy(response['overlapN']).scale(response['overlap']);
1052 |     }
1053 |     return true;
1054 |   }
1055 |   SAT['testPolygonPolygon'] = testPolygonPolygon;
1056 | 
1057 |   return SAT;
1058 | }));
1059 | 


--------------------------------------------------------------------------------
/examples/dynamic_collision.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <title>SAT.js - Simple Collision Examples</title>
 5 |     <script src="../SAT.js"></script>
 6 |     <script src="http://cdnjs.cloudflare.com/ajax/libs/raphael/2.1.2/raphael-min.js"></script>
 7 |     <script src="http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.5.2/underscore-min.js"></script>
 8 |     <script src="examples.js"></script>
 9 |   </head>
10 |   <body style="margin: 50px">
11 |     <h1>Dynamic Collision Examples</h1>
12 | 
13 |     <h2>Dynamic response</h2>
14 |     <p>Drag the shapes around. If they collide they will be moved so that they don't collide.  The circle is "heavy" - it will not be moved by other items (but will move other items)</p>
15 |     <div id="example1" style="border: 1px solid #CCC; width: 640px; height: 480px;"></div>
16 |     <script>
17 |     (function () {
18 |       var canvas = Raphael('example1', 640, 480);
19 |       var world = new World(canvas);
20 |       var poly = world.addEntity(P(V(160,120), [V(0,0), V(60, 0), V(100, 40), V(60, 80), V(0, 80)]).translate(-50, -40), { solid: true, draggable: true });
21 |       var poly2 = world.addEntity(P(V(10,10), [V(0,0), V(30, 0), V(30, 30), V(0, 30)]), { solid: true, draggable: true });
22 |       var circle1 = world.addEntity(C(V(50, 200), 30), { solid: true, heavy: true, draggable: true });
23 |       function doRotate() {
24 |         poly.data.setAngle(poly.data.angle + (Math.PI / 60)); // Assuming 60fps this will take ~2 seconds for a full rotation
25 |         world.simulate();
26 |         window.requestAnimationFrame(doRotate);
27 |       }
28 |       window.requestAnimationFrame(doRotate);
29 |     }());
30 |     </script>
31 | 
32 |     <h2>Lots of circles, all collidable with each other.</h2>
33 |     <p>Drag any of the circles and watch them react.</p>
34 |     <div id="example2" style="border: 1px solid #CCC; width: 640px; height: 640px;"></div>
35 |     <script>
36 |     (function () {
37 |       var canvas = Raphael('example2', 640, 640);
38 |       var world = new World(canvas, {
39 |         loopCount: 5
40 |       });
41 |       for (var i = 0; i < 16; i++) {
42 |         for (var j = 0; j < 16; j++) {
43 |           var displayAttrs = {
44 |             fill: 'rgba(' + Math.floor(Math.random() * 255) + ',' +  Math.floor(Math.random() * 255) + ',' +  Math.floor(Math.random() * 255) + ')'
45 |           }
46 |           var c = world.addEntity(C(V((40 * i) + 20, (40 * j) + 20), 18), { solid: true, draggable: true, displayAttrs: displayAttrs });
47 |         }
48 |       }
49 |     }());
50 |     </script>
51 | 
52 |   </body>
53 | </html>


--------------------------------------------------------------------------------
/examples/examples.js:
--------------------------------------------------------------------------------
  1 | // Alias a few things in SAT.js to make the code shorter
  2 | var V = function (x, y) { return new SAT.Vector(x, y); };
  3 | var P = function (pos, points) { return new SAT.Polygon(pos, points); };
  4 | var C = function (pos, r) { return new SAT.Circle(pos, r); };
  5 | var B = function (pos, w, h) { return new SAT.Box(pos, w, h); };
  6 | 
  7 | // Converts a SAT.Polygon into a SVG path string.
  8 | function poly2path(polygon) {
  9 |   var pos = polygon.pos;
 10 |   var points = polygon.calcPoints;
 11 |   var result = 'M' + pos.x + ' ' + pos.y;
 12 |   result += 'M' + (pos.x + points[0].x) + ' ' + (pos.y + points[0].y);
 13 |   for (var i = 1; i < points.length; i++) {
 14 |     var point = points[i];
 15 |     result += 'L' + (pos.x + point.x) + ' ' + (pos.y + point.y);
 16 |   }
 17 |   result += 'Z';
 18 |   return result;
 19 | }
 20 | 
 21 | // Create a Raphael start drag handler for specified entity
 22 | function startDrag(entity) {
 23 |   return function () {
 24 |     this.ox = entity.data.pos.x;
 25 |     this.oy = entity.data.pos.y;
 26 |   };
 27 | }
 28 | // Create a Raphael move drag handler for specified entity
 29 | function moveDrag(entity, world) {
 30 |   return function (dx, dy) {
 31 |     // This position updating is fairly naive - it lets objects tunnel through each other, but it suffices for these examples.
 32 |     entity.data.pos.x = this.ox + dx;
 33 |     entity.data.pos.y = this.oy + dy;
 34 |     world.simulate();
 35 |   };
 36 | }
 37 | // Create a Raphael end drag handler for specified entity
 38 | function endDrag(entity) {
 39 |   return function () {
 40 |     entity.updateDisplay();
 41 |   };
 42 | }
 43 | 
 44 | var idCounter = 0;
 45 | 
 46 | function noop() {}
 47 | 
 48 | function Entity(data, display, options) {
 49 |   options = _.defaults(options || {}, {
 50 |     solid: false, // Whether this object is "solid" and therefore should participate in responses.
 51 |     heavy: false, // Whether this object is "heavy" and can't be moved by other objects.
 52 |     displayAttrs: {}, // Raphael attrs to set on the display object
 53 |     onCollide: noop, // Function to execute when this entity collides with another - arguments are (otherEntity, response)
 54 |     onTick: noop // Function called at the start of every simulation tick - no arguments
 55 |   });
 56 |   this.id = idCounter++;
 57 |   this.data = data;
 58 |   this.display = display;
 59 |   this.displayAttrs = _.extend({
 60 |     fill: '#CCC',
 61 |     stroke: '#000'
 62 |   }, options.displayAttrs);
 63 |   this.isSolid = options.solid;
 64 |   this.isHeavy = options.heavy;
 65 |   this.onCollide = options.onCollide;
 66 |   this.onTick = options.onTick;
 67 | }
 68 | Entity.prototype = {
 69 |   remove: function () {
 70 |     this.display.remove();
 71 |   },
 72 |   // Call this to update the display after changing the underlying data.
 73 |   updateDisplay: function () {
 74 |     if (this.data instanceof SAT.Circle) {
 75 |       this.displayAttrs.cx = this.data.pos.x;
 76 |       this.displayAttrs.cy = this.data.pos.y;
 77 |       this.displayAttrs.r = this.data.r;
 78 |     } else {
 79 |       this.displayAttrs.path = poly2path(this.data);
 80 |     }
 81 |     this.display.attr(this.displayAttrs);
 82 |   },
 83 |   tick: function () {
 84 |     this.onTick();
 85 |   },
 86 |   respondToCollision: function (other, response) {
 87 |     this.onCollide(other, response);
 88 |     // Collisions between "ghostly" objects don't matter, and
 89 |     // two "heavy" objects will just remain where they are.
 90 |     if (this.isSolid && other.isSolid &&
 91 |       !(this.isHeavy && other.isHeavy)) {
 92 |       if (this.isHeavy) {
 93 |         // Move the other object out of us
 94 |         other.data.pos.add(response.overlapV);
 95 |       } else if (other.isHeavy) {
 96 |         // Move us out of the other object
 97 |         this.data.pos.sub(response.overlapV);
 98 |       } else {
 99 |         // Move equally out of each other
100 |         response.overlapV.scale(0.5);
101 |         this.data.pos.sub(response.overlapV);
102 |         other.data.pos.add(response.overlapV);
103 |       }
104 |     }
105 |   }
106 | };
107 | 
108 | function World(canvas, options) {
109 |   options = _.defaults(options || {},  {
110 |     loopCount: 1 // number of loops to do each time simulation is called. The higher the more accurate the simulation, but slowers.
111 |   });
112 |   this.canvas = canvas; // A raphael.js canvas
113 |   this.response = new SAT.Response(); // Response reused for collisions
114 |   this.loopCount = options.loopCount;
115 |   this.entities = {};
116 | }
117 | World.prototype = {
118 |   addEntity: function(data, options) {
119 |     var entity = new Entity(
120 |       data,
121 |       data instanceof SAT.Circle ? this.canvas.circle() : this.canvas.path(),
122 |       options
123 |     );
124 |     // Make the display item draggable if requested.
125 |     if (options.draggable) {
126 |       entity.display.drag(moveDrag(entity, this), startDrag(entity), endDrag(entity));
127 |     }
128 |     entity.updateDisplay();
129 |     this.entities[entity.id] = entity;
130 |     return entity;
131 |   },
132 |   removeEntity: function (entity) {
133 |     entity.remove();
134 |     delete this.entities[entity.id];
135 |   },
136 |   simulate: function () {
137 |     var entities = _.values(this.entities);
138 |     var entitiesLen = entities.length;
139 |     // Let the entity do something every simulation tick
140 |     _.each(entities, function (entity) {
141 |       entity.tick();
142 |     });
143 |     // Handle collisions - loop a configurable number of times to let things "settle"
144 |     var loopCount = this.loopCount;
145 |     for (var i = 0; i < loopCount; i++) {
146 |       // Naively check for collision between all pairs of entities 
147 |       // E.g if there are 4 entities: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)
148 |       for (var aCount = 0; aCount < entitiesLen; aCount++) {
149 |         var a = entities[aCount];
150 |         for (var bCount = aCount + 1; bCount < entitiesLen; bCount++) {
151 |           var b = entities[bCount];
152 |           this.response.clear();
153 |           var collided;
154 |           var aData = a.data;
155 |           var bData = b.data;
156 |           if (aData instanceof SAT.Circle) {
157 |             if (bData instanceof SAT.Circle) {
158 |               collided = SAT.testCircleCircle(aData, bData, this.response);
159 |             } else {
160 |               collided = SAT.testCirclePolygon(aData, bData, this.response);
161 |             }
162 |           } else {
163 |             if (bData instanceof SAT.Circle) {
164 |               collided = SAT.testPolygonCircle(aData, bData, this.response);
165 |             } else {
166 |               collided = SAT.testPolygonPolygon(aData, bData, this.response);
167 |             }
168 |           }
169 |           if (collided) {
170 |             a.respondToCollision(b, this.response);
171 |           }
172 |         }
173 |       }
174 |     }
175 |     // Finally, update the display of each entity now that the simulation step is done.
176 |     _.each(entities, function (entity) {
177 |       entity.updateDisplay();
178 |     });
179 |   }
180 | };


--------------------------------------------------------------------------------
/examples/simple_collision.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <title>SAT.js - Simple Collision Examples</title>
 5 |     <script src="http://cdnjs.cloudflare.com/ajax/libs/raphael/2.1.2/raphael-min.js"></script>
 6 |     <script src="http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.5.2/underscore-min.js"></script>
 7 |     <script src="../SAT.js"></script>
 8 |     <script src="examples.js"></script>
 9 |     <script>
10 |     // Simple onCollide handler that changes colors of displayed items.
11 |     function displayCollision(other, response) {
12 |       this.displayAttrs.fill = response.aInB ? '#0F0' : '#F00';
13 |       other.displayAttrs.fill = response.bInA ? '#0F0' : '#F00';
14 |     }
15 |     // onTick handler that restores "non collided" color
16 |     function restoreNoCollisionColors() {
17 |       this.displayAttrs.fill = '#CCC';
18 |     }
19 |     // Default entity options that will just highlight entities when they overlap
20 |     var defaultEntityOptions = {
21 |       solid: false,
22 |       draggable: true,
23 |       onCollide: displayCollision,
24 |       onTick: restoreNoCollisionColors
25 |     };
26 |     </script>
27 |   </head>
28 |   <body style="margin: 50px">
29 |     <h1>Simple Collision Examples</h1>
30 |     <p>Drag the shapes around. The shapes will turn red when they are colliding. The smaller shape will turn green if it is completely inside the larger one.</p>
31 |     <h2>Circle-Circle collision</h2>
32 |     <div id="example1" style="border: 1px solid #CCC; width: 320px; height: 240px;"></div>
33 |     <script>
34 |     (function () {
35 |       var canvas = Raphael('example1', 320, 240);
36 |       var world = new World(canvas);
37 |       var circle1 = world.addEntity(C(V(160, 120), 30), defaultEntityOptions);
38 |       var circle2 = world.addEntity(C(V(30,30), 10), defaultEntityOptions);
39 |     }());
40 |     </script>
41 | 
42 |     <h2>Circle-Polygon Collision</h2>
43 |     <div id="example2" style="border: 1px solid #CCC; width: 320px; height: 240px;"></div>
44 |     <script>
45 |     (function () {
46 |       var canvas = Raphael('example2', 320, 240);
47 |       var world = new World(canvas);
48 |       var poly = world.addEntity(P(V(160,120), [V(0,0), V(60, 0), V(100, 40), V(60, 80), V(0, 80)]), defaultEntityOptions);
49 |       var circle = world.addEntity(C(V(30,30), 20), defaultEntityOptions);
50 |     }());
51 |     </script>
52 | 
53 |     <h2>Polygon-Polygon Collision</h2>
54 |     <div id="example3" style="border: 1px solid #CCC; width: 320px; height: 240px;"></div>
55 |     <script>
56 |     (function () {
57 |       var canvas = Raphael('example3', 320, 240);
58 |       var world = new World(canvas);
59 |       var poly = world.addEntity(P(V(160,120), [V(0,0), V(60, 0), V(100, 40), V(60, 80), V(0, 80)]), defaultEntityOptions);
60 |       var poly2 = world.addEntity(P(V(10,10), [V(0,0), V(30, 0), V(30, 30), V(0, 30)]), defaultEntityOptions);
61 |     }());
62 |     </script>
63 |   </body>
64 | </html>


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "sat",
 3 |   "description": "Library for performing 2D collision detection",
 4 |   "version": "0.9.0",
 5 |   "author": "Jim Riecken <jriecken@gmail.com>",
 6 |   "keywords": [
 7 |     "collision detection",
 8 |     "sat",
 9 |     "game"
10 |   ],
11 |   "license": "MIT",
12 |   "repository": {
13 |     "type": "git",
14 |     "url": "git://github.com/jriecken/sat-js.git"
15 |   },
16 |   "bugs": {
17 |     "url": "http://github.com/jriecken/sat-js/issues"
18 |   },
19 |   "scripts": {
20 |     "test": "mocha"
21 |   },
22 |   "main": "SAT.js",
23 |   "devDependencies": {
24 |     "mocha": "^2.1.0"
25 |   }
26 | }


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
  1 | var SAT = require('..');
  2 | var assert = require('assert');
  3 | 
  4 | describe('Vector.scale', function() {
  5 |   it('should scale by zero properly', function() {
  6 |     var V = SAT.Vector;
  7 |     var v1 = new V(5, 5);
  8 |     v1.scale(10, 10);
  9 |     assert(v1.x === 50);
 10 |     assert(v1.y === 50);
 11 | 
 12 |     v1.scale(0, 1);
 13 |     assert(v1.x === 0);
 14 |     assert(v1.y === 50);
 15 | 
 16 |     v1.scale(1, 0);
 17 |     assert(v1.x === 0);
 18 |     assert(v1.y === 0);
 19 |   });
 20 | });
 21 | 
 22 | describe("Polygon.getCentroid", function() {
 23 |   it("should calculate the correct value for a square", function() {
 24 |     var V = SAT.Vector;
 25 |     var P = SAT.Polygon;
 26 | 
 27 |     // A square
 28 |     var polygon = new P(new V(0,0), [
 29 |       new V(0,0), new V(40,0), new V(40,40), new V(0,40)
 30 |     ]);
 31 |     var c = polygon.getCentroid();
 32 |     assert( c.x === 20 );
 33 |     assert( c.y === 20 );
 34 |   });
 35 | 
 36 |   it("should calculate the correct value for a triangle", function() {
 37 |     var V = SAT.Vector;
 38 |     var P = SAT.Polygon;
 39 | 
 40 |     // A triangle
 41 |     var polygon = new P(new V(0,0), [
 42 |       new V(0,0), new V(100,0), new V(50,99)
 43 |     ]);
 44 |     var c = polygon.getCentroid();
 45 |     assert( c.x === 50 );
 46 |     assert( c.y === 33 );
 47 |   });
 48 | });
 49 | 
 50 | describe("Collision", function() {
 51 |   it("testCircleCircle", function() {
 52 |     var V = SAT.Vector;
 53 |     var C = SAT.Circle;
 54 | 
 55 |     var circle1 = new C(new V(0,0), 20);
 56 |     var circle2 = new C(new V(30,0), 20);
 57 |     var response = new SAT.Response();
 58 |     var collided = SAT.testCircleCircle(circle1, circle2, response);
 59 | 
 60 |     assert( collided );
 61 |     assert( response.overlap == 10 );
 62 |     assert( response.overlapV.x == 10 && response.overlapV.y === 0);
 63 | 
 64 |     circle1.offset = new V(-10, -10);
 65 |     collided = SAT.testCircleCircle(circle1, circle2, response);
 66 |     assert( !collided );
 67 |   });
 68 | 
 69 |   it("testPolygonCircle", function() {
 70 | 
 71 |     var V = SAT.Vector;
 72 |     var C = SAT.Circle;
 73 |     var P = SAT.Polygon;
 74 | 
 75 |     var circle = new C(new V(50,50), 20);
 76 |     // A square
 77 |     var polygon = new P(new V(0,0), [
 78 |       new V(0,0), new V(40,0), new V(40,40), new V(0,40)
 79 |     ]);
 80 |     var response = new SAT.Response();
 81 |     var collided = SAT.testPolygonCircle(polygon, circle, response);
 82 | 
 83 |     assert(collided);
 84 |     assert(response.overlap.toFixed(2) == "5.86");
 85 |     assert(
 86 |       response.overlapV.x.toFixed(2) == "4.14" &&
 87 |       response.overlapV.y.toFixed(2) == "4.14"
 88 |     );
 89 | 
 90 |     circle.offset = new V(10, 10);
 91 |     collided = SAT.testPolygonCircle(polygon, circle, response);
 92 |     assert(!collided);
 93 |   });
 94 | 
 95 |   it('testPolygonCircle - line - not collide', function () {
 96 |     var V = SAT.Vector;
 97 |     var C = SAT.Circle;
 98 |     var B = SAT.Box;
 99 | 
100 |     var circle = new C(new V(50,50), 20);
101 |     var polygon = new B(new V(1000,1000), 100, 0).toPolygon();
102 |     var response = new SAT.Response();
103 |     var collided = SAT.testPolygonCircle(polygon, circle, response);
104 |     assert(!collided);
105 |   })
106 | 
107 |   it('testPolygonCircle - line - collide', function () {
108 |     var V = SAT.Vector;
109 |     var C = SAT.Circle;
110 |     var B = SAT.Box;
111 | 
112 |     var circle = new C(new V(50,50), 20);
113 |     var polygon = new B(new V(50,50), 100, 0).toPolygon();
114 |     var response = new SAT.Response();
115 |     var collided = SAT.testPolygonCircle(polygon, circle, response);
116 | 
117 |     assert(collided);
118 |     assert(response.overlap.toFixed(2) == "20.00");
119 |   })
120 | 
121 |   it("testPolygonPolygon", function() {
122 |     var V = SAT.Vector;
123 |     var P = SAT.Polygon;
124 | 
125 |     // A square
126 |     var polygon1 = new P(new V(0,0), [
127 |       new V(0,0), new V(40,0), new V(40,40), new V(0,40)
128 |     ]);
129 |     // A triangle
130 |     var polygon2 = new P(new V(30,0), [
131 |       new V(0,0), new V(30, 0), new V(0, 30)
132 |     ]);
133 |     var response = new SAT.Response();
134 |     var collided = SAT.testPolygonPolygon(polygon1, polygon2, response);
135 | 
136 |     assert( collided );
137 |     assert( response.overlap == 10 );
138 |     assert( response.overlapV.x == 10 && response.overlapV.y === 0);
139 |   });
140 | });
141 | 
142 | describe("No collision", function() {
143 |   it("testPolygonPolygon", function(){
144 |     var V = SAT.Vector;
145 |     var B = SAT.Box;
146 | 
147 |     var box1 = new B(new V(0,0), 20, 20).toPolygon();
148 |     var box2 = new B(new V(100,100), 20, 20).toPolygon();
149 |     var collided = SAT.testPolygonPolygon(box1, box2);
150 |   });
151 | });
152 | 
153 | describe("Point testing", function() {
154 |   it("pointInCircle", function(){
155 |     var V = SAT.Vector;
156 |     var C = SAT.Circle;
157 | 
158 |     var circle = new C(new V(100,100), 20);
159 | 
160 |     assert(!SAT.pointInCircle(new V(0,0), circle)); // false
161 |     assert(SAT.pointInCircle(new V(110,110), circle)); // true
162 | 
163 |     circle.offset = new V(-10, -10);
164 |     assert(!SAT.pointInCircle(new V(110,110), circle)); // false
165 |   });
166 | 
167 |   it("pointInPolygon", function() {
168 |     var V = SAT.Vector;
169 |     var C = SAT.Circle;
170 |     var P = SAT.Polygon;
171 | 
172 |     var triangle = new P(new V(30,0), [
173 |       new V(0,0), new V(30, 0), new V(0, 30)
174 |     ]);
175 |     assert(!SAT.pointInPolygon(new V(0,0), triangle)); // false
176 |     assert(SAT.pointInPolygon(new V(35, 5), triangle)); // true
177 |   });
178 | 
179 |   it("pointInPolygon (small)", function () {
180 |     var V = SAT.Vector;
181 |     var C = SAT.Circle;
182 |     var P = SAT.Polygon;
183 | 
184 |     var v1 = new V(1, 1.1);
185 |     var p1 = new P(new V(0,0),[new V(2,1), new V(2,2), new V(1,3), new V(0,2),new V(0,1),new V(1,0)]);
186 |     assert(SAT.pointInPolygon(v1, p1));
187 |   });
188 | });
189 | 


--------------------------------------------------------------------------------