Prevent Ammo.js Raycast Vehicle From Flipping

This article explains the standard, most effective methods for stabilizing an ammo.js raycast vehicle to prevent it from flipping over during high-speed turns. You will learn how to manipulate the wheel roll influence, adjust the center of mass using compound shapes, and apply artificial downforce to keep your vehicle grounded.

1. Reduce the Wheel Roll Influence

The fastest and most common way to prevent flipping in ammo.js (and the underlying Bullet Physics engine) is to reduce the roll influence on each wheel.

When a vehicle turns, lateral forces are applied to the wheels, which transfers torque to the chassis and causes it to roll. By default, this value is set to 1.0, which often results in realistic but highly unstable physics for arcade-style driving.

You can reduce this by modifying the rollInfluence property of each wheel’s btWheelInfo structure:

// Loop through all wheels and reduce roll influence
for (let i = 0; i < vehicle.getNumWheels(); i++) {
    let wheel = vehicle.getWheelInfo(i);
    wheel.set_m_rollInfluence(0.1); // Default is 1.0; lower values reduce body roll
}

Setting the roll influence to a value between 0.0 and 0.2 drastically reduces the tipping force exerted on the chassis during sharp turns, keeping the vehicle flat.

2. Lower the Center of Mass (CoM)

By default, the center of mass of an ammo.js rigid body is located at its local origin (0, 0, 0). If your chassis collision shape is centered at this origin, the center of mass may sit too high, causing a high tipping moment.

To lower the center of mass, you must use a btCompoundShape. Instead of adding your collision shape directly to the rigid body, you add it as a child of a compound shape and offset it upward. This shifts the physical center of mass downward relative to the visual chassis.

// Create a compound shape
let compoundShape = new Ammo.btCompoundShape();

// Create your actual chassis shape (e.g., a box)
let chassisShape = new Ammo.btBoxShape(new Ammo.btVector3(halfWidth, halfHeight, halfLength));

// Offset the chassis shape UPWARD relative to the compound origin
let localTransform = new Ammo.btTransform();
localTransform.setIdentity();
localTransform.setOrigin(new Ammo.btVector3(0, 1.0, 0)); // Shift up by 1 unit

// Add the shape to the compound
compoundShape.addChildShape(localTransform, chassisShape);

// Use 'compoundShape' to create your vehicle's rigid body

Because the collision geometry is shifted upward, the physical center of mass (the origin of the compound shape) sits much closer to the ground, significantly increasing lateral stability.

3. Apply Artificial Downforce

In real-world racing, cars use aerodynamic downforce to push the vehicle into the ground at high speeds. You can simulate this in your physics loop by applying a constant downward force to the chassis rigid body.

In your physics update/render loop, apply a force pointing straight down relative to the vehicle’s current orientation:

let chassisBody = vehicle.getRigidBody();
let downforce = 1000; // Adjust based on vehicle mass and desired grip

let transform = chassisBody.getWorldTransform();
let upVector = new Ammo.btVector3(0, -1, 0); // Local down vector

// Convert local down vector to world space
let worldDown = transform.getBasis().op_mul(upVector);
worldDown.op_mul(downforce);

// Apply central force
chassisBody.applyCentralForce(worldDown);

Applying downforce keeps the tires firmly pressed against the ground during acceleration and high-speed cornering, mitigating the tendency of the inner wheels to lift.