自顶向下的汽车在JBox2D libGDX运动问题

Question

我正在尝试基于Emanuele Feronato's "Two ways to make Box2D cars"实现自上而下的汽车游戏的Java版本。我知道box2d的一些基础知识，并且在很大程度上我将代码转换为Java，几乎没有例外。

但是，当我运行程序时，我的车不会移动。

如果我把所有的轮子都变成一个动态的车身（左前方除外）开始向后和向前移动，使车辆前后甩动，但最后却没有任何地方。前两个关节是旋转关节，每个关节都有马达，而后背是棱柱形，所以如果我错了，请纠正我，但前两个应该是唯一“旋转”/移动的。我觉得我正在做一些可怕的错误，但到处都是我看起来总是在行动脚本中，所以我不是百分之百肯定是错的。

我已经检查过并且所有车轮都在正确的位置，并且关节也被放到了正确的车轮上。我检查了电机速度，它也在运行。 “ldirection”和“rdirection”的x分量始终为0，因此它会消除横向速度，而y始终是一个值。那真的应该向前推进吗？

当车身上下移动时，左前轮始终与车身保持相同的距离。所以左前线似乎正常运作。我检查了所有代码，以确保右前轮与左轮相同。

开车

当向前加速时，只有两个右轮和后左轮前后移动。

当我开始转动两个前轮后，两个轮子仍然与汽车保持一致但开始以略微倾斜的方式移动。最终当前轮转动90度时，它们开始几乎旋转关节的中心。

初​​始化

  this.world = new World(new Vector2(0, 0), false);
    this.box2Drender = new Box2DDebugRenderer();

    this.LeftPJointDef = new PrismaticJointDef();
    this.RightPJointDef = new PrismaticJointDef();
    this.RightJointDef = new RevoluteJointDef();
    this.LeftJointDef = new RevoluteJointDef();

    this.CarBody = new PolygonShape();
    this.RightRWheelShape = new PolygonShape();
    this.RightFWheelShape = new PolygonShape();
    this.LeftRWheelShape = new PolygonShape();
    this.LeftFWheelShape = new PolygonShape();

    this.LeftRWheelDef = new BodyDef();
    this.RightRWheelDef = new BodyDef();
    this.RightFWheelDef = new BodyDef();
    this.LeftFWheelDef = new BodyDef();

    this.bodyD = new BodyDef();
    this.CarFixDef = new FixtureDef();

    this.x = x;
    this.y = y;
    this.Cpos = new Vector2(x,y);

    this.RRW = new Vector2((this.x + (this.x * XPrc)), (this.y + (this.y * -YPrc)));
    this.RLW = new Vector2((this.x + (this.x * -XPrc)), (this.y + (this.y * -YPrc)));
    this.FRW = new Vector2((this.x + (this.x * XPrc)), (this.y + (this.y * YPrc)));
    this.FLW = new Vector2((this.x + (this.x * -XPrc)), (this.y + (this.y * YPrc)));

    this.WheelSizeX = this.width * 0.25f;
    this.WheelSizeY = this.length * 0.30f;
    //setting bodyDef damping
    bodyD.linearDamping = 0.5f;
    bodyD.angularDamping = 0.5f;

    //Adding bodyDef to the world and setting type as Dynamic
    body = world.createBody(bodyD);
    body.setType(BodyDef.BodyType.DynamicBody);

    //setting the body position in the world using the Vector given.
    body.setTransform(this.Cpos, (float) ((Math.PI) / 2));

    //Adding the calculated Position vecotrs of the wheel's to each wheel def.
    RightFWheelDef.position.add(FRW);
    LeftFWheelDef.position.add(FLW);
    RightRWheelDef.position.add(RRW);
    LeftRWheelDef.position.add(RLW);

    //Adding the wheels to the world using the Wheel Defs.
    RightFWheel = world.createBody(RightFWheelDef);
    LeftFWheel = world.createBody(LeftFWheelDef);
    RightRWheel = world.createBody(RightRWheelDef);
    LeftRWheel = world.createBody(LeftRWheelDef);

    RightFWheel.setType(BodyDef.BodyType.DynamicBody);
    RightRWheel.setType(BodyDef.BodyType.DynamicBody);
    LeftFWheel.setType(BodyDef.BodyType.DynamicBody);
    LeftRWheel.setType(BodyDef.BodyType.DynamicBody);

    //Setting the car(box) and wheel size
    CarBody.setAsBox(this.length, this.width);
    LeftFWheelShape.setAsBox(WheelSizeX, WheelSizeY);
    LeftRWheelShape.setAsBox(WheelSizeX, WheelSizeY);
    RightRWheelShape.setAsBox(WheelSizeX, WheelSizeY);
    RightFWheelShape.setAsBox(WheelSizeX, WheelSizeY);

    CarFixDef.shape = CarBody;

    RightFWheel.createFixture(RightFWheelShape, 1);
    RightRWheel.createFixture(RightRWheelShape, 1);
    LeftFWheel.createFixture(LeftFWheelShape, 1);
    LeftRWheel.createFixture(LeftRWheelShape, 1);

    body.createFixture(CarFixDef);

    LeftJointDef.enableMotor = true;
    RightJointDef.enableMotor = true;

    LeftJointDef.maxMotorTorque = 500;
    RightJointDef.maxMotorTorque = 500;

    //Setting Front Wheel joints in respects to the wheels and body
    LeftJointDef.initialize(body, LeftFWheel, LeftFWheel.getWorldCenter());
    RightJointDef.initialize(body, RightFWheel, RightFWheel.getWorldCenter());



    this.LeftJoint = (RevoluteJoint) world.createJoint(LeftJointDef);
    this.RightJoint = (RevoluteJoint) world.createJoint(RightJointDef);

    LeftPJointDef.enableLimit = true;
    RightPJointDef.enableLimit = true;
    //Translation Limit
    LeftPJointDef.lowerTranslation = 0;
    LeftPJointDef.upperTranslation = 0;
    RightPJointDef.lowerTranslation = 0;
    RightPJointDef.upperTranslation = 0;

    //Setting Rear wheel joints in respects to wheel and body
    LeftPJointDef.initialize(body, LeftRWheel, LeftRWheel.getWorldCenter(), new Vector2(1, 0));
    RightPJointDef.initialize(body, RightRWheel, RightRWheel.getWorldCenter(), new Vector2(1, 0));



    //adding the P Joints to the world.
    this.LeftPJoint = (PrismaticJoint) world.createJoint(LeftPJointDef);
    this.RightPJoint = (PrismaticJoint) world.createJoint(RightPJointDef);

