开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > Delphi/CppBuilder > 查看源码
UElasticBody.pas
资源名称：box2DDelphiPackage.zip　[点击查看]
上传用户：zkjn0718
上传日期：2021-01-01
资源大小：776k
文件大小：22k
源码类别：

Delphi/CppBuilder

开发平台：

Delphi

UElasticBody.pas：源码内容
  1. unit UElasticBody;
  3. interface
  4. {$I ......SourcePhysics2D.inc}
  6. uses
  7.    UMain,
  8.    UPhysics2DTypes,
  9.    UPhysics2D,
  10.    SysUtils;
  12. type
  13.    TElasticBody = class(TTester)
  14.    private
  15.       procedure Process;
  16.       procedure AddSpringForce(bA: Tb2Body; const localA: TVector2;
  17.          bB: Tb2Body; const localB: TVector2; const k, friction, desiredDist: Float);
  18.    public
  19.       bodies: array[0..63] of Tb2Body;
  20.       m_ground: Tb2Body;
  21.       m_elev: Tb2Body;
  22.       m_joint_elev: Tb2PrismaticJoint;
  24.       constructor Create; override;
  25.       procedure Step(var settings: TSettings; timeStep: Float); override;
  26.    end;
  28. implementation
  30. { TElasticBody }
  32. constructor TElasticBody.Create;
  33. const
  34.    startpoint: TVector2 = (X: 30.0; Y: 20.0);
  35. var
  36.    i, j: Integer;
  37.    sd: Tb2PolygonDef;
  38.    cd: Tb2CircleDef;
  39.    bd: Tb2BodyDef;
  40.    g, body, rightmotor, hammerleft, hammerright, pusher: Tb2Body;
  41.    jr: Tb2RevoluteJointDef;
  42.    jd: Tb2DistanceJointDef;
  43.    jp: Tb2PrismaticJointDef;
  44. begin
  45.    inherited;
  46.   /// Bottom static body
  47.    begin
  48.       sd := Tb2PolygonDef.Create;
  49.       sd.SetAsBox(50.0, 2.0);
  50.       sd.friction := 0.1;
  51.       sd.restitution := 0.1;
  52.       bd := Tb2BodyDef.Create;
  53.       {$IFDEF OP_OVERLOAD}
  54.       bd.position.SetValue(-1.0, -7.5);
  55.       {$ELSE}
  56.       SetValue(bd.position, -1.0, -7.5);
  57.       {$ENDIF}
  58.       m_ground := m_world.CreateBody(bd);
  59.       m_ground.CreateShape(sd);
  60.    end;
  61.    /// Upper static body
  62.    begin
  63.       sd := Tb2PolygonDef.Create;
  64.       sd.SetAsBox(20.0, 0.50, MakeVector(0.0, 0.0), 0.047 * Pi);
  65.       sd.friction := 0.01;
  66.       sd.restitution := 0.001;
  67.       bd := Tb2BodyDef.Create;
  68.       {$IFDEF OP_OVERLOAD}
  69.       bd.position.SetValue(-20.0, 93.0);
  70.       {$ELSE}
  71.       SetValue(bd.position, -20.0, 93.0);
  72.       {$ENDIF}
  73.       g := m_world.CreateBody(bd);
  74.       g.CreateShape(sd, False);
  75.       sd.SetAsBox(15.0, 0.50, MakeVector(-15.0, 12.5), 0.0);
  76.       g.CreateShape(sd, False);
  77.       sd.SetAsBox(20.0, 0.5, MakeVector(0.0, -25.0), -0.5);
  78.       g.CreateShape(sd);
  79.    end;
  80.    /// Left channel left wall
  81.    begin
  82.       sd := Tb2PolygonDef.Create;
  83.       sd.SetAsBox(0.7, 55.0);
  84.       sd.friction := 0.1;
  85.       sd.restitution := 0.1;
  86.       bd := Tb2BodyDef.Create;
  87.       {$IFDEF OP_OVERLOAD}
  88.       bd.position.SetValue(-49.3, 50.0);
  89.       {$ELSE}
  90.       SetValue(bd.position, -49.3, 50.0);
  91.       {$ENDIF}
  92.       g := m_world.CreateBody(bd);
  93.       g.CreateShape(sd);
  94.    end;
  95.    /// Right wall
  96.    begin
  97.       sd := Tb2PolygonDef.Create;
  98.       sd.SetAsBox(0.7, 55.0);
  99.       sd.friction := 0.1;
  100.       sd.restitution := 0.1;
  101.       bd := Tb2BodyDef.Create;
  102.       {$IFDEF OP_OVERLOAD}
  103.       bd.position.SetValue(45.0, 50.0);
  104.       {$ELSE}
  105.       SetValue(bd.position, 45.0, 50.0);
  106.       {$ENDIF}
  107.       g := m_world.CreateBody(bd);
  108.       g.CreateShape(sd);
  109.    end;
  110.    /// Left channel right upper wall
  111.    begin
  112.       sd := Tb2PolygonDef.Create;
  113.       sd.SetAsBox(0.5, 20.0);
  114.       sd.friction := 0.05;
  115.       sd.restitution := 0.01;
  116.       bd := Tb2BodyDef.Create;
  117.       {$IFDEF OP_OVERLOAD}
  118.       bd.position.SetValue(-42.0, 70.0);
  119.       {$ELSE}
  120.       SetValue(bd.position, -42.0, 70.0);
  121.       {$ENDIF}
  122.       bd.angle := -0.03 * Pi;
  123.       g := m_world.CreateBody(bd);
  124.       g.CreateShape(sd);
  125.    end;
  126.    /// Left channel right lower wall
  127.    begin
  128.       sd := Tb2PolygonDef.Create;
  129.       sd.SetAsBox(0.50, 23.0);
  130.       sd.friction := 0.05;
  131.       sd.restitution := 0.01;
  132.       bd := Tb2BodyDef.Create;
  133.       {$IFDEF OP_OVERLOAD}
  134.       bd.position.SetValue(-44.0, 27.0);
  135.       {$ELSE}
  136.       SetValue(bd.position, -44.0, 27.0);
  137.       {$ENDIF}
  138.       g := m_world.CreateBody(bd, False);
  139.       g.CreateShape(sd, False);
  140.       /// Bottom motors
  141.       cd := Tb2CircleDef.Create;
  142.       cd.radius := 3.0;
  143.       cd.density := 15.0;
  144.       cd.friction := 1.0;
  145.       cd.restitution := 0.2;
  146.       /// 1.
  147.       {$IFDEF OP_OVERLOAD}
  148.       bd.position.SetValue(-40.0, 2.5);
  149.       {$ELSE}
  150.       SetValue(bd.position, -40.0, 2.5);
  151.       {$ENDIF}
  152.       body := m_world.CreateBody(bd, False);
  153.       body.CreateShape(cd, False);
  154.       body.SetMassFromShapes;
  156.       jr := Tb2RevoluteJointDef.Create;
  157.       {$IFDEF OP_OVERLOAD}
  158.       jr.Initialize(g, body, body.GetWorldCenter + MakeVector(0.0, 1.0));
  159.       {$ELSE}
  160.       jr.Initialize(g, body, Add(body.GetWorldCenter, MakeVector(0.0, 1.0)));
  161.       {$ENDIF}
  162.       jr.maxMotorTorque := 30000.0;
  163.       jr.enableMotor := True;
  164.       jr.motorSpeed := 20.0;
  165.       m_world.CreateJoint(jr, False);
  167.       /// 1. left down
  168.       {$IFDEF OP_OVERLOAD}
  169.       bd.position.SetValue(-46.0, -2.5);
  170.       {$ELSE}
  171.       SetValue(bd.position, -46.0, -2.5);
  172.       {$ENDIF}
  173.       cd.radius := 1.5;
  174.       jr.motorSpeed := -20.0;
  175.       body := m_world.CreateBody(bd, False);
  176.       body.CreateShape(cd, False);
  177.       sd.SetAsBox(2.0, 0.50);
  178.       body.CreateShape(sd, False);
  179.       body.SetMassFromShapes;
  180.       jr.Initialize(g, body, body.GetWorldCenter);
  181.       m_world.CreateJoint(jr, False);
  183.       /// 2.
  184.       cd.radius := 3.0;
  185.       jr.motorSpeed := 20.0;
  186.       {$IFDEF OP_OVERLOAD}
  187.       bd.position.SetValue(-32.0, 2.5);
  188.       {$ELSE}
  189.       SetValue(bd.position, -32.0, 2.5);
  190.       {$ENDIF}
  191.       body := m_world.CreateBody(bd, False);
  192.       body.CreateShape(cd, False);
  193.       body.SetMassFromShapes;
  194.       {$IFDEF OP_OVERLOAD}
  195.       jr.Initialize(g, body, body.GetWorldCenter + MakeVector(0.0, 1.0));
  196.       {$ELSE}
  197.       jr.Initialize(g, body, Add(body.GetWorldCenter, MakeVector(0.0, 1.0)));
  198.       {$ENDIF}
  199.       m_world.CreateJoint(jr, False);
  201.       /// 3.
  202.       jr.motorSpeed := 20.0;
  203.       {$IFDEF OP_OVERLOAD}
  204.       bd.position.SetValue(-24.0, 1.5);
  205.       {$ELSE}
  206.       SetValue(bd.position, -24.0, 1.5);
  207.       {$ENDIF}
  208.       body := m_world.CreateBody(bd, False);
  209.       body.CreateShape(cd, False);
  210.       body.SetMassFromShapes;
  211.       {$IFDEF OP_OVERLOAD}
  212.       jr.Initialize(g, body, body.GetWorldCenter + MakeVector(0.0, 1.0));
  213.       {$ELSE}
  214.       jr.Initialize(g, body, Add(body.GetWorldCenter, MakeVector(0.0, 1.0)));
  215.       {$ENDIF}
  216.       m_world.CreateJoint(jr, False);
  218.       /// 4.
  219.       {$IFDEF OP_OVERLOAD}
  220.       bd.position.SetValue(-16.0, 0.8);
  221.       {$ELSE}
  222.       SetValue(bd.position, -16.0, 0.8);
  223.       {$ENDIF}
  224.       body := m_world.CreateBody(bd, False);
  225.       body.CreateShape(cd, False);
  226.       body.SetMassFromShapes;
  227.       {$IFDEF OP_OVERLOAD}
  228.       jr.Initialize(g, body, body.GetWorldCenter + MakeVector(0.0, 1.0));
  229.       {$ELSE}
  230.       jr.Initialize(g, body, Add(body.GetWorldCenter, MakeVector(0.0, 1.0)));
  231.       {$ENDIF}
  232.       m_world.CreateJoint(jr, False);
  234.       /// 5.
  235.       {$IFDEF OP_OVERLOAD}
  236.       bd.position.SetValue(-8.0, 0.5);
  237.       {$ELSE}
  238.       SetValue(bd.position, -8.0, 0.5);
  239.       {$ENDIF}
  240.       body := m_world.CreateBody(bd, False);
  241.       body.CreateShape(cd, False);
  242.       body.SetMassFromShapes;
  243.       {$IFDEF OP_OVERLOAD}
  244.       jr.Initialize(g, body, body.GetWorldCenter + MakeVector(0.0, 1.0));
  245.       {$ELSE}
  246.       jr.Initialize(g, body, Add(body.GetWorldCenter, MakeVector(0.0, 1.0)));
  247.       {$ENDIF}
  248.       m_world.CreateJoint(jr, False);
  250.       /// 6.
  251.       {$IFDEF OP_OVERLOAD}
  252.       bd.position.SetValue(0.0, 0.1);
  253.       {$ELSE}
  254.       SetValue(bd.position, 0.0, 0.1);
  255.       {$ENDIF}
  256.       body := m_world.CreateBody(bd, False);
  257.       body.CreateShape(cd, False);
  258.       body.SetMassFromShapes;
  259.       {$IFDEF OP_OVERLOAD}
  260.       jr.Initialize(g, body, body.GetWorldCenter + MakeVector(0.0, 1.0));
  261.       {$ELSE}
  262.       jr.Initialize(g, body, Add(body.GetWorldCenter, MakeVector(0.0, 1.0)));
  263.       {$ENDIF}
  264.       m_world.CreateJoint(jr, False);
  266.       /// 7.
  267.       {$IFDEF OP_OVERLOAD}
  268.       bd.position.SetValue(8.0, -0.5);
  269.       {$ELSE}
  270.       SetValue(bd.position, 8.0, -0.5);
  271.       {$ENDIF}
  272.       body := m_world.CreateBody(bd, False);
  273.       body.CreateShape(cd, False);
  274.       sd.SetAsBox(3.7, 0.5);
  275.       body.CreateShape(sd, False);
  276.       body.SetMassFromShapes;
  277.       {$IFDEF OP_OVERLOAD}
  278.       jr.Initialize(g, body, body.GetWorldCenter + MakeVector(0.0, 1.0));
  279.       {$ELSE}
  280.       jr.Initialize(g, body, Add(body.GetWorldCenter, MakeVector(0.0, 1.0)));
  281.       {$ENDIF}
  282.       m_world.CreateJoint(jr, False);
  284.       /// 8. right rotator
  285.       sd.SetAsBox(5.0, 0.5);
  286.       sd.density := 2.0;
  287.       {$IFDEF OP_OVERLOAD}
  288.       bd.position.SetValue(18.0, 1.0);
  289.       {$ELSE}
  290.       SetValue(bd.position, 18.0, 1.0);
  291.       {$ENDIF}
  292.       rightmotor := m_world.CreateBody(bd, False);
  293.       rightmotor.CreateShape(sd, False);
  294.       sd.SetAsBox(4.5, 0.5, b2Vec2_Zero, Pi / 3.0);
  295.       rightmotor.CreateShape(sd, False);
  296.       sd.SetAsBox(4.5, 0.5, b2Vec2_Zero, Pi * 2.0 / 3.0);
  297.       rightmotor.CreateShape(sd, False);
  298.       cd.radius := 4.2;
  299.       rightmotor.CreateShape(cd, False);
  300.       rightmotor.SetMassFromShapes;
  301.       jr.Initialize(g, rightmotor, rightmotor.GetWorldCenter);
  302.       jr.maxMotorTorque := 70000.0;
  303.       jr.motorSpeed := -4.0;
  304.       m_world.CreateJoint(jr, False);
  306.       /// 9. left rotator
  307.       sd.SetAsBox(8.5, 0.5);
  308.       sd.density := 2.0;
  309.       {$IFDEF OP_OVERLOAD}
  310.       bd.position.SetValue(-34.0, 17.0);
  311.       {$ELSE}
  312.       SetValue(bd.position, -34.0, 17.0);
  313.       {$ENDIF}
  314.       body := m_world.CreateBody(bd, False);
  315.       body.CreateShape(sd, False);
  316.       sd.SetAsBox(8.5, 0.5, MakeVector(0.0, 0.0), Pi / 2);
  317.       body.CreateShape(sd, False);
  318.       cd.radius := 7.0;
  319.       cd.friction := 0.9;
  320.       body.CreateShape(cd);
  321.       body.SetMassFromShapes;
  322.       jr.Initialize(g, body, body.GetWorldCenter);
  323.       jr.maxMotorTorque := 100000.0;
  324.       jr.motorSpeed := -5.0;
  325.       m_world.CreateJoint(jr);
  327.       /// big compressor
  328.       sd.SetAsBox(3.0, 4.0);
  329.       sd.density := 10.0;
  330.       {$IFDEF OP_OVERLOAD}
  331.       bd.position.SetValue(-16.0, 17.0);
  332.       {$ELSE}
  333.       SetValue(bd.position, -16.0, 17.0);
  334.       {$ENDIF}
  335.       hammerleft := m_world.CreateBody(bd, False);
  336.       hammerleft.CreateShape(sd, False);
  337.       hammerleft.SetMassFromShapes;
  338.       jd := Tb2DistanceJointDef.Create;
  339.       {$IFDEF OP_OVERLOAD}
  340.       jd.Initialize(body, hammerleft, body.GetWorldCenter + MakeVector(0.0, 6.0), hammerleft.GetWorldCenter);
  341.       {$ELSE}
  342.       jd.Initialize(body, hammerleft, Add(body.GetWorldCenter, MakeVector(0.0, 6.0)), hammerleft.GetWorldCenter);
  343.       {$ENDIF}
  344.       m_world.CreateJoint(jd, False);
  346.       {$IFDEF OP_OVERLOAD}
  347.       bd.position.SetValue(4.0, 17.0);
  348.       {$ELSE}
  349.       SetValue(bd.position, 4.0, 17.0);
  350.       {$ENDIF}
  351.       hammerright := m_world.CreateBody(bd, False);
  352.       hammerright.CreateShape(sd, False);
  353.       hammerright.SetMassFromShapes;
  354.       {$IFDEF OP_OVERLOAD}
  355.       jd.Initialize(body, hammerright, body.GetWorldCenter - MakeVector(0.0, 6.0), hammerright.GetWorldCenter);
  356.       {$ELSE}
  357.       jd.Initialize(body, hammerright, Subtract(body.GetWorldCenter, MakeVector(0.0, 6.0)), hammerright.GetWorldCenter);
  358.       {$ENDIF}
  359.       m_world.CreateJoint(jd, False);
  361.       /// pusher
  362.       sd.SetAsBox(6.0, 0.75);
  363.       {$IFDEF OP_OVERLOAD}
  364.       bd.position.SetValue(-21.0, 9.0);
  365.       {$ELSE}
  366.       SetValue(bd.position, -21.0, 9.0);
  367.       {$ENDIF}
  368.       pusher := m_world.CreateBody(bd);
  369.       pusher.CreateShape(sd, False);
  370.       sd.SetAsBox(2.0, 1.5, MakeVector(-5.0, 0.0), 0.0);
  371.       pusher.SetMassFromShapes;
  372.       pusher.CreateShape(sd);
  373.       {$IFDEF OP_OVERLOAD}
  374.       jd.Initialize(rightmotor, pusher, rightmotor.GetWorldCenter + MakeVector(-8.0, 0.0),
  375.          pusher.GetWorldCenter + MakeVector(5.0, 0.0));
  376.       {$ELSE}
  377.       jd.Initialize(rightmotor, pusher, Add(rightmotor.GetWorldCenter, MakeVector(-8.0, 0.0)),
  378.          Add(pusher.GetWorldCenter, MakeVector(5.0, 0.0)));
  379.       {$ENDIF}
  380.       m_world.CreateJoint(jd);
  381.    end;
  383.    /// Static bodies above motors
  384.    begin
  385.       sd := Tb2PolygonDef.Create;
  386.       cd := Tb2CircleDef.Create;
  387.       sd.SetAsBox(9.0, 0.5);
  388.       sd.friction := 0.05;
  389.       sd.restitution := 0.01;
  390.       bd := Tb2BodyDef.Create;
  391.       {$IFDEF OP_OVERLOAD}
  392.       bd.position.SetValue(-15.5, 12.0);
  393.       {$ELSE}
  394.       SetValue(bd.position, -15.5, 12.0);
  395.       {$ENDIF}
  396.       bd.angle := 0.0;
  397.       g := m_world.CreateBody(bd);
  398.       g.CreateShape(sd, False);
  400.       sd.SetAsBox(8.0, 0.5, MakeVector(23.0, 0.0), 0.0);
  401.       g.CreateShape(sd, False);
  403.       /// compressor statics
  404.       sd.SetAsBox(7.0, 0.5, MakeVector(-2.0, 9.0), 0.0);
  405.       g.CreateShape(sd, False);
  406.       sd.SetAsBox(9.0, 0.5, MakeVector(22.0, 9.0), 0.0);
  407.       g.CreateShape(sd, False);
  409.       sd.SetAsBox(19.0, 0.5, MakeVector(-9.0, 15.0), -0.05);
  410.       g.CreateShape(sd, False);
  411.       sd.SetAsBox(4.7, 0.5, MakeVector(15.0, 11.5), -0.5);
  412.       g.CreateShape(sd, False);
  414.       /// below compressor
  415.       sd.SetAsBox(26.0, 0.3, MakeVector(17.0, -4.4), -0.02);
  416.       g.CreateShape(sd);
  417.       cd.radius := 1.0;
  418.       cd.friction := 1.0;
  419.       cd.localPosition := MakeVector(29.0, -6.0);
  420.       g.CreateShape(cd, False);
  421.       cd.radius := 0.7;
  422.       cd.localPosition := MakeVector(-2.0, -4.5);
  423.       g.CreateShape(cd);
  424.    end;
  426.    /// Elevator
  427.    begin
  428.       bd := Tb2BodyDef.Create;
  429.       cd := Tb2CircleDef.Create;
  430.       sd := Tb2PolygonDef.Create;
  432.       {$IFDEF OP_OVERLOAD}
  433.       bd.position.SetValue(40.0, 4.0);
  434.       {$ELSE}
  435.       SetValue(bd.position, 40.0, 4.0);
  436.       {$ENDIF}
  437.       m_elev := m_world.CreateBody(bd, False);
  439.       sd.SetAsBox(0.5, 2.5, MakeVector(3.0, -3.0), 0.0);
  440.       sd.density := 1.0;
  441.       sd.friction := 0.01;
  442.       m_elev.CreateShape(sd, False);
  443.       sd.SetAsBox(7.0, 0.5, MakeVector(-3.5, -5.5), 0.0);
  444.       m_elev.CreateShape(sd, False);
  445.       sd.SetAsBox(0.5, 2.5, MakeVector(-11.0, -3.5), 0.0);
  446.       m_elev.CreateShape(sd, False);
  447.       m_elev.SetMassFromShapes;
  449.       jp := Tb2PrismaticJointDef.Create;
  450.       jp.Initialize(m_ground, m_elev, bd.position, MakeVector(0.0, 1.0));
  451.       jp.lowerTranslation := 0.0;
  452.       jp.upperTranslation := 100.0;
  453.       jp.enableLimit := True;
  454.       jp.enableMotor := True;
  455.       jp.maxMotorForce := 10000.0;
  456.       jp.motorSpeed := 0.0;
  457.       m_joint_elev := Tb2PrismaticJoint(m_world.CreateJoint(jp));
  459.       /// Korb
  460.       sd.SetAsBox(2.3, 0.5, MakeVector(1.0, 0.0), 0.0);
  461.       sd.density := 0.5;
  462.       {$IFDEF OP_OVERLOAD}
  463.       bd.position.SetValue(29.0, 6.5);
  464.       {$ELSE}
  465.       SetValue(bd.position, 29.0, 6.5);
  466.       {$ENDIF}
  467.       body := m_world.CreateBody(bd, False);
  468.       body.CreateShape(sd, False);
  469.       sd.SetAsBox(2.5, 0.5, MakeVector(3.0, -2.0), Pi / 2.0);
  470.       body.CreateShape(sd, False);
  471.       sd.SetAsBox(4.6, 0.5, MakeVector(7.8, -4.0), 0.0);
  472.       body.CreateShape(sd, False);
  473.       sd.SetAsBox(0.5, 4.5, MakeVector(12.0, 0.0), 0.0);
  474.       body.CreateShape(sd, False);
  476.       sd.SetAsBox(0.5, 0.5, MakeVector(13.0, 4.0), 0.0);
  477.       body.CreateShape(sd, False);
  479.       cd.radius := 0.7;
  480.       cd.density := 1.0;
  481.       cd.friction := 0.01;
  482.       cd.localPosition := MakeVector(0.0, 0.0);
  483.       body.CreateShape(cd);
  484.       body.SetMassFromShapes;
  486.       jr := Tb2RevoluteJointDef.Create;
  487.       jr.Initialize(m_elev, body, bd.position);
  488.       jr.enableLimit := True;
  489.       jr.lowerAngle := -0.2;
  490.       jr.upperAngle := Pi * 1.1;
  491.       jr.collideConnected := True;
  492.       m_world.CreateJoint(jr);
  494.       /// upper body exit
  495.       sd.SetAsBox(14.0, 0.5, MakeVector(-3.5, -10.0), 0.0);
  496.       {$IFDEF OP_OVERLOAD}
  497.       bd.position.SetValue(17.5, 96.0);
  498.       {$ELSE}
  499.       SetValue(bd.position, 17.5, 96.0);
  500.       {$ENDIF}
  501.       body := m_world.CreateBody(bd);
  502.       body.CreateShape(sd);
  503.    end;
  505.    /// "Elastic body" 64 bodies - something like a lin. elastic compound
  506.    /// connected via dynamic forces (springs)
  507.    begin
  508.       sd := Tb2PolygonDef.Create;
  509.       bd := Tb2BodyDef.Create;
  510.       sd.SetAsBox(0.55, 0.55);
  511.       sd.density := 1.5;
  512.       sd.friction := 0.01;
  513.       sd.filter.groupIndex := -1;
  514.       bd.isBullet := False;
  515.       bd.allowSleep := false;
  516.       for i := 0 to 7 do
  517.          for j := 0 to 7 do
  518.          begin
  519.             {$IFDEF OP_OVERLOAD}
  520.             bd.position.SetValue(j * 1.02, 2.51 + 1.02 * i);
  521.             bd.position.AddBy(startpoint);
  522.             {$ELSE}
  523.             SetValue(bd.position, j * 1.02, 2.51 + 1.02 * i);
  524.             AddBy(bd.position, startpoint);
  525.             {$ENDIF}
  526.             body := m_world.CreateBody(bd, False);
  527.             bodies[8 * i + j] := body;
  528.             body.CreateShape(sd, False);
  529.             body.SetMassFromShapes;
  530.          end;
  531.       bd.Free;
  532.       sd.Free;
  533.    end;
  534. end;
  536. procedure TElasticBody.Step(var settings: TSettings; timeStep: Float);
  537. begin
  538.    settings.customedStep := True; // Use customed step method
  539.    m_pointCount := 0;
  540.    if not settings.realTime then
  541.       timeStep := DefaultStep;
  543.    if settings.pause then
  544.    begin
  545.       m_RemainTime := 0.0;
  546.       if settings.singleStep then
  547.       begin
  548.          settings.singleStep := False;
  549.          Inc(m_frameCount);
  550.       end
  551.       else
  552.          timeStep := 0.0;
  553.       DrawText('****PAUSED****');
  554.    end
  555.    else
  556.       Inc(m_frameCount);
  558.    if settings.realTime then // Make sure that every frame is processed using a time step pf 1/60s.
  559.    begin
  560.       timeStep := timeStep + m_RemainTime;
  561.       while timeStep > DefaultStep do
  562.       begin
  563.          Process;
  564.          timeStep := timeStep - DefaultStep;
  565.       end;
  566.       m_RemainTime := timeStep;
  567.    end
  568.    else
  569.       Process;
  570.    m_world.DrawDebugData;
  571.    m_world.Validate;
  573.    if Assigned(m_bomb) and m_bomb.IsFrozen then
  574.    begin
  575.       m_world.DestroyBody(m_bomb);
  576.       m_bomb := nil;
  577.    end;
  578.    inherited; // Draw other objects, but do not Step
  579. end;
  581. procedure TElasticBody.Process;
  582. const
  583.    spring = 500.0;
  584.    damp = 5.0;
  585.    down: TVector2 = (X: 0.0; Y: - 0.5);
  586.    up: TVector2 = (X: 0.0; Y: 0.5);
  587.    right: TVector2 = (X: 0.5; Y: 0.0);
  588.    left: TVector2 = (X: -0.5; Y: 0.0);
  589.    drdist = 1.4142135;
  590.    drdist2 = 2 * drdist;
  591. var
  592.    i, j: Integer;
  593.    ind, indr, indd, inddr, inddl: Int32;
  594.    p1, p2, e: TVector2;
  595. begin
  596.    m_world.Step(DefaultStep, 10, False);
  597.    for i := 0 to 7 do
  598.       for j := 0 to 7 do
  599.       begin
  600.          ind := i * 8 + j;
  601.          indr := ind + 1;
  602.          indd := ind + 8;
  604.          if j < 7 then
  605.          begin
  606.             AddSpringForce(bodies[ind], b2Vec2_Zero, bodies[indr], b2Vec2_Zero, spring, damp, 1.0);
  607.             AddSpringForce(bodies[ind], right, bodies[indr], left, 0.5 * spring, damp, 0.0);
  608.          end;
  609.          if i < 7 then
  610.          begin
  611.             AddSpringForce(bodies[ind], b2Vec2_Zero, bodies[indd], b2Vec2_Zero, spring, damp, 1.0);
  612.             AddSpringForce(bodies[ind], up, bodies[indd], down, 0.5 * spring, damp, 0.0);
  613.          end;
  614.          inddr := indd + 1;
  615.          inddl := indd - 1;
  616.          if (i < 7) and (j < 7) then
  617.             AddSpringForce(bodies[ind], b2Vec2_Zero, bodies[inddr], b2Vec2_Zero, spring, damp, drdist);
  618.          if (i < 7) and (j > 0) then
  619.             AddSpringForce(bodies[ind], b2Vec2_Zero, bodies[inddl], b2Vec2_Zero, spring, damp, drdist);
  621.          indr := ind + 2;
  622.          indd := ind + 8 * 2;
  623.          if j < 6 then
  624.             AddSpringForce(bodies[ind], b2Vec2_Zero, bodies[indr], b2Vec2_Zero, spring, damp, 2.0);
  625.          if i < 6 then
  626.             AddSpringForce(bodies[ind], b2Vec2_Zero, bodies[indd], b2Vec2_Zero, spring, damp, 2.0);
  628.          inddr := indd + 2;
  629.          inddl := indd - 2;
  630.          if (i < 6) and (j < 6) then
  631.             AddSpringForce(bodies[ind], b2Vec2_Zero, bodies[inddr], b2Vec2_Zero, spring, damp, drdist2);
  632.          if (i < 6) and (j > 1) then
  633.             AddSpringForce(bodies[ind], b2Vec2_Zero, bodies[inddl], b2Vec2_Zero, spring, damp, drdist2);
  634.       end;
  636.    /// Check if bodies are near elevator
  637.    /// Look if the body to lift is near the elevator
  638.    p1 := bodies[0].GetWorldCenter;
  639.    p2 := bodies[63].GetWorldCenter;
  640.    /// m_elev:   elevator prism. joint
  641.    {$IFDEF OP_OVERLOAD}
  642.    e := m_elev.GetWorldCenter + MakeVector(0.0, 7.0);
  643.    {$ELSE}
  644.    e := Add(m_elev.GetWorldCenter, MakeVector(0.0, 7.0));
  645.    {$ENDIF}
  646.    // maybe not the best way to do it...
  647.    // Bodies reached the elevator side
  648.    if (p1.x > e.x) or (p2.x > e.x) then // go up
  649.       if ((p1.y < e.y) or (p2.y < e.y)) and (m_joint_elev.GetJointTranslation <= m_joint_elev.GetLowerLimit + 1.0) then
  650.          m_joint_elev.m_motorSpeed := 20.0;
  652.    // go down
  653.    if (m_joint_elev.GetJointTranslation >= m_joint_elev.GetUpperLimit - 2.0) then
  654.       m_joint_elev.m_motorSpeed := -15.0;
  655. end;
  657. procedure TElasticBody.AddSpringForce(bA: Tb2Body; const localA: TVector2;
  658.    bB: Tb2Body; const localB: TVector2; const k, friction, desiredDist: Float);
  659. var
  660.    diff, vA, vB, vdiff: TVector2;
  661.    dx, vrel, forceMag: Float;
  662. begin
  663.    {$IFDEF OP_OVERLOAD}
  664.    diff := bB.GetWorldPoint(localB) - bA.GetWorldPoint(localA);
  665.    //Find velocities of attach points
  666.    vA := bA.GetLinearVelocity - b2Cross(bA.GetWorldVector(localA), bA.GetAngularVelocity);
  667.    vB := bB.GetLinearVelocity - b2Cross(bB.GetWorldVector(localB), bB.GetAngularVelocity);
  668.    vdiff := vB - vA;
  669.    dx := diff.Normalize; //normalizes diff and puts length into dx
  670.    {$ELSE}
  671.    diff := Subtract(bB.GetWorldPoint(localB), bA.GetWorldPoint(localA));
  672.    //Find velocities of attach points
  673.    vA := Subtract(bA.GetLinearVelocity, b2Cross(bA.GetWorldVector(localA), bA.GetAngularVelocity));
  674.    vB := Subtract(bB.GetLinearVelocity, b2Cross(bB.GetWorldVector(localB), bB.GetAngularVelocity));
  675.    vdiff := Subtract(vB, vA);
  676.    dx := Normalize(diff); //normalizes diff and puts length into dx
  677.    {$ENDIF}
  678.    vrel := vdiff.x * diff.x + vdiff.y * diff.y;
  679.    forceMag := -k * (dx - desiredDist) - friction * vrel;
  680.    {$IFDEF OP_OVERLOAD}
  681.    diff := diff * forceMag;
  682.    {$ELSE}
  683.    diff := Multiply(diff, forceMag);
  684.    {$ENDIF}
  685.    bB.ApplyForce(diff, bA.GetWorldPoint(localA));
  686.    {$IFDEF OP_OVERLOAD}
  687.    diff := -diff;
  688.    {$ELSE}
  689.    diff := Negative(diff);
  690.    {$ENDIF}
  691.    bA.ApplyForce(diff, bB.GetWorldPoint(localB));
  692. end;
  694. initialization
  695.    RegisterTestEntry('Elastic Body', TElasticBody);
  697. end.