home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / wone.swf / scripts / __Packages / CLine.as < prev    next >
Encoding:
Text File  |  2007-02-20  |  4.7 KB  |  143 lines
  1. class CLine
  2. {
  3.    var mArena;
  4.    var mP1;
  5.    var mP2;
  6.    var mConcaveP1;
  7.    var mConcaveP2;
  8.    var mMatrix;
  9.    var iMatrix;
  10.    var mNormal;
  11.    var mPointOfIntersection;
  12.    function CLine(tArena, p1, p2, tConcaveP1, tConcaveP2)
  13.    {
  14.       this.mArena = tArena;
  15.       this.mP1 = p1;
  16.       this.mP2 = p2;
  17.       this.mConcaveP1 = tConcaveP1;
  18.       this.mConcaveP2 = tConcaveP2;
  19.       var _loc3_ = Math.atan2(this.mP2.y - this.mP1.y,this.mP2.x - this.mP1.x);
  20.       this.mMatrix = new flash.geom.Matrix();
  21.       this.mMatrix.rotate(- _loc3_);
  22.       this.iMatrix = this.mMatrix.clone();
  23.       this.iMatrix.invert();
  24.       var _loc2_ = new flash.geom.Matrix();
  25.       _loc2_.rotate(1.5707963267948966);
  26.       this.mNormal = new flash.geom.Point(this.mP2.x - this.mP1.x,this.mP2.y - this.mP1.y);
  27.       this.mNormal = _loc2_.transformPoint(this.mNormal);
  28.       this.mNormal = CLine.GetNormal(this.mP1,this.mP2);
  29.    }
  30.    function LineReflection(d)
  31.    {
  32.       return new flash.geom.Point(d.x - 2 * this.DotProduct(d,this.mNormal) * this.mNormal.x,d.y - 2 * this.DotProduct(d,this.mNormal) * this.mNormal.y);
  33.    }
  34.    function DotProduct(p1, p2)
  35.    {
  36.       return p1.x * p2.x + p1.y * p2.y;
  37.    }
  38.    function CrossProduct(p1, p2)
  39.    {
  40.       return new flash.geom.Point(p1.y * p2.x - p1.x * p2.y,p1.x * p2.y - p1.y * p2.x);
  41.    }
  42.    static function WheelToLineList(tLineList, wp1, wp2, r)
  43.    {
  44.       var _loc2_ = new Array();
  45.       for(var _loc6_ in tLineList)
  46.       {
  47.          if(tLineList[_loc6_].WheelToLine(wp1,wp2,r) != undefined)
  48.          {
  49.             _loc2_[_loc2_.length] = tLineList[_loc6_];
  50.          }
  51.       }
  52.       return _loc2_;
  53.    }
  54.    static function CollisionError(tLineList, p, d)
  55.    {
  56.       for(var _loc8_ in tLineList)
  57.       {
  58.          var _loc1_ = tLineList[_loc8_];
  59.          if(_loc1_.SideOfLine(p.add(d)) < 0)
  60.          {
  61.             var _loc3_ = _loc1_.mNormal.clone();
  62.             _loc3_.normalize(d.length * 2);
  63.             var _loc6_ = p.add(d).add(_loc3_);
  64.             var _loc5_ = undefined;
  65.             if((_loc5_ = _loc1_._LOI_WithCorrection(p.add(d),_loc6_)) != undefined)
  66.             {
  67.                return _loc5_;
  68.             }
  69.          }
  70.       }
  71.       return p.add(d);
  72.    }
  73.    function WheelToLine(wp1, wp2, r)
  74.    {
  75.       return this.SideOfLine(wp1) >= 0 ? (this.mPointOfIntersection = this._LOI_WithCorrection(wp1,wp2)) : undefined;
  76.    }
  77.    function SideOfLine(p)
  78.    {
  79.       return CLine._SideOfLine(p,this.mP1,this.mP2);
  80.    }
  81.    static function _SideOfLine(p, p1, p2)
  82.    {
  83.       return - ((p2.x - p1.x) * (p.y - p1.y) - (p.x - p1.x) * (p2.y - p1.y));
  84.    }
  85.    function _LOI_WithCorrection(p1, p2)
  86.    {
  87.       var _loc2_ = this._LOI(p1,p2);
  88.       if(_loc2_ == undefined)
  89.       {
  90.          return undefined;
  91.       }
  92.       var _loc3_ = this.mNormal.clone();
  93.       _loc3_.normalize(0.5);
  94.       return _loc2_.add(_loc3_);
  95.    }
  96.    function _LOI(p1, p2)
  97.    {
  98.       return CLine.LOI(p1,p2,this.mP2,this.mP1);
  99.    }
  100.    static function LOI(l1p1, l1p2, l2p1, l2p2)
  101.    {
  102.       var _loc11_ = l2p2.x - l2p1.x;
  103.       var _loc10_ = l2p2.y - l2p1.y;
  104.       var _loc9_ = l1p2.x - l1p1.x;
  105.       var _loc8_ = l1p2.y - l1p1.y;
  106.       var _loc4_ = ((l2p1.y - l1p1.y) * _loc9_ - (l2p1.x - l1p1.x) * _loc8_) / (_loc11_ * _loc8_ - _loc10_ * _loc9_);
  107.       var _loc6_ = new flash.geom.Point(l2p1.x + _loc4_ * _loc11_,l2p1.y + _loc4_ * _loc10_);
  108.       if(isNaN(_loc6_.x))
  109.       {
  110.          _loc6_ = !l2p1.equals(l2p2) ? (!l1p1.equals(l1p2) ? undefined : l1p1.clone()) : l2p2.clone();
  111.       }
  112.       _loc11_ = l1p2.x - l1p1.x;
  113.       _loc10_ = l1p2.y - l1p1.y;
  114.       _loc9_ = l2p2.x - l2p1.x;
  115.       _loc8_ = l2p2.y - l2p1.y;
  116.       var _loc7_ = ((l1p1.y - l2p1.y) * _loc9_ - (l1p1.x - l2p1.x) * _loc8_) / (_loc11_ * _loc8_ - _loc10_ * _loc9_);
  117.       return !(_loc4_ >= 0 && _loc4_ <= 1 && _loc7_ >= 0 && _loc7_ <= 1) ? undefined : _loc6_;
  118.    }
  119.    static function LOI2(l1p1, l1p2, l2p1, l2p2)
  120.    {
  121.       var _loc11_ = l1p2.y - l1p1.y;
  122.       var _loc9_ = l1p1.x - l1p2.x;
  123.       var _loc7_ = l1p2.x * l1p1.y - l1p1.x * l1p2.y;
  124.       var _loc10_ = l2p2.y - l2p1.y;
  125.       var _loc8_ = l2p1.x - l2p2.x;
  126.       var _loc6_ = l2p2.x * l2p1.y - l2p1.x * l2p2.y;
  127.       var _loc1_ = _loc11_ * _loc8_ - _loc10_ * _loc9_;
  128.       if(_loc1_ == 0)
  129.       {
  130.          return undefined;
  131.       }
  132.       return new flash.geom.Point((_loc9_ * _loc6_ - _loc8_ * _loc7_) / _loc1_,(_loc10_ * _loc7_ - _loc11_ * _loc6_) / _loc1_);
  133.    }
  134.    static function GetNormal(p1, p2)
  135.    {
  136.       var _loc1_ = new flash.geom.Matrix();
  137.       _loc1_.rotate(-1.5707963267948966);
  138.       var _loc2_ = _loc1_.transformPoint(new flash.geom.Point(p2.x - p1.x,p2.y - p1.y));
  139.       _loc2_.normalize(1);
  140.       return _loc2_;
  141.    }
  142. }
  143.