flash on 2013-1-17

/**
 * Copyright mutantleg ( http://wonderfl.net/user/mutantleg )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/zuay
 */

package {
    import flash.text.TextField;
    import flash.ui.Keyboard;
    import flash.events.KeyboardEvent;
    import flash.events.Event;
    import flash.display.Sprite;
    public class FlashTest extends Sprite {
       
       public var cx:Number = 0;
       public var cy:Number = 0;
       public var vx:Number = 0;
       public var vy:Number = 0;
       public var rad:Number = 8;
       
       public var ps:Sprite;
       public var rect:Sprite;
       public var trect:Sprite;
       public var grect:Sprite;
              
       public var rx:Number = 200;
       public var ry:Number = 200;
       public var ra:Number = 0;
       public var xrad:Number = 96;
       public var yrad:Number = 16;
       
        public function FlashTest() {
         
         cx = 200;
         cy = 300;
            
         ps = new Sprite();
         ps.graphics.clear();
         ps.graphics.lineStyle(1,0);
         ps.graphics.drawCircle(0,0,8);   
            addChild(ps);
            
        rect = new Sprite();
        rect.graphics.clear();
        rect.graphics.lineStyle(1,0);
        rect.graphics.drawCircle(0,0,4);
        rect.graphics.drawRect(-xrad,-yrad,xrad+xrad,yrad+yrad);
        addChild(rect);   
        
        trect = new Sprite();
        trect.graphics.clear();
        trect.graphics.lineStyle(1,0x0000FF);
        trect.graphics.drawCircle(0,0,4);
        trect.graphics.drawRect(-xrad,-yrad,xrad+xrad,yrad+yrad);
        addChild(trect);   
        
        grect = new Sprite();
        grect.graphics.clear();
        grect.graphics.lineStyle(1,0x00FF00);
        grect.graphics.drawCircle(0,0,4);
        grect.graphics.drawRect(-xrad,-yrad,xrad+xrad,yrad+yrad);
        addChild(grect);   
        
        dt = new TextField();
        addChild(dt);
            
            stage.addEventListener(KeyboardEvent.KEY_DOWN, kdown);
            stage.addEventListener(KeyboardEvent.KEY_UP, kup);
            stage.addEventListener(Event.ENTER_FRAME, onEnter);
        }//ctor
        
        public var dt:TextField;
        
        public var vecKey:Vector.<Boolean> = new Vector.<Boolean>(512,false);
        public function kdown(e:KeyboardEvent):void { vecKey[e.keyCode] = true; }
        public function kup(e:KeyboardEvent):void { vecKey[e.keyCode] = false; }
        
        public function onEnter(e:Event):void
        {
            
            if (vecKey[Keyboard.UP]) { vy -= 0.5; }
            if (vecKey[Keyboard.DOWN]) { vy += 0.5; }
            if (vecKey[Keyboard.LEFT]) { vx -= 0.5; }
            if (vecKey[Keyboard.RIGHT]) { vx += 0.5; }

            var mv:Number;
            mv = Math.sqrt(vx*vx+vy*vy);
            if (mv >= rad)
             {
                  vx /= mv; vx*=rad;
                  vy /= mv;  vy *=rad;
                 }
            

            vy += 0.1;
            
            vx *= 0.96;
            vy *= 0.96;
            
            if (vy >0 && cy >= 300) { vy *= -0.5; }
            
            cx += vx;
            cy += vy;
            
            ps.x = cx;
            ps.y = cy;
            
            //ra = 0.5; //debug
            
            rect.x = rx;
            rect.y = ry;
            rect.rotation = ra * (180/3.1415);
            
            graphics.clear();
            graphics.lineStyle(1,0xFF0000);
            
            
           
            var kx:Number;
            var ky:Number;
            var ix:Number;
            var iy:Number;
            var jx:Number;
            var jy:Number;
            var a:Number;
            
            //closest point from point to rotated rectangle
            
            a = -ra;
            
            jx = cx - rx;
            jy = cy - ry;
            
            kx = jx * Math.cos(a) - Math.sin(a)*jy;
            ky = jx * Math.sin(a) + Math.cos(a) * jy;
            
            if (kx < -xrad) { ix = -xrad;}
            else if (kx > xrad) { ix = xrad;}
            else { ix = kx;}
            
            if (ky < -yrad) { iy = -yrad;}
            else if (ky > yrad) { iy = yrad;}
            else {iy = ky; }
            
            jx = ix * Math.cos(ra) - Math.sin(ra)*iy;
            jy = ix * Math.sin(ra) + Math.cos(ra)*iy;
            
            
            ix = jx+ rx;
            iy = jy+ry;
            
            graphics.drawCircle(ix,iy,3);
            
            
            
            var dx:Number;
            var dy:Number;
            var mag:Number;
            
            //distance of point to closest point
            dx = cx - ix;
            dy = cy - iy;
            mag = Math.sqrt(dx*dx+dy*dy);
            if (mag == 0) { mag = 0.000001; }
           var bcol:Boolean = false;
           
           var nx:Number;
           var ny:Number;
           
           var ndot:Number;
           var vmag:Number;
           var vnx:Number;
           var vny:Number;
           ndot = 0;
           
           //push point out of closest point
            if (mag < rad)
            {
             dx /= mag;
             dy /= mag;
             cx-= dx * (mag-rad);
             cy-= dy * (mag-rad);
            
                vmag = Math.sqrt(vx*vx+vy*vy);
                if (vmag == 0) { vmag = 0.0000001;}
                vnx = vx/vmag;
                vny = vy/vmag;
                ndot = dx*vnx + dy*vny;
            
            //vx += dx; 
            // vy += dy;
             bcol = true;
            }
            
            var ax:Number;
            var ay:Number;
            var bx:Number;
            var by:Number;
            var dot:Number;
            
            //foolery to figure out a torque
            
            ax = ix - rx;
            ay = iy - ry;
            
            dot = (vx*ax+vy*ay)/(ax*ax+ay*ay);
            
            bx = vx - (ax * dot);
            by = vy - (ay * dot);
            
            var hx:Number;
            var hy:Number;
            
            hx = Math.cos(a);
            hy = Math.sin(a);
            
            graphics.moveTo(rx,ry);
            graphics.lineTo(rx+hx*16, ry+hy*16);
            
            graphics.lineStyle(1,0);
            graphics.moveTo(rx,ry);
            graphics.lineTo(rx+bx*16, ry+by*16);
            
          //  ra = 0.9;
            
            //attempt to turn the torque into a radian angle
            // (so far it seems to work ok, but im not sure why)
            
                 var a2:Number;
           
//           a2 = (vx * (ay*dot)) - (vy * (ax*dot));
             //i'm not exactly sure if i'm doing the right thing here
             //kind of confused how i got degrees from this
             // (note its a wedge product)
             a2 = ax * by - ay * bx;
             
             a2 *= 3.1415/180.0;
             
          //   by /= yrad;
          //   bx /= xrad;
             
             //a2 = Math.atan2(by,bx);          
            // a2 = Math.atan2(ay,ax);
           //  a2 += 1.57;
             //a2 *=-1;
             
             dt.text = "a2 " + a2;
             dt.appendText("\n ndot " + ndot);
           
           trect.visible = false;
                trect.x = rx;
                trect.y = ry;
                trect.rotation= (a2);
                
                grect.visible = false;
                
                grect.x = rx;
                grect.y = ry;
                grect.rotation = (Math.atan2(ay,ax)+1.57)*180/3.1415;
                
            
            if (bcol && ndot <0)
            {
                
                //30 was a guess as the default frame/sec
                //no idea if correct
                //usually it's divided by  moment of inertia 
                //which is related to the mass of the object  and some magical calculations based on its shape
                  //ra +=a2/30;
                  
                  
                var ka:Number;
                ka = a2/30;
                
               //trying to limit rotation change to max 1 degrees/frame
               // (0.0174 = 6.28 / 360
              if (ka > 0.0174) { ka = 0.0174;}
              else if (ka < -0.0174) { ka = -0.0174;}
              
              ra += ka;
           
             
            // a2 = getDir(Math.atan2(by,bx),ra );
               
            // ra += a2;   
            //ra += Math.atan2(by,bx);
            vx+=dx; 
            vy+=dy; 
            }
            
            
        }//onenter
        
        
        public function getDir(a:Number, b:Number):Number
        {
            var c:Number;
            var d:Number;
            var k:Number;
            d = 0.1;            

            if ( (a - b) > 3.1415 )
                {
                    c = b + 6.28;
                    k = (c-a)*d;
                    a = a + (c - a) * d; //0.1f;
                    if (a > 6.28) a -= 6.28;
                }
                else
                {
                    if ( (a - b) < -3.1415 )
                    {
                        c = b - 6.28;
                        k = (c-a)*d;
                        a = a + (c - a) * d; //0.1f;
                        if (a < 0) a += 6.28;
                    }
                    else
                    {
                         k = (b-a)*d;
                        a = a + (b - a) * d; //0.1f;
                    }//endif nsted
                }//endif
                
                
                
            return k;
    
        }//getdir
        
        
        
    }//classend
}