home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / org / cove / ape / SpringConstraintParticle.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  11.6 KB  |  384 lines
  1. package org.cove.ape
  2. {
  3.    import flash.display.Sprite;
  4.    
  5.    internal class SpringConstraintParticle extends RectangleParticle
  6.    {
  7.        
  8.       
  9.       private var _fixedEndLimit:Number;
  10.       
  11.       private var _rectScale:Number;
  12.       
  13.       private var rca:Vector;
  14.       
  15.       private var rcb:Vector;
  16.       
  17.       private var s:Number;
  18.       
  19.       private var parent:SpringConstraint;
  20.       
  21.       private var scaleToLength:Boolean;
  22.       
  23.       private var p1:AbstractParticle;
  24.       
  25.       private var p2:AbstractParticle;
  26.       
  27.       private var lambda:Vector;
  28.       
  29.       private var avgVelocity:Vector;
  30.       
  31.       private var _rectHeight:Number;
  32.       
  33.       public function SpringConstraintParticle(param1:AbstractParticle, param2:AbstractParticle, param3:SpringConstraint, param4:Number, param5:Number, param6:Boolean)
  34.       {
  35.          super(0,0,0,0,0,false);
  36.          this.p1 = param1;
  37.          this.p2 = param2;
  38.          lambda = new Vector(0,0);
  39.          avgVelocity = new Vector(0,0);
  40.          parent = param3;
  41.          this.rectScale = param5;
  42.          this.rectHeight = param4;
  43.          this.scaleToLength = param6;
  44.          fixedEndLimit = 0;
  45.          rca = new Vector();
  46.          rcb = new Vector();
  47.       }
  48.       
  49.       private function setCorners(param1:RectangleParticle, param2:int) : void
  50.       {
  51.          var _loc3_:Number = NaN;
  52.          var _loc4_:Number = NaN;
  53.          var _loc5_:Array = null;
  54.          var _loc6_:Array = null;
  55.          var _loc7_:Number = NaN;
  56.          var _loc8_:Number = NaN;
  57.          var _loc9_:Number = NaN;
  58.          var _loc10_:Number = NaN;
  59.          var _loc11_:Number = NaN;
  60.          var _loc12_:Number = NaN;
  61.          var _loc13_:Number = NaN;
  62.          var _loc14_:Number = NaN;
  63.          _loc3_ = Number(param1.curr.x);
  64.          _loc4_ = Number(param1.curr.y);
  65.          _loc5_ = param1.axes;
  66.          _loc6_ = param1.extents;
  67.          _loc7_ = _loc5_[0].x * _loc6_[0];
  68.          _loc8_ = _loc5_[0].y * _loc6_[0];
  69.          _loc9_ = _loc5_[1].x * _loc6_[1];
  70.          _loc10_ = _loc5_[1].y * _loc6_[1];
  71.          _loc11_ = _loc7_ - _loc9_;
  72.          _loc12_ = _loc8_ - _loc10_;
  73.          _loc13_ = _loc7_ + _loc9_;
  74.          _loc14_ = _loc8_ + _loc10_;
  75.          if(param2 == 0)
  76.          {
  77.             rca.x = _loc3_ - _loc13_;
  78.             rca.y = _loc4_ - _loc14_;
  79.             rcb.x = _loc3_ + _loc11_;
  80.             rcb.y = _loc4_ + _loc12_;
  81.          }
  82.          else if(param2 == 1)
  83.          {
  84.             rca.x = _loc3_ + _loc11_;
  85.             rca.y = _loc4_ + _loc12_;
  86.             rcb.x = _loc3_ + _loc13_;
  87.             rcb.y = _loc4_ + _loc14_;
  88.          }
  89.          else if(param2 == 2)
  90.          {
  91.             rca.x = _loc3_ + _loc13_;
  92.             rca.y = _loc4_ + _loc14_;
  93.             rcb.x = _loc3_ - _loc11_;
  94.             rcb.y = _loc4_ - _loc12_;
  95.          }
  96.          else if(param2 == 3)
  97.          {
  98.             rca.x = _loc3_ - _loc11_;
  99.             rca.y = _loc4_ - _loc12_;
  100.             rcb.x = _loc3_ - _loc13_;
  101.             rcb.y = _loc4_ - _loc14_;
  102.          }
  103.       }
  104.       
  105.       override public function init() : void
  106.       {
  107.          var _loc1_:Sprite = null;
  108.          var _loc2_:Number = NaN;
  109.          var _loc3_:Number = NaN;
  110.          if(displayObject != null)
  111.          {
  112.             initDisplay();
  113.          }
  114.          else
  115.          {
  116.             _loc1_ = new Sprite();
  117.             parent.sprite.addChild(_loc1_);
  118.             _loc1_.name = "inner";
  119.             _loc2_ = parent.currLength * rectScale;
  120.             _loc3_ = rectHeight;
  121.             _loc1_.graphics.clear();
  122.             _loc1_.graphics.lineStyle(parent.lineThickness,parent.lineColor,parent.lineAlpha);
  123.             _loc1_.graphics.beginFill(parent.fillColor,parent.fillAlpha);
  124.             _loc1_.graphics.drawRect(-_loc2_ / 2,-_loc3_ / 2,_loc2_,_loc3_);
  125.             _loc1_.graphics.endFill();
  126.          }
  127.          paint();
  128.       }
  129.       
  130.       internal function updatePosition() : void
  131.       {
  132.          var _loc1_:Vector = null;
  133.          _loc1_ = parent.center;
  134.          curr.setTo(_loc1_.x,_loc1_.y);
  135.          width = scaleToLength ? parent.currLength * rectScale : parent.restLength * rectScale;
  136.          height = rectHeight;
  137.          radian = parent.radian;
  138.       }
  139.       
  140.       private function closestPtSegmentSegment() : Number
  141.       {
  142.          var _loc1_:Vector = null;
  143.          var _loc2_:Vector = null;
  144.          var _loc3_:Vector = null;
  145.          var _loc4_:Vector = null;
  146.          var _loc5_:Vector = null;
  147.          var _loc6_:Vector = null;
  148.          var _loc7_:Vector = null;
  149.          var _loc8_:Number = NaN;
  150.          var _loc9_:Number = NaN;
  151.          var _loc10_:Number = NaN;
  152.          var _loc11_:Number = NaN;
  153.          var _loc12_:Number = NaN;
  154.          var _loc13_:Number = NaN;
  155.          var _loc14_:Number = NaN;
  156.          var _loc15_:Vector = null;
  157.          var _loc16_:Vector = null;
  158.          var _loc17_:Vector = null;
  159.          _loc1_ = p1.curr;
  160.          _loc2_ = p2.curr;
  161.          _loc3_ = rca;
  162.          _loc4_ = rcb;
  163.          _loc5_ = _loc2_.minus(_loc1_);
  164.          _loc6_ = _loc4_.minus(_loc3_);
  165.          _loc7_ = _loc1_.minus(_loc3_);
  166.          _loc9_ = _loc5_.dot(_loc5_);
  167.          _loc10_ = _loc6_.dot(_loc6_);
  168.          _loc11_ = _loc6_.dot(_loc7_);
  169.          _loc12_ = _loc5_.dot(_loc7_);
  170.          _loc13_ = _loc5_.dot(_loc6_);
  171.          if((_loc14_ = _loc9_ * _loc10_ - _loc13_ * _loc13_) != 0)
  172.          {
  173.             s = MathUtil.clamp((_loc13_ * _loc11_ - _loc12_ * _loc10_) / _loc14_,0,1);
  174.          }
  175.          else
  176.          {
  177.             s = 0.5;
  178.          }
  179.          if((_loc8_ = (_loc13_ * s + _loc11_) / _loc10_) < 0)
  180.          {
  181.             _loc8_ = 0;
  182.             s = MathUtil.clamp(-_loc12_ / _loc9_,0,1);
  183.          }
  184.          else if(_loc8_ > 0)
  185.          {
  186.             _loc8_ = 1;
  187.             s = MathUtil.clamp((_loc13_ - _loc12_) / _loc9_,0,1);
  188.          }
  189.          _loc15_ = _loc1_.plus(_loc5_.mult(s));
  190.          _loc16_ = _loc3_.plus(_loc6_.mult(_loc8_));
  191.          _loc17_ = _loc15_.minus(_loc16_);
  192.          return _loc17_.dot(_loc17_);
  193.       }
  194.       
  195.       internal function get rectHeight() : Number
  196.       {
  197.          return _rectHeight;
  198.       }
  199.       
  200.       internal function get fixedEndLimit() : Number
  201.       {
  202.          return _fixedEndLimit;
  203.       }
  204.       
  205.       private function closestParamPoint(param1:Vector) : Number
  206.       {
  207.          var _loc2_:Vector = null;
  208.          var _loc3_:Number = NaN;
  209.          _loc2_ = p2.curr.minus(p1.curr);
  210.          _loc3_ = _loc2_.dot(param1.minus(p1.curr)) / _loc2_.dot(_loc2_);
  211.          return MathUtil.clamp(_loc3_,0,1);
  212.       }
  213.       
  214.       internal function set rectHeight(param1:Number) : void
  215.       {
  216.          _rectHeight = param1;
  217.       }
  218.       
  219.       override public function paint() : void
  220.       {
  221.          var _loc1_:Vector = null;
  222.          var _loc2_:Sprite = null;
  223.          _loc1_ = parent.center;
  224.          _loc2_ = parent.sprite;
  225.          if(scaleToLength)
  226.          {
  227.             _loc2_.getChildByName("inner").width = parent.currLength * rectScale;
  228.          }
  229.          else if(displayObject != null)
  230.          {
  231.             _loc2_.getChildByName("inner").width = parent.restLength * rectScale;
  232.          }
  233.          _loc2_.x = _loc1_.x;
  234.          _loc2_.y = _loc1_.y;
  235.          _loc2_.rotation = parent.angle;
  236.       }
  237.       
  238.       private function getContactPointParam(param1:AbstractParticle) : Number
  239.       {
  240.          var _loc2_:Number = NaN;
  241.          var _loc3_:Number = NaN;
  242.          var _loc4_:Array = null;
  243.          var _loc5_:Number = NaN;
  244.          var _loc6_:int = 0;
  245.          var _loc7_:Number = NaN;
  246.          if(param1 is CircleParticle)
  247.          {
  248.             _loc2_ = closestParamPoint(param1.curr);
  249.          }
  250.          else if(param1 is RectangleParticle)
  251.          {
  252.             _loc4_ = new Array(4);
  253.             _loc5_ = Number.POSITIVE_INFINITY;
  254.             _loc6_ = 0;
  255.             while(_loc6_ < 4)
  256.             {
  257.                setCorners(param1 as RectangleParticle,_loc6_);
  258.                if((_loc7_ = closestPtSegmentSegment()) < _loc5_)
  259.                {
  260.                   _loc5_ = _loc7_;
  261.                   _loc3_ = _loc6_;
  262.                   _loc4_[_loc6_] = s;
  263.                }
  264.                _loc6_++;
  265.             }
  266.             _loc2_ = Number(_loc4_[_loc3_]);
  267.          }
  268.          return _loc2_;
  269.       }
  270.       
  271.       internal function set fixedEndLimit(param1:Number) : void
  272.       {
  273.          _fixedEndLimit = param1;
  274.       }
  275.       
  276.       override internal function get invMass() : Number
  277.       {
  278.          if(p1.fixed && p2.fixed)
  279.          {
  280.             return 0;
  281.          }
  282.          return 1 / ((p1.mass + p2.mass) / 2);
  283.       }
  284.       
  285.       override internal function initDisplay() : void
  286.       {
  287.          var _loc1_:Sprite = null;
  288.          displayObject.x = displayObjectOffset.x;
  289.          displayObject.y = displayObjectOffset.y;
  290.          displayObject.rotation = displayObjectRotation;
  291.          _loc1_ = new Sprite();
  292.          _loc1_.name = "inner";
  293.          _loc1_.addChild(displayObject);
  294.          parent.sprite.addChild(_loc1_);
  295.       }
  296.       
  297.       internal function set rectScale(param1:Number) : void
  298.       {
  299.          _rectScale = param1;
  300.       }
  301.       
  302.       override internal function resolveCollision(param1:Vector, param2:Vector, param3:Vector, param4:Number, param5:int, param6:AbstractParticle) : void
  303.       {
  304.          var _loc7_:Number = NaN;
  305.          var _loc8_:Number = NaN;
  306.          var _loc9_:Number = NaN;
  307.          var _loc10_:Number = NaN;
  308.          var _loc11_:AbstractParticle = null;
  309.          _loc7_ = getContactPointParam(param6);
  310.          _loc8_ = 1 - _loc7_;
  311.          _loc9_ = _loc7_;
  312.          if(p1.fixed)
  313.          {
  314.             if(_loc9_ <= fixedEndLimit)
  315.             {
  316.                return;
  317.             }
  318.             lambda.setTo(param1.x / _loc9_,param1.y / _loc9_);
  319.             p2.curr.plusEquals(lambda);
  320.             p2.velocity = param2;
  321.          }
  322.          else if(p2.fixed)
  323.          {
  324.             if(_loc8_ <= fixedEndLimit)
  325.             {
  326.                return;
  327.             }
  328.             lambda.setTo(param1.x / _loc8_,param1.y / _loc8_);
  329.             p1.curr.plusEquals(lambda);
  330.             p1.velocity = param2;
  331.          }
  332.          else
  333.          {
  334.             if((_loc10_ = _loc8_ * _loc8_ + _loc9_ * _loc9_) == 0)
  335.             {
  336.                return;
  337.             }
  338.             lambda.setTo(param1.x / _loc10_,param1.y / _loc10_);
  339.             p1.curr.plusEquals(lambda.mult(_loc8_));
  340.             p2.curr.plusEquals(lambda.mult(_loc9_));
  341.             if(_loc7_ == 0.5)
  342.             {
  343.                p1.velocity = param2;
  344.                p2.velocity = param2;
  345.             }
  346.             else
  347.             {
  348.                (_loc11_ = _loc7_ < 0.5 ? p1 : p2).velocity = param2;
  349.             }
  350.          }
  351.       }
  352.       
  353.       override public function get elasticity() : Number
  354.       {
  355.          return (p1.elasticity + p2.elasticity) / 2;
  356.       }
  357.       
  358.       internal function get rectScale() : Number
  359.       {
  360.          return _rectScale;
  361.       }
  362.       
  363.       override public function get velocity() : Vector
  364.       {
  365.          var _loc1_:Vector = null;
  366.          var _loc2_:Vector = null;
  367.          _loc1_ = p1.velocity;
  368.          _loc2_ = p2.velocity;
  369.          avgVelocity.setTo((_loc1_.x + _loc2_.x) / 2,(_loc1_.y + _loc2_.y) / 2);
  370.          return avgVelocity;
  371.       }
  372.       
  373.       override public function get friction() : Number
  374.       {
  375.          return (p1.friction + p2.friction) / 2;
  376.       }
  377.       
  378.       override public function get mass() : Number
  379.       {
  380.          return (p1.mass + p2.mass) / 2;
  381.       }
  382.    }
  383. }
  384.