flash on 2013-7-3

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

package {
    import flash.text.TextField;
    import flash.events.Event;
    import flash.display.Sprite;
    public class FlashTest extends Sprite {
      
        public function FlashTest() {
            
            
            deb = new TextField();
            deb.mouseEnabled = false;
            deb.width = 320;
            deb.height = 240;
            addChild(deb);
            
            line0 = new xLine();
            line1 = new xLine();
            
            line0.setValue(130, 50, 200, 50);
            line1.setValue(50, 100, 400, 300);
            
            stage.addEventListener(Event.ENTER_FRAME, onEnter);
        }//ctor
        
        public var deb:TextField;
        
        public var line0:xLine;
        public var line1:xLine;
      
         public function onEnter(e:Event):void
         {
             graphics.clear();
             graphics.lineStyle(2, 0);
             
             line1.ax = stage.mouseX;
             line1.ay = stage.mouseY;
             
             graphics.moveTo(line0.ax, line0.ay);
             graphics.lineTo(line0.bx, line0.by);
             
             graphics.moveTo(line1.ax, line1.ay);
             graphics.lineTo(line1.bx, line1.by);
             
             var temp:xLine;
             
            temp = closeLine(line0, line1);
             
          //   temp = LineLineIntersect(line0, line1);
             
             graphics.drawCircle(temp.ax, temp.ay, 4);
             graphics.drawCircle(temp.bx, temp.by, 8);
             
             graphics.moveTo(temp.ax, temp.ay);
             graphics.lineTo(temp.bx, temp.by);
             
         }//onenter      
         
         
         //so i read this GDC ppt and it had a line-line close algorithm
         //JOBrien_GameplayAI_GDC2012.pptx (i think it was on essentialmath something)
         //but i screwed it up somewhere
         //so its also based on 
         //http://geomalgorithms.com/a07-_distance.html
         //also based on 
         //http://paulbourke.net/geometry/pointlineplane/
         
         public var tempRet:xLine = new xLine(); //
         public function closeLine(mu:xLine, mv:xLine):xLine
         {
             
             var ux:Number; //21
             var uy:Number;
             var vx:Number; //43
             var vy:Number;
             var w0x:Number; //13
             var w0y:Number;
             
             ux = mu.bx - mu.ax;
             uy = mu.by - mu.ay;
             
             vx = mv.bx - mv.ax;
             vy = mv.by - mv.ay;
             
             w0x =  mu.ax - mv.ax;
             w0y =  mu.ay - mv.ay;
             
             var dotuu:Number; //a   //2121
             var dotuv:Number; //b  //4321
             var dotvv:Number; //c  //4343
             var dotuw0:Number; //d //1321
             var dotvw0:Number; //e //1343
             
             dotuv = (ux * vx) + (uy * vy);
             dotuu = (ux * ux) + (uy * uy);
             dotvv = (vx * vx) + (vy * vy);
             dotuw0 = (ux * w0x) + (uy * w0y);
             dotvw0 = (vx * w0x) + (vy * w0y); 
             
            
             var ret:xLine;
             var u:Number; //sc
             var v:Number; //tc
             var div:Number; //a*c - b*b
             
             ret = tempRet;
             
             
           
             div = (dotuu * dotvv) - (dotuv*dotuv); //denom
             
        /*     if (div < 0.000001)
             {
                u = 0;
                v = dotuv > dotvv ?  (dotuw0 / dotuv) : ( dotvw0 / dotvv);  
              }
             else */
             {
              u = (dotuv*dotvw0 - dotvv * dotuw0) / div; //mua
             // v = (dotuu*dotvw0 - dotuv * dotuw0) / div;
              
              v = (dotvw0 + dotuv * u) / dotvv;
             }
   
             
             deb.text = " u " + u + " \n v " + v;
             
             
             var denom:Number;
     
             
             
             /*
             //also interesting but not the result i was looking for
             ret.ax = mu.ax + (mv.ax - mu.ax) * u;
             ret.ay = mu.ay + (mv.ay - mu.ay) * u;
             ret.bx = mu.bx + (mv.bx - mu.bx) * v;
             ret.by = mu.by + (mv.by - mu.by) * v;
             */
             

            //not exactly it, this is the intersection point
             ret.ax = mu.ax + ux * u;
             ret.ay = mu.ay + uy * u;
           
             ret.bx = mv.ax + vx * v;
             ret.by = mv.ay + vy * v;
           
             
             
             return ret;
         }//closep
         
         
         
         /*
         //i dunno where i screwed up so i just paste  and replace in
         //http://paulbourke.net/geometry/pointlineplane/
         
         //and strangely enough it has the same result
         //i give up, i don't know what i missed
         
         public function LineLineIntersect(p1p2:xLine, p3p4:xLine):xLine 
         {
             var ret:xLine;
             
             var p13:xPoint = new xPoint();
             var p43:xPoint = new xPoint();
             var p21:xPoint = new xPoint();
             var p1:xPoint = new xPoint();
             var p2:xPoint = new xPoint();
             var p3:xPoint = new xPoint();
             var p4:xPoint = new xPoint();
             
             p1.x = p1p2.ax;
             p1.y = p1p2.ay;
             
             p2.x = p1p2.bx;
             p2.y = p1p2.by;
             
             p3.x = p3p4.ax;
             p3.y = p3p4.ay;
             
             p4.x = p3p4.bx;
             p4.y = p3p4.by;
            
             
             var d1343:Number;
             var d4321:Number;
             var d1321:Number;
             var d4343:Number;
             var d2121:Number;
             var numer:Number;
             var denom:Number;
             
             var mua:Number;
             var mub:Number;
             
              p13.x = p1.x - p3.x;
               p13.y = p1.y - p3.y;
               p13.z = p1.z - p3.z;
               p43.x = p4.x - p3.x;
               p43.y = p4.y - p3.y;
               p43.z = p4.z - p3.z; 
                         
            p21.x = p2.x - p1.x;
           p21.y = p2.y - p1.y;
           p21.z = p2.z - p1.z;         
                         
               d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z;
           d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z;
           d1321 = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z;
           d4343 = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z;
           d2121 = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z;
        
           denom = d2121 * d4343 - d4321 * d4321;
        
           numer = d1343 * d4321 - d1321 * d4343;           

            mua = numer / denom;
           mub = (d1343 + d4321 * (mua)) / d4343; 
             
             ret = tempRet;
             
            ret.ax = p1.x + mua * p21.x;
           ret.ay = p1.y + mua * p21.y;
           ret.bx = p3.x + mub * p43.x;
           ret.by = p3.y + mub * p43.y;
             
             
             return ret;
         }//lineline
         
         */
                    
        
    }//classend
}

internal class xPoint
{
    public var x:Number = 0;
    public var y:Number = 0;
    public var z:Number = 0;
    
}//xpoint

internal class xLine
{
    public var ax:Number = 0;
    public var ay:Number = 0;
    public var bx:Number = 0;
    public var by:Number = 0;
    
    public function setValue(ax_:Number, ay_:Number, bx_:Number, by_:Number):void
    {
        ax = ax_;
        ay = ay_;
        bx = bx_;
        by = by_;
    }//setvalue
    
}//xline