Advanced Rig Examples: Dirt Bikes, Jeeps, Tanks, Helicopters, and Input-Driven Parts

This page turns the current Vehicle MC reference rigs into plain-English design patterns.

Important public note:

• these examples come from the current source and test YAML
• they show what the wider Vehicle MC stack can do
• they are not all part of the planned free starter pack

That distinction matters. The free starting path is the dirt bike. The rest of this page is the advanced reference lane for larger or premium vehicle work.

Which example teaches what

• dirtbike_steering_parts_v2: motorcycle-style steering chain, lean, jumps, and front-wheel orbit steering
• jeep_me_imc_native_test: four-wheel native rig with independent front steering, suspension, and rear axle roll
• jeep_me_imc_hybrid_test: ModelEngine body plus Vehicle MC native wheels
• dirtbike_me_tank7_test_v2: ModelEngine-heavy body test for larger armored or specialized bodies
• helicopter: rotor spin, air-controller tuning, tilt response, and anchor-driven FX points

Dirt bike: front assembly that moves as one unit

The dirt bike is the first example because it teaches the difference between a normal animated part and a wheel with its own behavior.

parts:
  - id: handlebars
    steeringYaw:
      enabled: true
      maxDeg: 19.0
      smoothing: 0.35
      invert: true
      pivot: SELF
 
wheels:
  - partId: front_wheel
    pivotOffset: [0.048125, -2.1140625, 2.329196]
    spinEnabled: true
    spinAxis: X
    steer:
      enabled: true
      invert: true
      maxDeg: 19.0
      smoothing: 0.35
      pivot: ROOT
      pivotOffset: [0.0, 0.2, 2.41]

Why this matters:

• the handlebars are one visual steering cue
• the wheel needs to move with that steering column
• pivot: ROOT lets the front wheel orbit around a steering-column point instead of only turning around itself

Use this pattern for:

• dirt bikes
• motorcycles
• scooters
• any vehicle where the front assembly visibly swings as one steering unit

Native jeep: four-wheel vehicle with real front steering and rear axle behavior

The clearest four-wheel reference is jeep_me_imc_native_test.

Front-left wheel:

- partId: front_left_wheel
  pivotOffset: [-2.281214, -1.896391, 3.022524]
  radius: 0.418
  spinEnabled: true
  spinAxis: X
  suspension:
    enabled: true
    travelUp: 0.40
    travelDown: 0.45
    probeDepth: 1.20
    everyTicks: 1
    smoothing: 0.35
  steer:
    enabled: true
    invert: true
    maxDeg: 25.0
    smoothing: 0.30
    pivot: SELF
    pivotOffset: [1.8, -1.896391, 3.022524]

Rear axle:

- partId: rear_axle
  pivotOffset: [0.076804, -1.900774, -2.349829]
  radius: 0.418
  spinEnabled: true
  spinAxis: X
  suspension:
    enabled: true
    travelUp: 0.40
    travelDown: 0.45
    probeDepth: 1.20
    everyTicks: 1
    smoothing: 0.35
  axle:
    enabled: true
    leftProbeOffset: [-2.353665, -1.900774, -2.349829]
    rightProbeOffset: [2.507272, -1.900774, -2.349829]
    maxRollDeg: 10.0
    smoothing: 0.35
    invertRoll: false

What this teaches:

• pivotOffset fixes orbiting when a wheel mesh is exported off-center
• front wheels usually want pivot: SELF, because a car wheel mostly turns in place instead of swinging like a bike fork
• steer.pivotOffset gives you a kingpin-style steering axis
• rear axle roll is for a linked assembly, not for every wheel on every vehicle

Use this pattern for:

• jeeps
• cars
• trucks
• utility vehicles
• anything that needs believable steering plus terrain response

Hybrid jeep: ModelEngine body, native wheels

jeep_me_imc_hybrid_test shows the best middle ground when you want a polished custom body without giving up wheel logic.

