home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / Beez.swf / scripts / Box2D / Dynamics / Joints / b2PulleyJoint.as < prev    next >
Encoding:
Text File  |  2008-09-03  |  18.7 KB  |  499 lines
  1. package Box2D.Dynamics.Joints
  2. {
  3.    import Box2D.Common.Math.b2Mat22;
  4.    import Box2D.Common.Math.b2Math;
  5.    import Box2D.Common.Math.b2Vec2;
  6.    import Box2D.Common.b2Settings;
  7.    import Box2D.Dynamics.b2Body;
  8.    import Box2D.Dynamics.b2TimeStep;
  9.    
  10.    public class b2PulleyJoint extends b2Joint
  11.    {
  12.       
  13.       public static const b2_minPulleyLength:Number = 2;
  14.        
  15.       
  16.       public var m_limitState1:int;
  17.       
  18.       public var m_limitState2:int;
  19.       
  20.       public var m_ground:b2Body;
  21.       
  22.       public var m_maxLength2:Number;
  23.       
  24.       public var m_maxLength1:Number;
  25.       
  26.       public var m_limitPositionImpulse1:Number;
  27.       
  28.       public var m_limitPositionImpulse2:Number;
  29.       
  30.       public var m_force:Number;
  31.       
  32.       public var m_constant:Number;
  33.       
  34.       public var m_positionImpulse:Number;
  35.       
  36.       public var m_state:int;
  37.       
  38.       public var m_ratio:Number;
  39.       
  40.       public var m_groundAnchor1:b2Vec2;
  41.       
  42.       public var m_groundAnchor2:b2Vec2;
  43.       
  44.       public var m_localAnchor1:b2Vec2;
  45.       
  46.       public var m_localAnchor2:b2Vec2;
  47.       
  48.       public var m_limitMass1:Number;
  49.       
  50.       public var m_limitMass2:Number;
  51.       
  52.       public var m_pulleyMass:Number;
  53.       
  54.       public var m_u1:b2Vec2;
  55.       
  56.       public var m_limitForce1:Number;
  57.       
  58.       public var m_limitForce2:Number;
  59.       
  60.       public var m_u2:b2Vec2;
  61.       
  62.       public function b2PulleyJoint(def:b2PulleyJointDef)
  63.       {
  64.          var tMat:b2Mat22 = null;
  65.          var tX:Number = NaN;
  66.          var tY:Number = NaN;
  67.          m_groundAnchor1 = new b2Vec2();
  68.          m_groundAnchor2 = new b2Vec2();
  69.          m_localAnchor1 = new b2Vec2();
  70.          m_localAnchor2 = new b2Vec2();
  71.          m_u1 = new b2Vec2();
  72.          m_u2 = new b2Vec2();
  73.          super(def);
  74.          m_ground = m_body1.m_world.m_groundBody;
  75.          m_groundAnchor1.x = def.groundAnchor1.x - m_ground.m_xf.position.x;
  76.          m_groundAnchor1.y = def.groundAnchor1.y - m_ground.m_xf.position.y;
  77.          m_groundAnchor2.x = def.groundAnchor2.x - m_ground.m_xf.position.x;
  78.          m_groundAnchor2.y = def.groundAnchor2.y - m_ground.m_xf.position.y;
  79.          m_localAnchor1.SetV(def.localAnchor1);
  80.          m_localAnchor2.SetV(def.localAnchor2);
  81.          m_ratio = def.ratio;
  82.          m_constant = def.length1 + m_ratio * def.length2;
  83.          m_maxLength1 = b2Math.b2Min(def.maxLength1,m_constant - m_ratio * b2_minPulleyLength);
  84.          m_maxLength2 = b2Math.b2Min(def.maxLength2,(m_constant - b2_minPulleyLength) / m_ratio);
  85.          m_force = 0;
  86.          m_limitForce1 = 0;
  87.          m_limitForce2 = 0;
  88.       }
  89.       
  90.       public function GetGroundAnchor2() : b2Vec2
  91.       {
  92.          var a:b2Vec2 = m_ground.m_xf.position.Copy();
  93.          a.Add(m_groundAnchor2);
  94.          return a;
  95.       }
  96.       
  97.       override public function GetAnchor1() : b2Vec2
  98.       {
  99.          return m_body1.GetWorldPoint(m_localAnchor1);
  100.       }
  101.       
  102.       override public function GetAnchor2() : b2Vec2
  103.       {
  104.          return m_body2.GetWorldPoint(m_localAnchor2);
  105.       }
  106.       
  107.       override public function GetReactionForce() : b2Vec2
  108.       {
  109.          var F:b2Vec2 = m_u2.Copy();
  110.          F.Multiply(m_force);
  111.          return F;
  112.       }
  113.       
  114.       override public function SolvePositionConstraints() : Boolean
  115.       {
  116.          var tMat:b2Mat22 = null;
  117.          var r1X:Number = NaN;
  118.          var r1Y:Number = NaN;
  119.          var r2X:Number = NaN;
  120.          var r2Y:Number = NaN;
  121.          var p1X:Number = NaN;
  122.          var p1Y:Number = NaN;
  123.          var p2X:Number = NaN;
  124.          var p2Y:Number = NaN;
  125.          var length1:Number = NaN;
  126.          var length2:Number = NaN;
  127.          var C:Number = NaN;
  128.          var impulse:Number = NaN;
  129.          var oldImpulse:Number = NaN;
  130.          var oldLimitPositionImpulse:Number = NaN;
  131.          var tX:Number = NaN;
  132.          var b1:b2Body = m_body1;
  133.          var b2:b2Body = m_body2;
  134.          var s1X:Number = m_ground.m_xf.position.x + m_groundAnchor1.x;
  135.          var s1Y:Number = m_ground.m_xf.position.y + m_groundAnchor1.y;
  136.          var s2X:Number = m_ground.m_xf.position.x + m_groundAnchor2.x;
  137.          var s2Y:Number = m_ground.m_xf.position.y + m_groundAnchor2.y;
  138.          var linearError:Number = 0;
  139.          if(m_state == e_atUpperLimit)
  140.          {
  141.             tMat = b1.m_xf.R;
  142.             r1X = m_localAnchor1.x - b1.m_sweep.localCenter.x;
  143.             r1Y = m_localAnchor1.y - b1.m_sweep.localCenter.y;
  144.             tX = tMat.col1.x * r1X + tMat.col2.x * r1Y;
  145.             r1Y = tMat.col1.y * r1X + tMat.col2.y * r1Y;
  146.             r1X = tX;
  147.             tMat = b2.m_xf.R;
  148.             r2X = m_localAnchor2.x - b2.m_sweep.localCenter.x;
  149.             r2Y = m_localAnchor2.y - b2.m_sweep.localCenter.y;
  150.             tX = tMat.col1.x * r2X + tMat.col2.x * r2Y;
  151.             r2Y = tMat.col1.y * r2X + tMat.col2.y * r2Y;
  152.             r2X = tX;
  153.             p1X = b1.m_sweep.c.x + r1X;
  154.             p1Y = b1.m_sweep.c.y + r1Y;
  155.             p2X = b2.m_sweep.c.x + r2X;
  156.             p2Y = b2.m_sweep.c.y + r2Y;
  157.             m_u1.Set(p1X - s1X,p1Y - s1Y);
  158.             m_u2.Set(p2X - s2X,p2Y - s2Y);
  159.             length1 = m_u1.Length();
  160.             length2 = m_u2.Length();
  161.             if(length1 > b2Settings.b2_linearSlop)
  162.             {
  163.                m_u1.Multiply(1 / length1);
  164.             }
  165.             else
  166.             {
  167.                m_u1.SetZero();
  168.             }
  169.             if(length2 > b2Settings.b2_linearSlop)
  170.             {
  171.                m_u2.Multiply(1 / length2);
  172.             }
  173.             else
  174.             {
  175.                m_u2.SetZero();
  176.             }
  177.             C = m_constant - length1 - m_ratio * length2;
  178.             linearError = b2Math.b2Max(linearError,-C);
  179.             C = b2Math.b2Clamp(C + b2Settings.b2_linearSlop,-b2Settings.b2_maxLinearCorrection,0);
  180.             impulse = -m_pulleyMass * C;
  181.             oldImpulse = m_positionImpulse;
  182.             m_positionImpulse = b2Math.b2Max(0,m_positionImpulse + impulse);
  183.             impulse = m_positionImpulse - oldImpulse;
  184.             p1X = -impulse * m_u1.x;
  185.             p1Y = -impulse * m_u1.y;
  186.             p2X = -m_ratio * impulse * m_u2.x;
  187.             p2Y = -m_ratio * impulse * m_u2.y;
  188.             b1.m_sweep.c.x += b1.m_invMass * p1X;
  189.             b1.m_sweep.c.y += b1.m_invMass * p1Y;
  190.             b1.m_sweep.a += b1.m_invI * (r1X * p1Y - r1Y * p1X);
  191.             b2.m_sweep.c.x += b2.m_invMass * p2X;
  192.             b2.m_sweep.c.y += b2.m_invMass * p2Y;
  193.             b2.m_sweep.a += b2.m_invI * (r2X * p2Y - r2Y * p2X);
  194.             b1.SynchronizeTransform();
  195.             b2.SynchronizeTransform();
  196.          }
  197.          if(m_limitState1 == e_atUpperLimit)
  198.          {
  199.             tMat = b1.m_xf.R;
  200.             r1X = m_localAnchor1.x - b1.m_sweep.localCenter.x;
  201.             r1Y = m_localAnchor1.y - b1.m_sweep.localCenter.y;
  202.             tX = tMat.col1.x * r1X + tMat.col2.x * r1Y;
  203.             r1Y = tMat.col1.y * r1X + tMat.col2.y * r1Y;
  204.             r1X = tX;
  205.             p1X = b1.m_sweep.c.x + r1X;
  206.             p1Y = b1.m_sweep.c.y + r1Y;
  207.             m_u1.Set(p1X - s1X,p1Y - s1Y);
  208.             length1 = m_u1.Length();
  209.             if(length1 > b2Settings.b2_linearSlop)
  210.             {
  211.                m_u1.x *= 1 / length1;
  212.                m_u1.y *= 1 / length1;
  213.             }
  214.             else
  215.             {
  216.                m_u1.SetZero();
  217.             }
  218.             C = m_maxLength1 - length1;
  219.             linearError = b2Math.b2Max(linearError,-C);
  220.             C = b2Math.b2Clamp(C + b2Settings.b2_linearSlop,-b2Settings.b2_maxLinearCorrection,0);
  221.             impulse = -m_limitMass1 * C;
  222.             oldLimitPositionImpulse = m_limitPositionImpulse1;
  223.             m_limitPositionImpulse1 = b2Math.b2Max(0,m_limitPositionImpulse1 + impulse);
  224.             impulse = m_limitPositionImpulse1 - oldLimitPositionImpulse;
  225.             p1X = -impulse * m_u1.x;
  226.             p1Y = -impulse * m_u1.y;
  227.             b1.m_sweep.c.x += b1.m_invMass * p1X;
  228.             b1.m_sweep.c.y += b1.m_invMass * p1Y;
  229.             b1.m_sweep.a += b1.m_invI * (r1X * p1Y - r1Y * p1X);
  230.             b1.SynchronizeTransform();
  231.          }
  232.          if(m_limitState2 == e_atUpperLimit)
  233.          {
  234.             tMat = b2.m_xf.R;
  235.             r2X = m_localAnchor2.x - b2.m_sweep.localCenter.x;
  236.             r2Y = m_localAnchor2.y - b2.m_sweep.localCenter.y;
  237.             tX = tMat.col1.x * r2X + tMat.col2.x * r2Y;
  238.             r2Y = tMat.col1.y * r2X + tMat.col2.y * r2Y;
  239.             r2X = tX;
  240.             p2X = b2.m_sweep.c.x + r2X;
  241.             p2Y = b2.m_sweep.c.y + r2Y;
  242.             m_u2.Set(p2X - s2X,p2Y - s2Y);
  243.             length2 = m_u2.Length();
  244.             if(length2 > b2Settings.b2_linearSlop)
  245.             {
  246.                m_u2.x *= 1 / length2;
  247.                m_u2.y *= 1 / length2;
  248.             }
  249.             else
  250.             {
  251.                m_u2.SetZero();
  252.             }
  253.             C = m_maxLength2 - length2;
  254.             linearError = b2Math.b2Max(linearError,-C);
  255.             C = b2Math.b2Clamp(C + b2Settings.b2_linearSlop,-b2Settings.b2_maxLinearCorrection,0);
  256.             impulse = -m_limitMass2 * C;
  257.             oldLimitPositionImpulse = m_limitPositionImpulse2;
  258.             m_limitPositionImpulse2 = b2Math.b2Max(0,m_limitPositionImpulse2 + impulse);
  259.             impulse = m_limitPositionImpulse2 - oldLimitPositionImpulse;
  260.             p2X = -impulse * m_u2.x;
  261.             p2Y = -impulse * m_u2.y;
  262.             b2.m_sweep.c.x += b2.m_invMass * p2X;
  263.             b2.m_sweep.c.y += b2.m_invMass * p2Y;
  264.             b2.m_sweep.a += b2.m_invI * (r2X * p2Y - r2Y * p2X);
  265.             b2.SynchronizeTransform();
  266.          }
  267.          return linearError < b2Settings.b2_linearSlop;
  268.       }
  269.       
  270.       override public function InitVelocityConstraints(step:b2TimeStep) : void
  271.       {
  272.          var tMat:b2Mat22 = null;
  273.          var P1X:Number = NaN;
  274.          var P1Y:Number = NaN;
  275.          var P2X:Number = NaN;
  276.          var P2Y:Number = NaN;
  277.          var b1:b2Body = m_body1;
  278.          var b2:b2Body = m_body2;
  279.          tMat = b1.m_xf.R;
  280.          var r1X:Number = m_localAnchor1.x - b1.m_sweep.localCenter.x;
  281.          var r1Y:Number = m_localAnchor1.y - b1.m_sweep.localCenter.y;
  282.          var tX:Number = tMat.col1.x * r1X + tMat.col2.x * r1Y;
  283.          r1Y = tMat.col1.y * r1X + tMat.col2.y * r1Y;
  284.          r1X = tX;
  285.          tMat = b2.m_xf.R;
  286.          var r2X:Number = m_localAnchor2.x - b2.m_sweep.localCenter.x;
  287.          var r2Y:Number = m_localAnchor2.y - b2.m_sweep.localCenter.y;
  288.          tX = tMat.col1.x * r2X + tMat.col2.x * r2Y;
  289.          r2Y = tMat.col1.y * r2X + tMat.col2.y * r2Y;
  290.          r2X = tX;
  291.          var p1X:Number = b1.m_sweep.c.x + r1X;
  292.          var p1Y:Number = b1.m_sweep.c.y + r1Y;
  293.          var p2X:Number = b2.m_sweep.c.x + r2X;
  294.          var p2Y:Number = b2.m_sweep.c.y + r2Y;
  295.          var s1X:Number = m_ground.m_xf.position.x + m_groundAnchor1.x;
  296.          var s1Y:Number = m_ground.m_xf.position.y + m_groundAnchor1.y;
  297.          var s2X:Number = m_ground.m_xf.position.x + m_groundAnchor2.x;
  298.          var s2Y:Number = m_ground.m_xf.position.y + m_groundAnchor2.y;
  299.          m_u1.Set(p1X - s1X,p1Y - s1Y);
  300.          m_u2.Set(p2X - s2X,p2Y - s2Y);
  301.          var length1:Number = m_u1.Length();
  302.          var length2:Number = m_u2.Length();
  303.          if(length1 > b2Settings.b2_linearSlop)
  304.          {
  305.             m_u1.Multiply(1 / length1);
  306.          }
  307.          else
  308.          {
  309.             m_u1.SetZero();
  310.          }
  311.          if(length2 > b2Settings.b2_linearSlop)
  312.          {
  313.             m_u2.Multiply(1 / length2);
  314.          }
  315.          else
  316.          {
  317.             m_u2.SetZero();
  318.          }
  319.          var C:Number = m_constant - length1 - m_ratio * length2;
  320.          if(C > 0)
  321.          {
  322.             m_state = e_inactiveLimit;
  323.             m_force = 0;
  324.          }
  325.          else
  326.          {
  327.             m_state = e_atUpperLimit;
  328.             m_positionImpulse = 0;
  329.          }
  330.          if(length1 < m_maxLength1)
  331.          {
  332.             m_limitState1 = e_inactiveLimit;
  333.             m_limitForce1 = 0;
  334.          }
  335.          else
  336.          {
  337.             m_limitState1 = e_atUpperLimit;
  338.             m_limitPositionImpulse1 = 0;
  339.          }
  340.          if(length2 < m_maxLength2)
  341.          {
  342.             m_limitState2 = e_inactiveLimit;
  343.             m_limitForce2 = 0;
  344.          }
  345.          else
  346.          {
  347.             m_limitState2 = e_atUpperLimit;
  348.             m_limitPositionImpulse2 = 0;
  349.          }
  350.          var cr1u1:Number = r1X * m_u1.y - r1Y * m_u1.x;
  351.          var cr2u2:Number = r2X * m_u2.y - r2Y * m_u2.x;
  352.          m_limitMass1 = b1.m_invMass + b1.m_invI * cr1u1 * cr1u1;
  353.          m_limitMass2 = b2.m_invMass + b2.m_invI * cr2u2 * cr2u2;
  354.          m_pulleyMass = m_limitMass1 + m_ratio * m_ratio * m_limitMass2;
  355.          m_limitMass1 = 1 / m_limitMass1;
  356.          m_limitMass2 = 1 / m_limitMass2;
  357.          m_pulleyMass = 1 / m_pulleyMass;
  358.          if(step.warmStarting)
  359.          {
  360.             P1X = step.dt * (-m_force - m_limitForce1) * m_u1.x;
  361.             P1Y = step.dt * (-m_force - m_limitForce1) * m_u1.y;
  362.             P2X = step.dt * (-m_ratio * m_force - m_limitForce2) * m_u2.x;
  363.             P2Y = step.dt * (-m_ratio * m_force - m_limitForce2) * m_u2.y;
  364.             b1.m_linearVelocity.x += b1.m_invMass * P1X;
  365.             b1.m_linearVelocity.y += b1.m_invMass * P1Y;
  366.             b1.m_angularVelocity += b1.m_invI * (r1X * P1Y - r1Y * P1X);
  367.             b2.m_linearVelocity.x += b2.m_invMass * P2X;
  368.             b2.m_linearVelocity.y += b2.m_invMass * P2Y;
  369.             b2.m_angularVelocity += b2.m_invI * (r2X * P2Y - r2Y * P2X);
  370.          }
  371.          else
  372.          {
  373.             m_force = 0;
  374.             m_limitForce1 = 0;
  375.             m_limitForce2 = 0;
  376.          }
  377.       }
  378.       
  379.       override public function GetReactionTorque() : Number
  380.       {
  381.          return 0;
  382.       }
  383.       
  384.       public function GetRatio() : Number
  385.       {
  386.          return m_ratio;
  387.       }
  388.       
  389.       override public function SolveVelocityConstraints(step:b2TimeStep) : void
  390.       {
  391.          var tMat:b2Mat22 = null;
  392.          var v1X:Number = NaN;
  393.          var v1Y:Number = NaN;
  394.          var v2X:Number = NaN;
  395.          var v2Y:Number = NaN;
  396.          var P1X:Number = NaN;
  397.          var P1Y:Number = NaN;
  398.          var P2X:Number = NaN;
  399.          var P2Y:Number = NaN;
  400.          var Cdot:Number = NaN;
  401.          var force:Number = NaN;
  402.          var oldForce:Number = NaN;
  403.          var b1:b2Body = m_body1;
  404.          var b2:b2Body = m_body2;
  405.          tMat = b1.m_xf.R;
  406.          var r1X:Number = m_localAnchor1.x - b1.m_sweep.localCenter.x;
  407.          var r1Y:Number = m_localAnchor1.y - b1.m_sweep.localCenter.y;
  408.          var tX:Number = tMat.col1.x * r1X + tMat.col2.x * r1Y;
  409.          r1Y = tMat.col1.y * r1X + tMat.col2.y * r1Y;
  410.          r1X = tX;
  411.          tMat = b2.m_xf.R;
  412.          var r2X:Number = m_localAnchor2.x - b2.m_sweep.localCenter.x;
  413.          var r2Y:Number = m_localAnchor2.y - b2.m_sweep.localCenter.y;
  414.          tX = tMat.col1.x * r2X + tMat.col2.x * r2Y;
  415.          r2Y = tMat.col1.y * r2X + tMat.col2.y * r2Y;
  416.          r2X = tX;
  417.          if(m_state == e_atUpperLimit)
  418.          {
  419.             v1X = b1.m_linearVelocity.x + -b1.m_angularVelocity * r1Y;
  420.             v1Y = b1.m_linearVelocity.y + b1.m_angularVelocity * r1X;
  421.             v2X = b2.m_linearVelocity.x + -b2.m_angularVelocity * r2Y;
  422.             v2Y = b2.m_linearVelocity.y + b2.m_angularVelocity * r2X;
  423.             Cdot = -(m_u1.x * v1X + m_u1.y * v1Y) - m_ratio * (m_u2.x * v2X + m_u2.y * v2Y);
  424.             force = -step.inv_dt * m_pulleyMass * Cdot;
  425.             oldForce = m_force;
  426.             m_force = b2Math.b2Max(0,m_force + force);
  427.             force = m_force - oldForce;
  428.             P1X = -step.dt * force * m_u1.x;
  429.             P1Y = -step.dt * force * m_u1.y;
  430.             P2X = -step.dt * m_ratio * force * m_u2.x;
  431.             P2Y = -step.dt * m_ratio * force * m_u2.y;
  432.             b1.m_linearVelocity.x += b1.m_invMass * P1X;
  433.             b1.m_linearVelocity.y += b1.m_invMass * P1Y;
  434.             b1.m_angularVelocity += b1.m_invI * (r1X * P1Y - r1Y * P1X);
  435.             b2.m_linearVelocity.x += b2.m_invMass * P2X;
  436.             b2.m_linearVelocity.y += b2.m_invMass * P2Y;
  437.             b2.m_angularVelocity += b2.m_invI * (r2X * P2Y - r2Y * P2X);
  438.          }
  439.          if(m_limitState1 == e_atUpperLimit)
  440.          {
  441.             v1X = b1.m_linearVelocity.x + -b1.m_angularVelocity * r1Y;
  442.             v1Y = b1.m_linearVelocity.y + b1.m_angularVelocity * r1X;
  443.             Cdot = -(m_u1.x * v1X + m_u1.y * v1Y);
  444.             force = -step.inv_dt * m_limitMass1 * Cdot;
  445.             oldForce = m_limitForce1;
  446.             m_limitForce1 = b2Math.b2Max(0,m_limitForce1 + force);
  447.             force = m_limitForce1 - oldForce;
  448.             P1X = -step.dt * force * m_u1.x;
  449.             P1Y = -step.dt * force * m_u1.y;
  450.             b1.m_linearVelocity.x += b1.m_invMass * P1X;
  451.             b1.m_linearVelocity.y += b1.m_invMass * P1Y;
  452.             b1.m_angularVelocity += b1.m_invI * (r1X * P1Y - r1Y * P1X);
  453.          }
  454.          if(m_limitState2 == e_atUpperLimit)
  455.          {
  456.             v2X = b2.m_linearVelocity.x + -b2.m_angularVelocity * r2Y;
  457.             v2Y = b2.m_linearVelocity.y + b2.m_angularVelocity * r2X;
  458.             Cdot = -(m_u2.x * v2X + m_u2.y * v2Y);
  459.             force = -step.inv_dt * m_limitMass2 * Cdot;
  460.             oldForce = m_limitForce2;
  461.             m_limitForce2 = b2Math.b2Max(0,m_limitForce2 + force);
  462.             force = m_limitForce2 - oldForce;
  463.             P2X = -step.dt * force * m_u2.x;
  464.             P2Y = -step.dt * force * m_u2.y;
  465.             b2.m_linearVelocity.x += b2.m_invMass * P2X;
  466.             b2.m_linearVelocity.y += b2.m_invMass * P2Y;
  467.             b2.m_angularVelocity += b2.m_invI * (r2X * P2Y - r2Y * P2X);
  468.          }
  469.       }
  470.       
  471.       public function GetLength1() : Number
  472.       {
  473.          var p:b2Vec2 = m_body1.GetWorldPoint(m_localAnchor1);
  474.          var sX:Number = m_ground.m_xf.position.x + m_groundAnchor1.x;
  475.          var sY:Number = m_ground.m_xf.position.y + m_groundAnchor1.y;
  476.          var dX:Number = p.x - sX;
  477.          var dY:Number = p.y - sY;
  478.          return Math.sqrt(dX * dX + dY * dY);
  479.       }
  480.       
  481.       public function GetLength2() : Number
  482.       {
  483.          var p:b2Vec2 = m_body2.GetWorldPoint(m_localAnchor2);
  484.          var sX:Number = m_ground.m_xf.position.x + m_groundAnchor2.x;
  485.          var sY:Number = m_ground.m_xf.position.y + m_groundAnchor2.y;
  486.          var dX:Number = p.x - sX;
  487.          var dY:Number = p.y - sY;
  488.          return Math.sqrt(dX * dX + dY * dY);
  489.       }
  490.       
  491.       public function GetGroundAnchor1() : b2Vec2
  492.       {
  493.          var a:b2Vec2 = m_ground.m_xf.position.Copy();
  494.          a.Add(m_groundAnchor1);
  495.          return a;
  496.       }
  497.    }
  498. }
  499.