---
name: "Arma 3: CfgVehicles Plane class config reference"
type: topic
aliases: ["A3 CfgVehicles Plane class config reference", "Arma 3 CfgVehicles Plane class config reference"]
source: https://community.bistudio.com/wiki/Arma_3:_CfgVehicles_Plane_class_config_reference
revid: 378498
updated: 2026-04-28T09:09:07Z
---

# Arma 3: CfgVehicles Plane class config reference

All config values related to Plane class configuration can be found here.

### [CfgVehicles](../topics/CfgVehicles_Config_Reference.md)

#### A

##### aileronCoef

Graph array, defines the influence of the ailerons control surface depending on the current speed. Each position in the array is a percentage of maxSpeed. First value is 0% of maxSpeed, last value is 150% of maxSpeed.

Array - Graph array of float values, related to maxSpeed

```cpp
aileronCoef[] = { 0, 0.5, 1, 1.2, 1.4, 1.5, 1.6 };        // V-44 Blackfish
aileronCoef[] = { 0.6, 1, 0.95, 0.9, 0.85, 0.8, 0.75 };    // A-164 Wipeout
aileronCoef[] = {
    0,        // At 0 % of maxSpeed, this is the influence of the aileron
    0.4,    // 12.5 %
    0.8,    // 25 %
    0.8,    // 37.5 %
    0.9,    // 50 %
    1.0,    // 62.5 %
    1.0,    // 75 %
    1.1,    // 87.5 %
    1.1,    // 100 %
    1.2,    // 112.5 %
    1.2,    // 125 %
    1.2,    // 137.5 %
    1.3        // 150 %
};
```

##### aileronControlsSensitivityCoef

Sensitivity of the player roll (aileron) input - how fast the control surface reaches it is max. extent. (does not affect AI).

Float

```cpp
aileronControlsSensitivityCoef = 1;        // V-44 Blackfish
aileronControlsSensitivityCoef = 3.6;    // Caesar BTT
aileronControlsSensitivityCoef = 3;        // A-164 Wipeout
```

##### aileronSensitivity

Aileron authority. Lower values make the airplane bank slower, allowing to simulate heavier aircraft.

Float

```cpp
aileronSensitivity = 0;            // No bank
aileronSensitivity = 0.5;        // V-44 Blackfish
aileronSensitivity = 0.75;        // A-164 Wipeout
aileronSensitivity = 0.85;        // Caesar BTT
aileronSensitivity = 1;            // Fast bank
```

##### airBrake

Defines if the aircraft has airbrakes. Also linked to "SpeedBrake" animation source.

Boolean

```cpp
airBrake = 0;    // No airbrakes
airBrake = 1;    // Most aircrafts
```

##### airBrakeFrictionCoef

Defines the "braking power" / friction of airbrakes.

Boolean

```cpp
airBrakeFrictionCoef = 2.4;
```

##### airFrictionCoefs

Air friction depending on velocity 2, 1 and 0 powers in {X, Y, Z} axes in the model space.
Boolean

```cpp
airFrictionCoefs2[] = { 0.00100, 0.00050, 0.00006 };
airFrictionCoefs1[] = { 0.100, 0.050, 0.006 };
airFrictionCoefs0[] = { 0.0, 0.0, 0.0 };
```

##### altFullForce

Altitude value in meters at which the aircraft starts to progressively lose thrust influence until altNoForce is reached. Below this altitude, thrust influence is always at its maximum.
Simulates effect of thinning air on engine performace.

Integrer

```cpp
altFullForce = 6000;    // Caesar BTT
altFullForce = 2000;    // V-44 Blackfish
```

##### altNoForce

Altitude value in meters at which the aircraft loses its thrust influence completely. Below this altitude, thrust influence is progressively lost as soon as altFullForce is reached.
Simulates effect of thinning air on engine performace.

Integrer

```cpp
altNoForce = 7500;    // Caesar BTT
altNoForce = 7000;    // V-44 Blackfish
```

##### angleOfIndicence

angleOfIndicence [sic]