rig:
  backend: MODELENGINE
  modelEngine:
    modelId: "jeep_imc"
    applyPitchToRoot: true
    hideBaseEntity: true
    states:
      idle:
        animation: "idle"
      drive:
        animation: "drive"
      reverse:
        animation: "reverse"
      turn_left:
        animation: "turn_left"
        overlay: true
      turn_right:
        animation: "turn_right"
        overlay: true
 
  wheels:
    - partId: front_left_wheel
      radius: 0.38
      spinEnabled: true
      spinAxis: X
      steer:
        enabled: true
        maxDeg: 25.0
        smoothing: 0.30
        pivot: SELF

Interpretation:

• ModelEngine owns the chassis art and animation states
• Vehicle MC still owns movement, terrain response, and wheel behavior
• this is the right pattern when the body is too complex for a simple native part stack but the wheel layer still needs to feel physically honest

Use this pattern for:

• premium jeeps and armored cars
• vehicles with more elaborate body animation states
• rigs that need custom body animation but not a fake wheel system

Tank-style ModelEngine body test

dirtbike_me_tank7_test_v2 is a body-backend test more than a public finished vehicle family.

model:
  rootItem: minecraft:diamond_hoe{Damage:10}
  rigType: MODELENGINE
 
rig:
  backend: MODELENGINE
  modelEngine:
    modelId: "tank7"
    baseEntity: ARMOR_STAND
    applyPitchToRoot: true
    hideBaseEntity: true

This teaches a different lesson than the dirt bike or jeep:

• the important question is not only wheel spin
• the important question is how a large external model follows Vehicle MC's authoritative pose
• it is the right place to test body animation states, cannon-ready layouts, or custom animation playback without rewriting the core physics

Use this pattern for:

• tanks
• heavy tracked bodies
• premium special vehicles
• cinematic or faction-specific bodies

Helicopter: rotor parts, tilt, and air controller behavior

The helicopter example proves that Vehicle MC rigs are not limited to ground-wheel logic.

physics:
  heli:
    yawRateDegPerTick: 10
    ascendSpeed: 0.22
    descendSpeed: 0.32
    idleSink: 0.14
    maxFlyingHeight: 230.0
 
rig:
  parts:
    - id: rotor_center
      scale: 2.5
      offset: [0.0, 0.75, -1.0]
      tiltPosFactor: 0.9
      animation:
        type: ROTATE_Y
        when: DRIVER
        idleDegPerTick: 8.0
        activeDegPerTick: 20.0
        activeSpeedThreshold: 0.05
 
visuals:
  tilt:
    enabled: true
    maxPitchDeg: 12.0
    maxRollDeg: 10.0
    response: 0.22
    returnRate: 0.18
    applyTo: ROOT_HEAD_POSE

What this teaches:

• a rig part can be a rotor, not only a wheel
• tiltPosFactor helps a large part stay visually believable when the vehicle pitches and rolls
• helicopter feel is split between the controller physics and the visual tilt layer
• anchors like rotor_center and exhaust_left give you stable points for FX and weapons later

Use this pattern for:

• helicopters
• drones
• hovering craft with spinning top assemblies
• any vehicle where air tilt must read clearly to the player

Choosing the right pattern

Use the simplest pattern that gives the correct feel:

• use the dirt bike pattern when the steering assembly must visibly swing
• use the native jeep pattern when each wheel needs believable physical behavior
• use the hybrid pattern when the body is premium but the wheels still need real ground logic
• use the ModelEngine-heavy pattern when the body and animation complexity matter more than the starter-pack simplicity
• use the helicopter pattern when the vehicle's identity depends on rotor motion and air tilt

Related pages

• free Starter Dirt Bike Quick Start and Upgrade Path
• rig Backends, Display Parts, Wheels, and ModelEngine
• native Wheels, Suspension, Axles, and Hybrid ModelEngine Rigs
• rig Debug Commands, Pivot Tools, and Live Diagnostics