forked from: flash on 2012-10-25

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

// forked from mutantleg's flash on 2012-10-25
package {
    import flash.events.KeyboardEvent;
    import flash.text.TextField;
    import flash.events.Event;
    import flash.display.Sprite;
    public class FlashTest extends Sprite {
        
       public var a:ColTest;
     
       public static var deb:TextField;
       
        public function FlashTest() {
            
            deb = new TextField();
            deb.multiline = true;
            deb.width = 128;
            deb.height = 400;
            addChild(deb);
            
            graphics.clear();
            graphics.lineStyle(2,0);
            //graphics.drawRect(0,0,32,32);
            
     
            a = new ColTest();
            addChild(a);
         
         stage.addEventListener(Event.ENTER_FRAME, onEnter);   
         stage.addEventListener(KeyboardEvent.KEY_UP, kup);
         stage.addEventListener(KeyboardEvent.KEY_DOWN, kdown);
        }
        
        public static var vecKey:Vector.<Boolean> = new Vector.<Boolean>(512,false);
        
        public function kdown(e:KeyboardEvent):void
        {
            vecKey[e.keyCode]= true;
        }//kdwn
         
        public function kup(e:KeyboardEvent):void
        {
            
            vecKey[e.keyCode] = false;
            
        }//kup
        
        public function onEnter(e:Event):void
        {
            deb.text = "";
            a.onEnter(e);
        }//onenter
        
    }
}
import flash.ui.Keyboard;
import flash.utils.Proxy;
import flash.display.Sprite;
import flash.display.Graphics;
import flash.events.Event;
import flash.geom.Point;



internal class ColTest extends Sprite
{

  public var ray:RayTest;
  public var ob:ColOb;

  public function ColTest()
  {
    ray = new RayTest();
    ob = new ColOb();
    addChild(ob.debSpr);

     var w:Number = 64;
     var h:Number = 16;


    ob.addLine(new Line(w,-h,-w,-h));
    ob.addLine(new Line(-w,h,w,h));
    ob.addLine(new Line(-w,-h,-w,h));
    ob.addLine(new Line( w,h,w,-h));
 
 /*
     ob.addLine(new Line(w,-h,-w,-h));
     ob.addLine(new Line(-w,-h,0,h));   
    ob.addLine(new Line(0,h,w,-h));   
  */  
    
     graphics.clear();
      graphics.lineStyle(2,0);
      graphics.drawRect(0,0,400,400);

    //stage.addEventListener(Event.ENTER_FRAME,onEnter);
  }//coltest

  public function onEnter(e:Event):void
  {
      
      graphics.clear();
      graphics.lineStyle(2,0);
      //graphics.drawRect(0,0,400,400);

    ray.start.x = 30;
    ray.start.y = 30;
    ray.end.x = mouseX; 
    ray.end.y = mouseY;

    ob.cx = 200;
    ob.cy = 200;
    
    if (FlashTest.vecKey[Keyboard.LEFT])
    {
    ob.ori += 0.02;
    }
    
    if (FlashTest.vecKey[Keyboard.RIGHT])
    {
     ob.ori -=0.02;   
    }
    
    
    ray.test(ob);

    ray.draw(graphics);
    ob.draw(ob.debSpr);

    ob.debDraw(graphics);
    /*
    graphics.lineStyle(1,0xFF0000);
    var kt:Number;
    kt =   ob.linePoint(ray.start, ray.end,100,100);
    graphics.drawCircle(100,100, 8);
    graphics.moveTo(ray.start.x, ray.start.y);
    graphics.moveTo(ray.end.x, ray.end.y);
    var jx:Number;
    var jy:Number;
    jx = ray.start.x + (ray.end.x-ray.start.x) * kt;
    jy = ray.start.y + (ray.end.y-ray.start.y) * kt;
    graphics.drawCircle(jx,jy, 4);
    graphics.moveTo(100,100);
    graphics.lineTo(jx,jy);
    */
  }//onenter


};//coltest




internal class RayTest
{
  public var start:Point = new Point();
  public var end:Point = new Point();
  public var col:Point = new Point();
  public var t:Number = 0;
  public var bColl:Boolean = false;
  public var rad:Number = 16;

  public function RayTest()
  {

  }

  public function test(ob:ColOb):Boolean
  {
    t = ob.lineTest(start, end, rad);

  
    bColl = t >= 0 && t <= 1.0;

    if (bColl)
    {
      col.x = start.x + (end.x - start.x) * t;
      col.y = start.y + (end.y - start.y) * t;
    }
    else
    {
      col.x = end.x;
      col.y = end.y;
    }

    return bColl;
  }//test