[of incidence (aerodynamics) Angle of incidence (aerodynamics)](https://en.wikipedia.org/wiki/Angle)

Relates to envelope, affects lift properties and ev. view from the cabin.

Float

```cpp
angleOfIndicence = -2 * 3.1415 / 180; // Buzzard
```

#### C

##### cabinOpening

Once the engine shut down, opens the cabin using "cabin" animation source.

Boolean

```cpp
cabinOpening = 1;    // Caesar BTT or A-164 Wipeout
cabinOpening = 0;    // V-44 Blackfish
```

##### cargoCanEject

Allows the cargo passengers to jump out even if the aircraft is moving.
Not a plane-specific value, but it is important to allow parachute jumps.

Boolean

```cpp
cargoCanEject = 1;    // Cargo can eject
cargoCanEject = 0;    // Cargo cannot eject
```

#### D

##### draconicForceXCoef

Force that affects the horizontal (X in model space) component of its velocity vector. Low values together with strong rudder authority will lead to skidding.

Float

```cpp
draconicForceXCoef = 7.4;    // A-164 Wipeout
draconicForceXCoef = 7.5;    // Caesar BTT
draconicForceXCoef = 15;    // V-44 Blackfish
```

##### draconicForceYCoef

Force that affects the vertical (Y in model space) component of its velocity vector. Bigger values allow for faster and sharper elevator turns.

Float

```cpp
draconicForceYCoef = 3;        // A-164 Wipeout
draconicForceYCoef = 1;        // Caesar BTT
draconicForceYCoef = 0.5;    // V-44 Blackfish
```

##### draconicForceZCoef

Force that affects the forward (Z in model space) component of its velocity vector.
Float

```cpp
draconicForceZCoef = 0.1;    // A-164 Wipeout
draconicForceZCoef = 2.5;    // Caesar BTT
draconicForceZCoef = 0.2;    // V-44 Blackfish
```

##### draconicTorqueXCoef

Force that keeps the airplane aligned according to a horizontal (X in model space) component of its velocity vector (model space). Makes the airplane turn in banked flight, affects how fast lower wing in a knife flight drops.
Bigger values also need to be balanced by a stronger rudder authority and draconicForceXCoef, otherwise the player won't be able to control the airplane in yaw. Good balancing with rudderCoef and draconicForceXCoef will allow good yaw authority in leveled flight, but disallow a sustained knife flight or too good turning just by using the rudder.

Can be also defined as an array.

Float

```cpp
draconicTorqueXCoef = 1.2;    // A-164 Wipeout
draconicTorqueXCoef[] =        // Caesar BTT
{
    14.0,    // 0 %
    12.0,    // 15 %
    11.2,    // 30 %
    10.6,    // 45 %
    9.9,    // 60 %
    9.6,    // 75 %
    9.7,    // 90 %
    10.5,    // 105 %
    11.0,    // 120 %
    11.5,    // 135 %
    12.0    // 150 %
};
```

##### draconicTorqueYCoef

Force that keeps the airplane aligned according to a vertical (Y in model space) component of its velocity vector. Makes the airplane go nose up when climbing and nose down when there's not enough lift.
Should be strong enough to make the aircraft go nose down in stall conditions as Arma does not simulate stalling of wings individually.
Bigger values also need to be balanced by a stronger elevator authority and draconicForceYCoef, otherwise the player won't be able to control the airplane in pitch.

Can be also defined as an array.

Float

```cpp
draconicTorqueYCoef = 3;    // A-164 Wipeout
draconicTorqueYCoef[] =        // Caesar BTT
{
    7.0,    // 0 %
    6.3,    // 15 %
    4.0,    // 30 %
    3.3,    // 45 %
    3.0,    // 60 %
    2.7,    // 75 %
    2.5,    // 90 %
    2.3,    // 105 %
    2.1,    // 120 %
    1.9,    // 135 %
    1.8        // 150 %
};
```

##### driveOnComponent

Defines the geometry LOD shapes on which the vehicle can roll without damage. (obsolete, from 1.68 use PhysX wheels and suspension)

Array - Strings linked to the geometry LOD shapes

```cpp
driveOnComponent[] = { "Gear_1_damper", "Gear_2_damper", "Gear_3_damper" };            // A-164 Wipeout
driveOnComponent[] = { "wheel_f", "wheel_r", "wheel_l" };                            // Caesar BTT
driveOnComponent[] = {                                                                // V-44 Blackfish
    "Wheel_1_1", "Wheel_1_2",
    "Wheel_2_1", "Wheel_2_2", "Wheel_2_3",
    "Wheel_3_1", "Wheel_3_2", "Wheel_3_3"
};
```

#### E

##### ejectSpeed

Defines the ejection speed and vector for all seats (driver, gunners and cargo).

Array - Values of velocity in m/s, [x, y, z]

```cpp
ejectSpeed[] = { 0, 60, 0 };    // A-164 Wipeout, pilot is ejected upwards
ejectSpeed[] = { 0, 0, 3 };        // Caesar BTT, passengers are ejected frontwards (needs confirmation)
ejectSpeed[] = { 0, -2, 0 };    // V-44 Blackfish, passengers are ejected downwards
```

##### elevatorCoef

Coefficient of the elevator authority according to a given speed.

Array - Graph array of values, see aileronCoef

```cpp
elevatorCoef[] = { 0.6, 0.9, 0.5, 0.4, 0.35, 0.3, 0.3 };    // A-164 Wipeout
elevatorCoef[] = { 0, 1, 1.2, 1.4, 1.5, 1.6, 1.6 };            // V-44 Blackfish
```

##### elevatorControlsSensitivityCoef

Sensitivity of the player pitch (elevator) input - how fast the control surface reaches it is max. extent. (does not affect AI).

Float

```cpp
elevatorControlsSensitivityCoef = 4;    // A-164 Wipeout
elevatorControlsSensitivityCoef = 2;    // Caesar BTT
elevatorControlsSensitivityCoef = 3;    // V-44 Blackfish
```

##### elevatorSensitivity

Elevator authority. Lower values make the airplane pitch slower.

Float

```cpp
elevatorSensitivity = 1.9;    // A-164 Wipeout
elevatorSensitivity = 0.3;    // Caesar BTT
elevatorSensitivity = 0.5;    // V-44 Blackfish
```

##### envelope

The lift properties (G) of the wing dependent of the actual speed of the aircraft. Each of the positions in the array corresponds to a relative
speed expressed as a proportion of the 125% of maxSpeed of the vehicle.
Relates directly to angleOfIndicence and airplane's mass and can be used to simulate various wing sizes and camber.

Array - Graph array of values, see aileronCoef

```cpp
envelope[] = { 0.1, 0.1, 0.9, 2.8, 3.5, 3.7, 3.8, 3.8, 3.6, 3.3, 2.7 };                // A-164 Wipeout
envelope[] = { 0, 0.15, 1.05, 1.8, 2.8, 3.3, 3.5, 3.2, 2.6, 2, 1.5, 1, 0.5, 0 };    // Caesar BTT
envelope[] = { 0, 0.01, 0.5, 1.5, 3.5, 4.4, 4.6, 4.8, 5, 5.1, 5.2, 5.3, 5.3, 1 };    // V-44 Blackfish
```

#### F

##### flaps

Defines if the aircraft has flaps. Uses "flap" animation source.

Boolean

```cpp
flaps = 1;    // Flaps
flaps = 0;    // No flaps
```

##### flapsFrictionCoef

Friction coefficient of flaps. Increases drag and lift. Relates to envelope.

Float

```cpp
flapsFrictionCoef = 0.5;    // A-164 Wipeout
flapsFrictionCoef = 0.4;    // Caesar BTT
flapsFrictionCoef = 0.2;    // V-44 Blackfish
```

##### gearDownTime

Only if gearRetracting = 1;, defines the time in seconds it takes to extract the gear.

Float

```cpp
gearDownTime = 2;    // Most aircrafts
```

##### gearRetracting

Defines if the aircraft has retracting landing gear. Uses "gear" animation source.

Boolean

```cpp
gearRetracting = 1;    // A-164 Wipeout, retractable landing gear
gearRetracting = 0;    // Caesar BTT, fixed landing gear
```

##### gearUpTime

Only if gearRetracting = 1;, defines the time in seconds it takes to retract the gear.
Float

```cpp
gearUpTime = 3.33;    // Most aircrafts
```

##### gearsUpFrictionCoef

Defines the additional friction when the landing gear is open.
Float

```cpp
gearsUpFrictionCoef = 0.5;
```

#### L

##### landingAoa

Advised landing angle of attack for AI and autopilot. (Make sure to check functionality in game. The angles of glideslopes of airports and airstrips in Arma vary from 3-5°, finding a good AoA is often a compromise.)

Float

```cpp
landingAoa = 0.174533;            // A-164 Wipeout
landingAoa = "rad 3";            // Caesar BTT
landingAoa = "1*3.1415/180";    // V-44 Blackfish
```

##### landingSpeed

Advised landing speed for AI and autopilot.

Float

```cpp
landingSpeed = 195;    // A-164 Wipeout
landingSpeed = 110;    // Caesar BTT
landingSpeed = 230;    // V-44 Blackfish
```

##### lightOnGear

Defines if the lights are on the landing gear, thus only shining when the gear is down.

Boolean

```cpp
lightOnGear = 1;    // A-164 Wipeout
lightOnGear = 0;    // Caesar BTT
```

##### maxSpeed

Maximum speed. Doesn't limit the speed the aircraft is able to reach. Value is used mainly for the AI and thrust, envelope and control surfaces coefficients.

Float

```cpp
maxSpeed = 706;    // A-164 Wipeout
maxSpeed = 435;    // Caesar BTT
maxSpeed = 550;    // V-44 Blackfish
```

#### R

##### rudderCoef

Defines the authority of the rudder in a given speed.

Array - Graph array of floats, see aileronsCoef

```cpp
rudderCoef[] = { 0.6, 1, 1, 0.9, 0.8, 0.7, 0.6 };                                // A-164 Wipeout
rudderCoef[] = { 0, 0.4, 1, 1.4, 1.8, 2, 2.2, 2.3, 2.4, 2.5, 2.5, 2.5, 2.6 };    // V-44 Blackfish
```

##### rudderControlsSensitivityCoef

Sensitivity of the player yaw (rudder) input - how fast the control surface reaches it is max. extent. (does not affect AI).

Float

```cpp
rudderControlsSensitivityCoef = 4;        // A-164 Wipeout
rudderControlsSensitivityCoef = 2;        // Caesar BTT
rudderControlsSensitivityCoef = 1.5;    // V-44 Blackfish
```

##### rudderInfluence

Cos of the angle in which rudder can turn the aircraft. Lower values mean less yaw extent and authority. Relates to rudderCoef, draconicTorqueXCoef and draconicForceXCoef.

Float

```cpp
rudderInfluence = 0.01;        // A-164 Wipeout
rudderInfluence = 0.3;        // Caesar BTT
rudderInfluence = 0.9396;    // V-44 Blackfish
```

#### S

##### simulation

String - Must be "airplaneX" for a plane

```cpp
simulation = "airplanex";
```

##### stallSpeed

Advised stall speed. Used for AI, [stallWarningTreshold](../topics/CfgVehicles_Plane_class_config_reference.md#stallwarningtreshold) in instruments and animation sources.

> [!NOTE]
> This param is not read by the engine, instead stallSpeed is calculated based on maxSpeed. To force the uses of static config value, use 'stallSpeedForced' (below)

Float

```cpp
stallSpeed = 180;    // V-44 Blackfish
```

##### stallSpeedForced (Arma 3 v2.22)

Advised stall speed. Used for AI, [stallWarningTreshold](../topics/CfgVehicles_Plane_class_config_reference.md#stallwarningtreshold) in instruments and animation sources.

Float

```cpp
stallSpeedForced = 33;    // V-44 Blackfish
```

##### stallWarningTreshold

stallWarningTreshold [sic]

Threshold of the stall warning - relates to display sources (i.e. airspeed indicated in red color).

Float

```cpp
stallWarningTreshold = 0.2;    // A-164 Wipeout
stallWarningTreshold = 0.2;    // Caesar BTT
stallWarningTreshold = 0.5;    // V-44 Blackfish
```

#### T

##### thrustCoef

Used to define available thrust vs. airspeed.

Array - Graph array of floats, see aileronsCoef

```cpp
thrustCoef[] = { 0.9, 0.8, 0.9, 1.3, 1.2, 1.2, 1.1, 1, 0.9, 0.2, 0.1, 0, 0 };                    // A-164 Wipeout
thrustCoef[] = { 1.3, 1.1, 1.2, 1.3, 1.5, 1.7, 1.6, 0.6, 0.46, 0.33, 0.2, 0.066, 0, 0, 0, 0 };    // Caesar BTT
thrustCoef[] = { 1.1, 1.1, 1, 1, 0.9, 0.8, 0.7, 0.5, 0.3, 0, 0, 0, 0 };                            // V-44 Blackfish
thrustCoef[] =
{
    1.2,    // At 0 % of maxSpeed, thrust energy will be 1.2
    1.2,    // 12.5 %
    1.1,    // 25 %
    1.1,    // 37.5 %
    1.0,    // 50 %
    0.9,    // 62.5 %
    0.8,    // 75 %
    0.7,    // 87.5 %
    0.5,    // 100 %
    0.2,    // 112.5 %
    0.0,    // 125 %
    0.0,    // 137.5 %
    0        // 150 %
};
```

#### V

##### vtol

Requires "airplanex" simulation.

Type of VTOL :

All types allow manual vectoring up/down to certain limits described under that type.

0 - No VTOL capacity

1 - VTOL\
default 1.0 vectoring (nozzles/nacelles horizontal @ 0°)

2 - STOVL, vectoring limitation on slow speed\
default 1.0 vectoring (nozzles/nacelles horizontal @ 0°)\
limited 0.0 maximum vectoring (nozzles/nacelles horizontal @ 0°) below 5 km/h

3 - VTOL, vectoring limitation near ground\
default 0.7 vectoring (nozzles/nacelles medium @ ~60°)\
limited 0.7 minimum vectoring (nozzles/nacelles medium @ ~60°) below 5 meters altitude

4 - VTOL, opposite of 1\
default 1.0 vectoring (nozzles/nacelles vertical @ 90°)

Integer

```cpp
vtol = 0;    // A-164 Wipeout, not a VTOL aircraft
vtol = 1;    // F-35B, Vertical Take Off and Landing, Start horizontal (nozzles/nacelles @ 0°)
vtol = 2;    // AV-8B Harrier, Short Take Off/Vertical Landing
vtol = 3;    // V-44 Blackfish, VTOL using a vectoring near the ground (to avoid blades collision with ground)
vtol = 4;    // Y-32 Xi'an, Vertical Take Off and Landing, Start vertical (nozzles/nacelles @ 90°)
```

##### VTOLPitchInfluence

Once in hover flight, defines influence of pitch input.

Float

```cpp
VTOLPitchInfluence = 3.0;    // V-44 Blackfish
```

##### VTOLRollInfluence

Once in hover flight, defines influence of roll input.

Float

```cpp
VTOLRollInfluence = 10.0;    // V-44 Blackfish
```

##### VTOLYawInfluence

Once in hover flight, defines influence of yaw input.
Float

```cpp
VTOLYawInfluence = 6.0;    // V-44 Blackfish
```

#### W

##### wheelSteeringSensitivity

Once landed, defines the radius of steering with nose/tail wheel (same action as rudder).

Float

```cpp
wheelSteeringSensitivity = 1;    // A-164 Wipeout
wheelSteeringSensitivity = 1.2;    // Caesar BTT
wheelSteeringSensitivity = 0.8;    // V-44 Blackfish
```

<sub>Source: [BI Community Wiki — Arma 3: CfgVehicles Plane class config reference](https://community.bistudio.com/wiki/Arma_3:_CfgVehicles_Plane_class_config_reference) (revision 378498).</sub>