home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / wone.swf / scripts / __Packages / CLineManager.as < prev    next >
Encoding:
Text File  |  2007-02-20  |  11.8 KB  |  326 lines
  1. class CLineManager
  2. {
  3.    var mArena;
  4.    var mLineList_Temp;
  5.    var mPointList_Temp;
  6.    var mLineList;
  7.    var mMap;
  8.    static var mCellSize = 40;
  9.    static var JoinTolerance = 5;
  10.    function CLineManager(tArena)
  11.    {
  12.       this.mArena = tArena;
  13.    }
  14.    function AddLine(node1, node2)
  15.    {
  16.       var _loc4_ = new flash.geom.Point(0,0);
  17.       var _loc3_ = new flash.geom.Point(0,0);
  18.       node1.localToGlobal(_loc4_);
  19.       this.mArena.globalToLocal(_loc4_);
  20.       node2.localToGlobal(_loc3_);
  21.       this.mArena.globalToLocal(_loc3_);
  22.       node1._visible = node2._visible = false;
  23.       this.mLineList_Temp = this.mLineList_Temp != undefined ? this.mLineList_Temp : new Array();
  24.       var _loc2_ = new Object();
  25.       _loc2_.mP1 = this.AddPoint(_loc4_,_loc2_);
  26.       _loc2_.mP2 = this.AddPoint(_loc3_,_loc2_);
  27.       this.mLineList_Temp[this.mLineList_Temp.length] = _loc2_;
  28.       _loc2_.mNormal = CLine.GetNormal(_loc4_,_loc3_);
  29.       _loc2_.mAdded = false;
  30.    }
  31.    function AddPoint(p, oLine)
  32.    {
  33.       this.mPointList_Temp = this.mPointList_Temp != undefined ? this.mPointList_Temp : new Array();
  34.       for(var _loc4_ in this.mPointList_Temp)
  35.       {
  36.          if(flash.geom.Point.distance(this.mPointList_Temp[_loc4_].mP,p) <= CLineManager.JoinTolerance)
  37.          {
  38.             this.mPointList_Temp[_loc4_].mLineList[this.mPointList_Temp[_loc4_].mLineList.length] = oLine;
  39.             return this.mPointList_Temp[_loc4_];
  40.          }
  41.       }
  42.       var _loc5_ = {mP:p,mLineList:[oLine]};
  43.       this.mPointList_Temp[this.mPointList_Temp.length] = _loc5_;
  44.       return _loc5_;
  45.    }
  46.    function Compile(r)
  47.    {
  48.       if(this.mLineList == undefined)
  49.       {
  50.          this.mLineList = new Array();
  51.          var _loc18_ = 0;
  52.          while(_loc18_ < this.mLineList_Temp.length)
  53.          {
  54.             var _loc2_ = this.mLineList_Temp[_loc18_];
  55.             while(_loc2_ != undefined && !_loc2_.mAdded)
  56.             {
  57.                var _loc17_ = _loc2_.mNormal.clone();
  58.                _loc17_.normalize(r);
  59.                var _loc5_ = _loc2_.mP1.pNext != undefined ? _loc2_.mP1.pNext : _loc2_.mP1.mP.add(_loc17_);
  60.                var _loc6_ = _loc2_.mP2.mP.add(_loc17_);
  61.                var _loc14_ = _loc2_.mP2.mP;
  62.                var _loc10_ = _loc2_.mP1.pNext == undefined && _loc2_.mP1.mLineList.length > 1;
  63.                var _loc3_ = _loc2_.mP2.mLineList[_loc2_.mP2.mLineList[0] != _loc2_ ? 0 : 1];
  64.                if(_loc3_ == undefined)
  65.                {
  66.                   if(!_loc10_)
  67.                   {
  68.                      this._AddLine2p(_loc5_,_loc6_);
  69.                      _loc2_.mAdded = true;
  70.                   }
  71.                   break;
  72.                }
  73.                var _loc7_ = _loc3_.mNormal.clone();
  74.                _loc7_.normalize(r);
  75.                var _loc9_ = _loc3_.mP1.mP.add(_loc7_);
  76.                var _loc11_ = _loc3_.mP2.mP.add(_loc7_);
  77.                if(_loc2_ == _loc3_)
  78.                {
  79.                   trace("***************** Lines are the same ***********************");
  80.                   trace(_loc5_ + "," + _loc6_ + "," + _loc9_ + "," + _loc11_);
  81.                   break;
  82.                }
  83.                var _loc8_ = CLine.LOI(_loc5_,_loc6_,_loc9_,_loc11_);
  84.                if(_loc8_ == undefined)
  85.                {
  86.                   if(!_loc10_)
  87.                   {
  88.                      this._AddLine2p(_loc5_,_loc6_);
  89.                      _loc2_.mAdded = true;
  90.                   }
  91.                   this._RoundedLine(_loc14_,_loc17_,_loc7_,r);
  92.                   _loc3_.mP1.pNext = _loc9_;
  93.                }
  94.                else
  95.                {
  96.                   if(!_loc10_)
  97.                   {
  98.                      this._AddLine2p(_loc5_,_loc8_,false,true);
  99.                      _loc2_.mAdded = true;
  100.                   }
  101.                   _loc3_.mP1.pNext = _loc8_;
  102.                   _loc3_.mP1.mConcave = true;
  103.                }
  104.                _loc2_ = _loc3_;
  105.             }
  106.             _loc18_ = _loc18_ + 1;
  107.          }
  108.          var _loc23_ = this.mArena.mEdgeDraw;
  109.          var _loc22_ = flash.display.BitmapData.loadBitmap("Graphic.Edge");
  110.          var _loc24_ = flash.display.BitmapData.loadBitmap("Graphic.Edge.2");
  111.          var _loc21_ = _loc22_.height - 1;
  112.          _loc18_ = 0;
  113.          while(_loc18_ < this.mLineList_Temp.length)
  114.          {
  115.             var _loc4_ = this.mLineList_Temp[_loc18_];
  116.             var _loc12_ = _loc4_.mP1.mLineList[_loc4_.mP1.mLineList[0] != _loc4_ ? 0 : 1];
  117.             var _loc15_ = _loc4_.mP2.mLineList[_loc4_.mP2.mLineList[0] != _loc4_ ? 0 : 1];
  118.             _loc17_ = _loc12_.mNormal;
  119.             _loc17_.normalize(_loc21_);
  120.             _loc7_ = _loc4_.mNormal;
  121.             _loc7_.normalize(_loc21_);
  122.             var _loc16_ = _loc15_.mNormal;
  123.             _loc16_.normalize(_loc21_);
  124.             var _loc20_ = _loc12_ != undefined ? CLine.LOI2(_loc12_.mP1.mP.subtract(_loc17_),_loc12_.mP2.mP.subtract(_loc17_),_loc4_.mP1.mP.subtract(_loc7_),_loc4_.mP2.mP.subtract(_loc7_)) : _loc4_.mP1.mP.subtract(_loc7_);
  125.             var _loc19_ = _loc15_ != undefined ? CLine.LOI2(_loc15_.mP1.mP.subtract(_loc16_),_loc15_.mP2.mP.subtract(_loc16_),_loc4_.mP1.mP.subtract(_loc7_),_loc4_.mP2.mP.subtract(_loc7_)) : _loc4_.mP2.mP.subtract(_loc7_);
  126.             if(_loc20_ == undefined)
  127.             {
  128.                _loc20_ = _loc4_.mP1.mP.subtract(_loc7_);
  129.             }
  130.             if(_loc19_ == undefined)
  131.             {
  132.                _loc19_ = _loc4_.mP2.mP.subtract(_loc7_);
  133.             }
  134.             this._DrawEdge(_loc23_,_loc22_,_loc4_.mP1.mP,_loc4_.mP2.mP,_loc19_,_loc20_);
  135.             _loc18_ = _loc18_ + 1;
  136.          }
  137.          delete this.mLineList_Temp;
  138.          delete this.mPointList_Temp;
  139.       }
  140.    }
  141.    function _DrawEdge(dp, tBitmap, p1, p2, p3, p4)
  142.    {
  143.       var _loc3_ = new flash.geom.Matrix();
  144.       _loc3_.rotate(Math.atan2(p2.y - p1.y,p2.x - p1.x));
  145.       _loc3_.translate(p1.x,p1.y);
  146.       dp.beginBitmapFill(tBitmap,_loc3_,true,true);
  147.       dp.moveTo(p1.x,p1.y);
  148.       dp.lineTo(p2.x,p2.y);
  149.       dp.lineTo(p3.x,p3.y);
  150.       dp.lineTo(p4.x,p4.y);
  151.       dp.lineTo(p1.x,p1.y);
  152.       dp.endFill();
  153.    }
  154.    function _RoundedLine(sharePoint, n1, n2, r)
  155.    {
  156.       if(flash.geom.Point.distance(n1,n2) <= r * 0.6666666666666666)
  157.       {
  158.          var _loc8_ = sharePoint.add(n1);
  159.          var _loc7_ = sharePoint.add(n2);
  160.          this._AddLine2p(_loc8_,_loc7_);
  161.          return undefined;
  162.       }
  163.       var _loc2_ = n1.add(n2);
  164.       _loc2_.normalize(r);
  165.       this._RoundedLine(sharePoint,n1,_loc2_,r);
  166.       this._RoundedLine(sharePoint,_loc2_,n2,r);
  167.    }
  168.    function _AddLine2p(p1, p2, tConcaveP1, tConcaveP2)
  169.    {
  170.       this.mArena.mCollisionDraw.lineStyle(0,16711935,50);
  171.       var _loc4_ = 0;
  172.       this.mArena.mCollisionDraw.moveTo(p1.x + _loc4_,p1.y + _loc4_);
  173.       this.mArena.mCollisionDraw.lineTo(p2.x + _loc4_,p2.y + _loc4_);
  174.       this.mArena.mCollisionDraw.moveTo(p1.x - 2,p1.y + 2);
  175.       this.mArena.mCollisionDraw.lineTo(p1.x + 2,p1.y - 2);
  176.       this.mArena.mCollisionDraw.moveTo(p1.x + 2,p1.y + 2);
  177.       this.mArena.mCollisionDraw.lineTo(p1.x - 2,p1.y - 2);
  178.       this.mArena.mCollisionDraw.moveTo(p2.x - 2,p2.y + 2);
  179.       this.mArena.mCollisionDraw.lineTo(p2.x + 2,p2.y - 2);
  180.       this.mArena.mCollisionDraw.moveTo(p2.x + 2,p2.y + 2);
  181.       this.mArena.mCollisionDraw.lineTo(p2.x - 2,p2.y - 2);
  182.       this._AddLine(new CLine(this.mArena,p1,p2,tConcaveP1,tConcaveP2));
  183.    }
  184.    function _AddLine(tLine)
  185.    {
  186.       this.mLineList = this.mLineList != undefined ? this.mLineList : new Array();
  187.       this.mLineList[this.mLineList.length] = tLine;
  188.       this.MarkMap(tLine);
  189.    }
  190.    function GetLineList(oldPosition, newPosition, tSize)
  191.    {
  192.       var _loc5_ = oldPosition.clone();
  193.       var _loc3_ = newPosition.clone();
  194.       if(_loc5_.x > _loc3_.x)
  195.       {
  196.          var _loc8_ = _loc5_.x;
  197.          _loc5_.x = _loc3_.x;
  198.          _loc3_.x = _loc8_;
  199.       }
  200.       if(_loc5_.y > _loc3_.y)
  201.       {
  202.          _loc8_ = _loc5_.y;
  203.          _loc5_.y = _loc3_.y;
  204.          _loc3_.y = _loc8_;
  205.       }
  206.       _loc5_.x = Math.floor(_loc5_.x / CLineManager.mCellSize);
  207.       _loc5_.y = Math.floor(_loc5_.y / CLineManager.mCellSize);
  208.       _loc3_.x = Math.floor(_loc3_.x / CLineManager.mCellSize);
  209.       _loc3_.y = Math.floor(_loc3_.y / CLineManager.mCellSize);
  210.       var _loc7_ = new Array();
  211.       var _loc4_ = _loc5_.y;
  212.       while(_loc4_ <= _loc3_.y)
  213.       {
  214.          var _loc6_ = this.mMap[_loc4_];
  215.          var _loc2_ = _loc5_.x;
  216.          while(_loc2_ <= _loc3_.x)
  217.          {
  218.             this.AddToLL(_loc7_,_loc6_[_loc2_]);
  219.             _loc2_ = _loc2_ + 1;
  220.          }
  221.          _loc4_ = _loc4_ + 1;
  222.       }
  223.       return _loc7_;
  224.    }
  225.    function AddToLL(ll, pll)
  226.    {
  227.       for(var _loc5_ in pll)
  228.       {
  229.          var _loc2_ = true;
  230.          for(var _loc4_ in ll)
  231.          {
  232.             if(pll[_loc5_] == ll[_loc4_])
  233.             {
  234.                _loc2_ = false;
  235.                break;
  236.             }
  237.          }
  238.          if(_loc2_)
  239.          {
  240.             ll[ll.length] = pll[_loc5_];
  241.          }
  242.       }
  243.    }
  244.    function MarkMap(tLine)
  245.    {
  246.       var _loc7_ = tLine.mP1;
  247.       var _loc6_ = tLine.mP2;
  248.       var _loc2_ = _loc6_.subtract(_loc7_);
  249.       if(Math.abs(_loc2_.x) > Math.abs(_loc2_.y))
  250.       {
  251.          var _loc3_ = _loc6_.x <= _loc7_.x ? _loc6_.clone() : _loc7_.clone();
  252.          var _loc9_ = _loc6_.x <= _loc7_.x ? _loc7_.clone() : _loc6_.clone();
  253.          _loc2_ = _loc9_.subtract(_loc3_);
  254.          var _loc8_ = Math.ceil(_loc2_.x / CLineManager.mCellSize);
  255.          _loc2_.y = _loc2_.y / _loc2_.x * CLineManager.mCellSize;
  256.          _loc2_.x = CLineManager.mCellSize;
  257.          this.MarkMap_Cell(tLine,_loc3_);
  258.          var _loc4_ = undefined;
  259.          while((_loc8_ = _loc8_ - 1) >= 0)
  260.          {
  261.             if(_loc4_ != undefined)
  262.             {
  263.                this._mmCell(tLine,_loc3_,_loc4_);
  264.             }
  265.             _loc4_ = _loc3_;
  266.             _loc3_ = _loc3_.add(_loc2_);
  267.          }
  268.          this._mmCell(tLine,_loc9_,_loc4_);
  269.       }
  270.       else
  271.       {
  272.          _loc3_ = _loc6_.y <= _loc7_.y ? _loc6_.clone() : _loc7_.clone();
  273.          _loc9_ = _loc6_.y <= _loc7_.y ? _loc7_.clone() : _loc6_.clone();
  274.          _loc2_ = _loc9_.subtract(_loc3_);
  275.          _loc8_ = Math.ceil(_loc2_.y / CLineManager.mCellSize);
  276.          _loc2_.x = _loc2_.x / _loc2_.y * CLineManager.mCellSize;
  277.          _loc2_.y = CLineManager.mCellSize;
  278.          this.MarkMap_Cell(tLine,_loc3_);
  279.          while((_loc8_ = _loc8_ - 1) >= 0)
  280.          {
  281.             if(_loc4_ != undefined)
  282.             {
  283.                this._mmCell(tLine,_loc3_,_loc4_);
  284.             }
  285.             _loc4_ = _loc3_;
  286.             _loc3_ = _loc3_.add(_loc2_);
  287.          }
  288.          this._mmCell(tLine,_loc9_,_loc4_);
  289.       }
  290.    }
  291.    function _mmCell(tLine, sp, lsp)
  292.    {
  293.       this.MarkMap_Cell(tLine,new flash.geom.Point(sp.x,sp.y));
  294.       this.MarkMap_Cell(tLine,new flash.geom.Point(sp.x,lsp.y));
  295.       this.MarkMap_Cell(tLine,new flash.geom.Point(lsp.x,sp.y));
  296.    }
  297.    function MarkMap_Cell(tLine, p)
  298.    {
  299.       p = p.clone();
  300.       p.x = Math.floor(p.x / CLineManager.mCellSize);
  301.       p.y = Math.floor(p.y / CLineManager.mCellSize);
  302.       if(p.x < 0 || p.y < 0)
  303.       {
  304.          return undefined;
  305.       }
  306.       this.mMap = this.mMap != undefined ? this.mMap : (this.mMap = new Array());
  307.       this.mMap[p.y] = this.mMap[p.y] != undefined ? this.mMap[p.y] : (this.mMap[p.y] = new Array());
  308.       this.mMap[p.y][p.x] = this.mMap[p.y][p.x] != undefined ? this.mMap[p.y][p.x] : (this.mMap[p.y][p.x] = new Array());
  309.       var _loc3_ = this.mMap[p.y][p.x];
  310.       var _loc4_ = false;
  311.       for(var _loc8_ in _loc3_)
  312.       {
  313.          if(_loc3_[_loc8_] == tLine)
  314.          {
  315.             _loc4_ = true;
  316.             break;
  317.          }
  318.       }
  319.       if(!_loc4_)
  320.       {
  321.          _loc3_[_loc3_.length] = tLine;
  322.       }
  323.       return undefined;
  324.    }
  325. }
  326.