home *** CD-ROM | disk | FTP | other *** search
/ 600 Games / 600games.iso / Acao / germ_roundup.swf / scripts / __Packages / smashing / Line.as < prev    next >
Encoding:
Text File  |  2007-03-20  |  8.8 KB  |  292 lines
  1. class smashing.Line
  2. {
  3.    var vector;
  4.    var p0;
  5.    var bChanged = true;
  6.    function Line(x0, y0, x1, y1)
  7.    {
  8.       var _loc1_ = this;
  9.       _loc1_.p0 = new smashing.Point(x0,y0);
  10.       _loc1_.p1 = new smashing.Point(x1,y1);
  11.       _loc1_.vector = new smashing.Point(_loc1_.p1.x - _loc1_.p0.x,_loc1_.p1.y - _loc1_.p0.y);
  12.       _loc1_.lineNormal = _loc1_.vector.normalize();
  13.    }
  14.    function get normal()
  15.    {
  16.       var _loc1_ = this;
  17.       if(_loc1_.bChanged == true)
  18.       {
  19.          _loc1_.bChanged = false;
  20.          _loc1_.vN = new smashing.Point(_loc1_.vector.y,- _loc1_.vector.x);
  21.          _loc1_.vN.normalizeMe();
  22.       }
  23.       return _loc1_.vN;
  24.    }
  25.    function setLine(x0, y0, x1, y1)
  26.    {
  27.       var _loc1_ = this;
  28.       _loc1_.p0.x = x0;
  29.       _loc1_.p0.y = y0;
  30.       _loc1_.p1.x = x1;
  31.       _loc1_.p1.y = y1;
  32.       _loc1_.vector.x = _loc1_.p1.x - _loc1_.p0.x;
  33.       _loc1_.vector.y = _loc1_.p1.y - _loc1_.p0.y;
  34.       _loc1_.lineNormal = _loc1_.vector.normalize();
  35.       _loc1_.bChanged = true;
  36.    }
  37.    function move(nX, nY)
  38.    {
  39.       var _loc1_ = this;
  40.       _loc1_.p0.x += nX;
  41.       _loc1_.p0.y += nY;
  42.       _loc1_.p1.x += nX;
  43.       _loc1_.p1.y += nY;
  44.    }
  45.    function collisionPointSwept(p, m, radius)
  46.    {
  47.       var _loc1_ = this;
  48.       var _loc2_ = m;
  49.       var nMotionDot = _loc2_.dot(_loc1_.normal);
  50.       if(nMotionDot >= 0)
  51.       {
  52.          return null;
  53.       }
  54.       var pLocalStart = new smashing.Point(p.x - _loc1_.p0.x,p.y - _loc1_.p0.y);
  55.       var pOffset = _loc1_.normal.copy();
  56.       pOffset.multiplyMe(radius);
  57.       var pR = pLocalStart.copy();
  58.       pR.subtractPointMe(pOffset);
  59.       var nOffLine = ((- pR.y) * _loc2_.x + pR.x * _loc2_.y) / (_loc2_.y * _loc1_.vector.x + (- _loc2_.x) * _loc1_.vector.y);
  60.       var lReturn;
  61.       if(nOffLine >= 0 && nOffLine <= 1)
  62.       {
  63.          var _loc3_ = new smashing.Point(_loc1_.vector.x * nOffLine,_loc1_.vector.y * nOffLine);
  64.          var dX = _loc3_.x - pR.x;
  65.          var dY = _loc3_.y - pR.y;
  66.          var mX = _loc2_.x;
  67.          var mY = _loc2_.y;
  68.          var pD = new smashing.Point(_loc3_.x - pR.x,_loc3_.y - pR.y);
  69.          if(dX * mX + dY * mY < 0)
  70.          {
  71.             return null;
  72.          }
  73.          dX *= dX;
  74.          dY *= dY;
  75.          mX *= mX;
  76.          mY *= mY;
  77.          var nD = dX + dY;
  78.          if(nD > mX + mY)
  79.          {
  80.             return null;
  81.          }
  82.          _loc3_.x += _loc1_.p0.x + pOffset.x;
  83.          _loc3_.y += _loc1_.p0.y + pOffset.y;
  84.          lReturn = new smashing.CollisionResult(_loc3_,_loc1_.normal,nD);
  85.          lReturn.gizmo = _loc1_;
  86.          lReturn.lHit = _loc3_;
  87.       }
  88.       else
  89.       {
  90.          var unitMotion = _loc2_.normalize();
  91.          if(nOffLine < 0)
  92.          {
  93.             var pEndPoint = _loc1_.p0;
  94.             var pToEnd = pLocalStart.reverse();
  95.          }
  96.          else if(nOffLine > 0)
  97.          {
  98.             var pEndPoint = _loc1_.p1;
  99.             var pToEnd = new smashing.Point(_loc1_.p1.x - p.x,_loc1_.p1.y - p.y);
  100.          }
  101.          var nClosest = pToEnd.dot(unitMotion);
  102.          if(_loc2_.length < Math.abs(nClosest) - radius)
  103.          {
  104.             return null;
  105.          }
  106.          var nHyp = pToEnd.length;
  107.          var nOppSqu = nHyp * nHyp - nClosest * nClosest;
  108.          var nRadiusSqu = radius * radius;
  109.          if(nOppSqu > nRadiusSqu)
  110.          {
  111.             return null;
  112.          }
  113.          var nFinal = Math.sqrt(nRadiusSqu - nOppSqu) - nClosest;
  114.          if(Math.abs(nFinal) > _loc2_.length)
  115.          {
  116.             return null;
  117.          }
  118.          var vFinal = unitMotion.multiply(nFinal);
  119.          if(vFinal.dot(_loc2_) > 0)
  120.          {
  121.             return null;
  122.          }
  123.          var vClipped = new smashing.Point(p.x - vFinal.x,p.y - vFinal.y);
  124.          var vCNormal = new smashing.Point(vClipped.x - pEndPoint.x,vClipped.y - pEndPoint.y).normalize();
  125.          lReturn = new smashing.CollisionResult(vClipped,vCNormal,nFinal * nFinal);
  126.          lReturn.gizmo = _loc1_;
  127.          lReturn.lHit = vFinal;
  128.       }
  129.       return lReturn;
  130.    }
  131.    function collisionPoint(p, m, r)
  132.    {
  133.       var _loc1_ = this;
  134.       var nMD = m.dot(_loc1_.normal);
  135.       if(nMD > 0)
  136.       {
  137.          return null;
  138.       }
  139.       var _loc3_ = new smashing.Point(p.x + m.x,p.y + m.y);
  140.       var de = _loc1_.vector.x * (_loc3_.x - _loc1_.p0.x) + _loc1_.vector.y * (_loc3_.y - _loc1_.p0.y);
  141.       var e2 = _loc1_.vector.dot(_loc1_.vector);
  142.       var _loc2_ = undefined;
  143.       var nDist;
  144.       var lR;
  145.       if(de < 0)
  146.       {
  147.          _loc2_ = new smashing.Point(_loc3_.x - _loc1_.p0.x,_loc3_.y - _loc1_.p0.y);
  148.          nDist = _loc2_.dot(_loc2_);
  149.          if(nDist > r * r)
  150.          {
  151.             return null;
  152.          }
  153.          var cN = _loc2_.normalize();
  154.          _loc2_.length = r;
  155.          var pC2 = _loc1_.p0.addPoint(_loc2_);
  156.          var xF = pC2.x - p.x;
  157.          var yF = pC2.y - p.y;
  158.          var lR = new smashing.CollisionResult(pC2,cN,xF * xF + yF * yF);
  159.          lR.lHit = _loc1_.p0;
  160.          lR.nRatio = 0;
  161.          lR.gizmo = _loc1_;
  162.       }
  163.       else if(de > e2)
  164.       {
  165.          _loc2_ = new smashing.Point(_loc3_.x - _loc1_.p1.x,_loc3_.y - _loc1_.p1.y);
  166.          nDist = _loc2_.dot(_loc2_);
  167.          if(nDist > r * r)
  168.          {
  169.             return null;
  170.          }
  171.          var cN = _loc2_.normalize();
  172.          _loc2_.length = r;
  173.          var pC2 = _loc1_.p1.addPoint(_loc2_);
  174.          var xF = pC2.x - p.x;
  175.          var yF = pC2.y - p.y;
  176.          var lR = new smashing.CollisionResult(pC2,cN,xF * xF + yF * yF);
  177.          lR.lHit = _loc1_.p1;
  178.          lR.nRatio = 1;
  179.          lR.gizmo = _loc1_;
  180.       }
  181.       else
  182.       {
  183.          var t = de / e2;
  184.          var pC = new smashing.Point(_loc1_.p0.x + _loc1_.vector.x * t,_loc1_.p0.y + _loc1_.vector.y * t);
  185.          var xDist = _loc3_.x - pC.x;
  186.          var yDist = _loc3_.y - pC.y;
  187.          if(xDist * xDist + yDist * yDist > r * r)
  188.          {
  189.             return null;
  190.          }
  191.          var pC2 = new smashing.Point(pC.x + _loc1_.normal.x * r,pC.y + _loc1_.normal.y * r);
  192.          var xF = pC2.x - p.x;
  193.          var yF = pC2.y - p.y;
  194.          var lR = new smashing.Line(pC2.x + cN.x,pC2.y + cN.y,pC2.x,pC2.y);
  195.          var dist2 = xF * xF + yF * yF;
  196.          lR = new smashing.CollisionResult(pC2,_loc1_.normal,dist2);
  197.          lR.lHit = pC;
  198.          lR.nRatio = t;
  199.          lR.gizmo = _loc1_;
  200.       }
  201.       return lR;
  202.    }
  203.    function nearestPointSeg(m0)
  204.    {
  205.       var _loc1_ = this;
  206.       var D = new smashing.Point(m0.x - _loc1_.p0.x,m0.y - _loc1_.p0.y);
  207.       var _loc2_ = _loc1_.vector.dot(D);
  208.       var e2 = _loc1_.vector.dot(_loc1_.vector);
  209.       if(_loc2_ < 0)
  210.       {
  211.          return _loc1_.p0;
  212.       }
  213.       if(_loc2_ > e2)
  214.       {
  215.          return _loc1_.p1;
  216.       }
  217.       var _loc3_ = _loc2_ / e2;
  218.       return new smashing.Point(_loc1_.p0.x + _loc1_.vector.x * _loc3_,_loc1_.p0.y + _loc1_.vector.y * _loc3_);
  219.    }
  220.    function nearestPointLine(m0)
  221.    {
  222.       var _loc1_ = this;
  223.       var _loc3_ = new smashing.Point(m0.x - _loc1_.p0.x,m0.y - _loc1_.p0.y);
  224.       var de = _loc1_.vector.dot(_loc3_);
  225.       var e2 = _loc1_.vector.dot(_loc1_.vector);
  226.       var _loc2_ = de / e2;
  227.       return new smashing.Point(_loc1_.p0.x + _loc1_.vector.x * _loc2_,_loc1_.p0.y + _loc1_.vector.y * _loc2_);
  228.    }
  229.    function nearestPointRatio(p)
  230.    {
  231.       var _loc1_ = this;
  232.       var _loc2_ = new smashing.Point(p.x - _loc1_.p0.x,p.y - _loc1_.p0.y);
  233.       var de = _loc1_.vector.dot(_loc2_);
  234.       var e2 = _loc1_.vector.dot(_loc1_.vector);
  235.       var _loc3_ = de / e2;
  236.       return _loc3_;
  237.    }
  238.    function distanceFrom(p)
  239.    {
  240.       var _loc3_ = this;
  241.       var _loc1_ = new smashing.Point(p.x - _loc3_.p0.x,p.y - _loc3_.p0.y);
  242.       var _loc2_ = _loc3_.normal.dot(_loc1_);
  243.       return _loc2_;
  244.    }
  245.    function intersection(op0, op1, oVector)
  246.    {
  247.       var _loc1_ = op0;
  248.       var a1;
  249.       var b1;
  250.       var c1;
  251.       var a2;
  252.       var b2;
  253.       var c2;
  254.       var det_inv;
  255.       var _loc3_ = undefined;
  256.       var _loc2_ = undefined;
  257.       var xi;
  258.       var yi;
  259.       if(this.vector.x != 0)
  260.       {
  261.          _loc3_ = this.vector.y / this.vector.x;
  262.       }
  263.       else
  264.       {
  265.          _loc3_ = Infinity;
  266.       }
  267.       if(op1.x - _loc1_.x != 0)
  268.       {
  269.          _loc2_ = (op1.y - _loc1_.y) / (op1.x - _loc1_.x);
  270.       }
  271.       else
  272.       {
  273.          _loc2_ = Infinity;
  274.       }
  275.       a1 = _loc3_;
  276.       a2 = _loc2_;
  277.       b1 = -1;
  278.       b2 = -1;
  279.       c1 = this.p0.y - _loc3_ * this.p0.x;
  280.       c2 = _loc1_.y - _loc2_ * _loc1_.x;
  281.       det_inv = 1 / (a1 * b2 - a2 * b1);
  282.       xi = (b1 * c2 - b2 * c1) * det_inv;
  283.       yi = (a2 * c1 - a1 * c2) * det_inv;
  284.       return new smashing.Point(xi,yi);
  285.    }
  286.    function toString()
  287.    {
  288.       var _loc1_ = this;
  289.       return "Line(" + _loc1_.p0.x + ", " + _loc1_.p0.y + ", " + _loc1_.p1.x + ", " + _loc1_.p1.y + ")";
  290.    }
  291. }
  292.