// File "SAT.as"

package
{
    import Box2D.Common.Math.b2Vec2;
    import flash.display.*;
    import flash.geom.*;
    import flash.events.*;
    import flash.utils.Timer;

    /**
     * SAT.as
     * Created On:  12/03/2012 17:46
     */

    [SWF(backgroundColor="0x000000", frameRate="60", width="800", height="600")]
    public class SAT extends Sprite
    {
        private static var square:Vector.<b2Vec2>;
        private static var canvas:Sprite;
        private var A:Shape2D;
        private var B:Shape2D;

        public function SAT()
        {
            // SPRITE TO DRAW SHAPES TO:
            canvas = new Sprite();
            // SHAPE OF A:
            A = new Shape2D(Vector.<b2Vec2>([
            new b2Vec2( -100, -100),
            new b2Vec2( -100, 100),
            new b2Vec2( 100, 100),
            new b2Vec2( 100, -100)]), new b2Vec2(550, 300), 45);
            // SHAPE OF B:
            B = new Shape2D(Vector.<b2Vec2>([
            new b2Vec2( -200, -50),
            new b2Vec2( -200, 50),
            new b2Vec2( 200, 50),
            new b2Vec2( 200, -50)]), new b2Vec2(250, 300), 175);
            // ADD CANVAS TO STAGE:
            stage.addChild(canvas);
            // DRAW A & B:
            A.draw(canvas, false);
            B.draw(canvas, false);
            collides(A, B);

            /*
            // TIMER THAT TRIGGERS FUNCTION 'ROTATE' EVERY 10MS:
            var t:Timer = new Timer(10);
            t.addEventListener(TimerEvent.TIMER, rotate);
            t.start();
            */
        }
        public function rotate(e:TimerEvent):void
        {
            // INCREMENT ANGLES:
            A.angle++;
            B.angle++;

            // CLEAR GRAPHICS:
            canvas.graphics.clear();

            // FILL SHAPE IF IT'S CURRENTLY COLLIDING:
            if (collides(A, B))
            {
                A.draw(canvas, true);
                B.draw(canvas, true);
            } else {
                A.draw(canvas, false);
                B.draw(canvas, false);
            }
        }
        public function collides(A:Shape2D, B:Shape2D):Boolean
        {
            var test1:Number;   // numbers to use to test for overlap
            var test2:Number;
            var testNum:Number; // number to test if its the new max/min
            var min1:Number;    // current smallest(shape 1)
            var max1:Number;    // current largest(shape 1)
            var min2:Number;    // current smallest(shape 2)
            var max2:Number;    // current largest(shape 2)
            var axis:b2Vec2;    // the normal axis for projection
            var offset:Number;
            var vectorOffset:b2Vec2;
            var vectors1:Vector.<b2Vec2>;   // the points
            var vectors2:Vector.<b2Vec2>;   // the points
            vectors1 = A.getOBB().concat(); // these functions are in my polygon class, all they do is return a Vector.<b2Vec2> of the vertices of the polygon
            vectors2 = B.getOBB().concat();

            /* SHOULDN'T NEED THIS AS BOTH VECTORS CONSIST OF 4 OBJECTS.
             * ALSO B2VEC2 DOESN'T HAVE A TRUNCATE FUNCTION.
             *
            // add a little padding to make the test work correctly
            if (vectors1.length == 2)
            {
                var temp:b2Vec2 = new b2Vec2(-(vectors1[1].y - vectors1[0].y), vectors1[1].x - vectors1[0].x);
                temp.truncate(0.0000000001);
                vectors1.push(vectors1[1].add(temp));
            }
            if (vectors2.length == 2)
            {
                temp = new b2Vec2(-(vectors2[1].y - vectors2[0].y), vectors2[1].x - vectors2[0].x);
                temp.truncate(0.0000000001);
                vectors2.push(vectors2[1].add(temp));
            }
            */

            // find vertical offset
            vectorOffset = new b2Vec2(A.position.x - B.position.x, A.position.y - B.position.y);

            // loop to begin projection
            for (var i:int = 0; i < vectors1.length; i++)
            {
                // get the normal axis, and begin projection
                axis = findNormalAxis(vectors1, i);
                trace("AXIS:", axis.x, axis.y);

                // project polygon1
                min1 = dotProduct(axis, vectors1[0]);
                max1 = min1;//set max and min equal

                for (var j:int = 1; j < vectors1.length; j++)
                {
                    testNum = dotProduct(axis, vectors1[j]);// project each point
                    if (testNum < min1) min1 = testNum;     // test for new smallest
                    if (testNum > max1) max1 = testNum;     // test for new largest
                }

                trace("MIN1:", min1);
                trace("MAX1:", max1);

                // project polygon2
                min2 = dotProduct(axis, vectors2[0]);
                max2 = min2;    // set 2's max and min

                for (j = 1; j < vectors2.length; j++)
                {
                    testNum = dotProduct(axis, vectors2[j]);// project the point
                    if (testNum < min2) min2 = testNum;     // test for new min
                    if (testNum > max2) max2 = testNum;     // test for new max
                }

                trace("MIN2:", min2);
                trace("MAX2:", max2);

                // apply the offset to each max/min(no need for each point, max and min are all that matter)
                offset = dotProduct(axis, vectorOffset);// calculate offset
                min1 += offset;                         // apply offset
                max1 += offset;                         // apply offset


                trace("MIN1OFFSET:", min1);
                trace("MAX1OFFSET:", max1);

                // and test if they are touching
                test1 = min1 - max2;    // test min1 and max2
                test2 = min2 - max1;    // test min2 and max1

                trace("TEST1:", test1);
                trace("TEST2:", test2);
                trace("TEST1 > 0 || TEST2 > 0:", test1 > 0 || test2 > 0);

                if (test1 > 0 || test2 > 0)
                {   //if they are greater than 0, there is a gap
                    trace("RETURN: FALSE");
                    return false;//just quit
                }
            }
            //if you're here, there is a collision
            var seperation:b2Vec2 = new b2Vec2(axis.x*((max2-min1)*-1), axis.y*((max2-min1)*-1)); //return the separation, apply it to a polygon to separate the two shapes.
            return true;
        }
        private function dotProduct(vecA_:b2Vec2, vecB_:b2Vec2):Number
        {
            return (vecA_.x * vecB_.x + vecA_.y * vecB_.y);
        }
        private function findNormalAxis(verts:Vector.<b2Vec2>, index:int):b2Vec2
        {
            var vector1:b2Vec2 = verts[index];
            var vector2:b2Vec2 = (index >= verts.length - 1) ? verts[0] : verts[index + 1];     //make sure you get a real vertex, not one that is outside the length of the vector.

            var normalAxis:b2Vec2 = new b2Vec2( -(vector2.y - vector1.y), vector2.x - vector1.x);//take the two vertices, make a line out of them, and find the normal of the line
            normalAxis.Normalize(); //normalize the line(set its length to 1)
            return normalAxis;
        }
    }
}