这是我的更新方法。

    KillOrthoVelocity(LeftFWheel);
    KillOrthoVelocity(RightFWheel);
    KillOrthoVelocity(LeftRWheel);
    KillOrthoVelocity(RightRWheel);

    //Driving
    float r1 = LeftFWheel.getTransform().getRotation();
    Vector2 ldirection = new Vector2((float) -Math.sin(r1), (float) Math.cos(r1));
    ldirection.scl(enginespeed);
    float r2 = RightFWheel.getTransform().getRotation();
    Vector2 rdirection = new Vector2((float) -Math.sin(r2), (float) Math.cos(r2));
    rdirection.scl(enginespeed);

    LeftFWheel.applyForce(ldirection, LeftFWheel.getPosition(), true);
    RightFWheel.applyForce(rdirection, RightFWheel.getPosition(), true);


    //Steering
    float movespeed;

    movespeed = steerAng - LeftJoint.getJointAngle();
    LeftJoint.setMotorSpeed(movespeed * AngleSpeed);

    movespeed = steerAng - RightJoint.getJointAngle();
    RightJoint.setMotorSpeed(movespeed * AngleSpeed);

    world.step(dt, 6, 2);

KillOrthoVelocity类似于获取“ldirection”

    Vector2 localP = new Vector2(0, 0);
    Vector2 velocity = body.getLinearVelocityFromLocalPoint(localP);

    float r = body.getTransform().getRotation();
    Vector2 sideways = new Vector2((float) -Math.sin(r), (float) Math.cos(r));
    sideways.scl(velocity.dot(sideways));

    body.setLinearVelocity(sideways);

任何建议都将非常感谢！即使只是一个线索将是非常有帮助的！ 谢谢！

Answer 1

try this code 