  public function draw(g:Graphics):void
  {
    g.moveTo(start.x, start.y);
    g.lineTo(col.x, col.y);
    
    g.drawCircle(col.x, col.y, rad);
  }//draw

};//test


internal class Line
{
  public var v0:Point = new Point();
  public var v1:Point = new Point();
  public var nx:Number = 0;
  public var ny:Number = 0;
  public var mag:Number = 0;

  public function Line(sx:Number,sy:Number, ex:Number, ey:Number)
  {
    v0.x = sx;
    v0.y = sy;
    v1.x = ex;
    v1.y = ey;
    
    var dx:Number;
    var dy:Number;
    //var mag:Number;
    dx = sx-ex;
    dy = sy-ey;
    mag = Math.sqrt(dx*dx+dy*dy);
    if (mag == 0) { mag= 0.0000001;}
    ny = - (dx /mag);
    nx = dy/mag;
    
  }//ctor

};//line


internal class ColOb
{
        
public var cx:Number = 0;
public var cy:Number = 0;
public var ori:Number = 0;
public var debSpr:Sprite = new Sprite();

public var vecLine:Vector.<Line> = new Vector.<Line>;

public function addLine(a:Line):void
{
  vecLine.push(a);
  
  calcMinMax();
}//addline

public var minx:Number = 0;
public var maxx:Number = 0;
public var miny:Number = 0;
public var maxy:Number = 0;

public var rad:Number = 0;

public function calcMinMax():void
{
    var i:int;
    var num:int;
    var m:Line;
    num = vecLine.length;
    
    minx = 9999999;
    miny = 9999999;
    maxy = -9999999;
    maxx = -9999999;
    
    for (i =0; i < num; i++)
    {
        m = vecLine[i];
        
        if (minx > m.v0.x) { minx = m.v0.x; }
        if (minx > m.v1.x) { minx = m.v1.x; }
        if (maxx < m.v0.x) { maxx = m.v0.x; }
        if (maxx < m.v1.x) { maxx = m.v1.x; }
        
        if (miny > m.v0.y) { miny = m.v0.y; }
        if (miny > m.v1.y) { miny = m.v1.y; }
        if (maxy < m.v0.y) { maxy = m.v0.y; }
        if (maxy < m.v1.y) { maxy = m.v1.y; }
        
    }//nexti
    
    var mag:Number;
    var dx:Number;
    var dy:Number;
    dx = maxx - minx;
    dy = maxy - miny;
    mag = Math.sqrt(dx*dx+dy*dy);
    rad = mag /2;
    
}//calcminmax

public function debDraw(g:Graphics):void
{
    return;
    
    g.lineStyle(1, 0x0000FF);
    g.drawRect(cx+minx,cy+miny, maxx-minx, maxy-miny);
    
    g.lineStyle(1,0xFF0000);
    g.drawCircle(cx,cy, rad);
    
    var r2:Number;
    
    r2 = rad + 16;
    
    g.lineStyle(1,0x00FF00);
    g.drawRect(cx-r2,cy-r2,r2+r2,r2+r2);
    
}//deb

public function draw(s:Sprite):void
{
  var i:int;
  var num:int;
  var m:Line;
  var g:Graphics;

  g = s.graphics;

  num = vecLine.length;

  g.clear();
  g.lineStyle(2,0);

  g.drawCircle(0,0, 4);

  for (i = 0; i < num; i++)
  {
    m = vecLine[i];
    g.moveTo(m.v0.x, m.v0.y);
    g.lineTo(m.v1.x, m.v1.y);
    
   
    var kx:Number;
    var ky:Number;
    var tx:Number;
    var ty:Number;
    kx = m.v0.x + (m.v1.x - m.v0.x) * 0.5;
    ky = m.v0.y + (m.v1.y - m.v0.y) * 0.5;
    g.moveTo(kx,ky);
    //g.lineTo(0,0);
    //g.lineTo(kx+10,ky+10);
    g.lineTo(kx+m.nx*10,ky+m.ny*10);
     /*   
    g.moveTo(m.v0.x+m.nx*mrad, m.v0.y+m.ny*mrad);
    g.lineTo(m.v1.x+m.nx*mrad, m.v1.y+m.ny*mrad);
    
    tx = m.v0.x + m.nx*mrad + (-m.ny*mrad);
    ty = m.v0.y + m.ny*mrad + (m.nx*mrad);
    kx = m.v1.x + m.nx*mrad + (m.ny*mrad);
    ky = m.v1.y + m.ny*mrad + (-m.nx*mrad);
   
   g.moveTo(tx,ty);
   g.lineTo(kx,ky);
    
    
    g.drawCircle(m.v0.x, m.v0.y, mrad);
   g.drawCircle(m.v1.x, m.v1.y, mrad);
    
  
        
   // g.moveTo(m.v0.x*mrad, m.v0.y*mrad);
   // g.lineTo(m.v1.x*mrad, m.v1.y*mrad);    
    */    
  }//nexti

  s.x = cx;
  s.y = cy;
  s.rotation = ori * (180 / 3.1415);  

}//draw


public var mrad:Number = 32;

public static var vs:Point = new Point();
public static var ve:Point = new Point();
public static var ms:Point = new Point();
public static var me:Point = new Point();
public function lineTest(s:Point, e:Point, r:Number):Number
{

 var ang:Number;
 var rx:Number;
 var ry:Number;
 
 mrad = r;


//transform line into the colob coordinate system

  ang = -ori;  

  rx = s.x - cx;
  ry = s.y - cy;

  vs.x = Math.cos(ang) * rx - Math.sin(ang) * ry;
  vs.y = Math.sin(ang) * rx + Math.cos(ang) * ry;

  rx = e.x - cx;
  ry = e.y - cy;

  ve.x = Math.cos(ang) * rx - Math.sin(ang) * ry;
  ve.y = Math.sin(ang) * rx + Math.cos(ang) * ry;



//go through all lines
  var i:int;
  var num:int;
  var smallt:Number;
  var dist:Number;
  var m:Line;
  var rad:Number = mrad;  //line radius
  var rad2:Number = rad*rad; //squared rad
  //var radh:Number = rad * 0.5;
  var kx:Number;
  var ky:Number;
  var dx:Number;
  var dy:Number;
  var tx:Number;
  var ty:Number;
 // var nx:Number;
 // var ny:Number;
 // var mag:Number;
  
  //nx = vs.x - ve.x;
 // ny = vs.y - ve.y;
 // mag = Math.sqrt(nx*nx+ny*ny);
 
  smallt = 999;
 // var jt:Number;
 // var ht:Number;
  
 // ht = ((rad)/mag ); // *0.5;

  num = vecLine.length;

//FlashTest.deb.appendText("ht "+ ht+ " \n");

  for (i = 0; i < num; i++)
  {
    m = vecLine[i];
 /*   
    ms.x = m.v0.x + m.nx * rad;// + (-m.ny*rad);
    ms.y = m.v0.y + m.ny * rad;// + (m.nx *rad);
    me.x = m.v1.x + m.nx * rad;// + (m.ny*rad);
    me.y = m.v1.y + m.ny * rad;// + (-m.nx*rad);

    jt = (rad / m.mag) * 0.5;
*/
//FlashTest.deb.appendText("rad " + rad+ " mag:" +m.mag+ "  jt: "+ jt + " \n");
    
 
    dist = lineLineInter(vs,ve,m.v0,m.v1);
    
    if (ua < 0) { ua = 0;}
    else if (ua > 1) { ua = 1;}

    if (ub < 0) { ub = 0;}
    else if (ub > 1) { ub = 1;}


    if (dist < smallt)
    {
      smallt = dist;
    }
    
   
  }//nexti

  return smallt;
}//linetest

public function linePoint(v0:Point, v1:Point, px:Number, py:Number):Number
{
    var vx:Number;
    var vy:Number;
    var dx:Number;
    var dy:Number;
    var t:Number;
    
    vx = v1.x - v0.x;
    vy = v1.y - v0.y;
    
    dx = px - v0.x;
    dy = py - v0.y;
    
    t = (vx*dx + vy*dy) /  (vx*vx + vy*vy) ;
    if (t < 0) { t = 0; }
    if (t > 1) { t = 1;}
    
    return t;
}//linepoint

    
    public var ua:Number = 0;
    public var ub:Number = 0;
 public function lineLineInter(v0:Point, v1:Point, v2:Point, v3:Point):Number
         {
            // var ua:Number;
            // var ub:Number;
             var bot:Number;
             
             bot = ((v3.y-v2.y)*(v1.x-v0.x))-((v3.x-v2.x)*(v1.y-v0.y));
             if (bot == 0) { return 999;}
             
              ua = (((v3.x-v2.x)*(v0.y-v2.y))-((v3.y-v2.y)*(v0.x-v2.x))) / bot;
              ub = (((v1.x-v0.x)*(v0.y-v2.y))-((v1.y-v0.y)*(v0.x-v2.x))) / bot;
              if (ua > 1 || ua < 0 || ub > 1 || ub < 0) { return 999; }
              return ua;

         }//lineline
         

};//classend