RaceCar::RaceCar( b2World* world )  
{       
b2Vec2 race_car_pos( 13.0f,
        13.0f );

/ Create race car chassis 
{       
    // Physics Body Shape           
b2Vec2 verticies[8];            
verticies[0].Set(  1.5f, 0.0f  );   
        verticies[1].Set(  3.0f, 2.5f  );   
        verticies[2].Set(  2.8f, 5.5f  );   
        verticies[3].Set(  1.0f, 10.0f ); 
            verticies[4].Set( -1.0f,
        10.0f );        
    verticies[5].Set( -2.8f, 5.5f  );   
        verticies[6].Set( -3.0f, 2.5f  );   
        verticies[7].Set( -1.5f, 0.0f  );

b2PolygonShape body_shape;      
    body_shape.Set( verticies, 8 );

// Physics body definition  
        b2BodyDef body_def;     
        body_def.type
        = b2_dynamicBody; 
//          body_def.position =b2Vec2(3,3);     
        // Physics Body Fixture             
b2FixtureDef body_fixture;      
    body_fixture.shape = &body_shape;           
body_fixture.density = 0.1f;

m_chassisPhysicsBody = world->CreateBody( &body_def );  
        m_chassisPhysicsBody->CreateFixture( &body_fixture );           m_chassisPhysicsBody->SetUserData( this );

m_chassisPhysicsBody->SetTransform( race_car_pos, 0.0f ); 
        }

// Tires 
{           b2Vec2 pos = m_chassisPhysicsBody->GetPosition();

// Top left tire    
        {
                        RCTire* tire_top_left = new RCTire( world );
                        tire_top_left->setPosition( race_car_pos );
                        m_tires.push_back( tire_top_left );

                        b2RevoluteJointDef joint_def;
                        joint_def.enableLimit = true;
                        joint_def.lowerAngle = 0.0f;
                        joint_def.upperAngle = 0.0f;
                        joint_def.bodyA = m_chassisPhysicsBody;
                        joint_def.localAnchorB.SetZero();
                        joint_def.bodyB = tire_top_left->getPhysicsBody();
                        joint_def.localAnchorA.Set( -3.0f, 8.5f );
                        b2RevoluteJoint* joint = static_cast<b2RevoluteJoint*>( world->CreateJoint( &joint_def ) );
                        tire_top_left->setJointToChassis( joint );          }

// Top right tire   
{
                        RCTire* tire_top_right = new RCTire( world );
                        tire_top_right->setPosition( race_car_pos );
                        m_tires.push_back( tire_top_right );

                        b2RevoluteJointDef joint_def;
                        joint_def.enableLimit = true;
                        joint_def.lowerAngle = 0.0f;
                        joint_def.upperAngle = 0.0f;
                        joint_def.bodyA = m_chassisPhysicsBody;
                        joint_def.localAnchorB.SetZero();
                        joint_def.bodyB = tire_top_right->getPhysicsBody();
                        joint_def.localAnchorA.Set( 3.0f, 8.5f );
                        b2RevoluteJoint* joint = static_cast<b2RevoluteJoint*>( world->CreateJoint( &joint_def ) );
                        tire_top_right->setJointToChassis( joint );             }

// Bottom left tire 
{
                        RCTire* tire_bottom_left = new RCTire( world );
                        tire_bottom_left->setPosition( race_car_pos );
                        m_tires.push_back( tire_bottom_left );

                        b2RevoluteJointDef joint_def;
                        joint_def.enableLimit = true;
                        joint_def.lowerAngle = 0.0f;
                        joint_def.upperAngle = 0.0f;
                        joint_def.bodyA = m_chassisPhysicsBody;
                        joint_def.localAnchorB.SetZero();
                        joint_def.bodyB = tire_bottom_left->getPhysicsBody();
                        joint_def.localAnchorA.Set( -3.0f, 0.5f );

                        b2RevoluteJoint* joint = static_cast<b2RevoluteJoint*>( world->CreateJoint( &joint_def ) );
                        tire_bottom_left->setJointToChassis( joint );           }

                    // Bottom right tire            {
                        RCTire* tire_bottom_right = new RCTire( world );
                        tire_bottom_right->setPosition( race_car_pos );
                        m_tires.push_back( tire_bottom_right );

                        b2RevoluteJointDef joint_def;
                        joint_def.enableLimit = true;
                        joint_def.lowerAngle = 0.0f;
                        joint_def.upperAngle = 0.0f;
                        joint_def.bodyA = m_chassisPhysicsBody;
                        joint_def.localAnchorB.SetZero();
                        joint_def.bodyB = tire_bottom_right->getPhysicsBody();
                        joint_def.localAnchorA.Set( 3.0f, 0.5f );
                        world->CreateJoint( &joint_def );
                        b2RevoluteJoint* joint = static_cast<b2RevoluteJoint*>( world->CreateJoint( &joint_def ) );
                        tire_bottom_right->setJointToChassis( joint );          }       }   }