---
name: "CfgVehicles Config Reference"
type: topic
aliases: ["reflectors"]
source: https://community.bistudio.com/wiki/CfgVehicles_Config_Reference
revid: 378791
updated: 2026-06-14T23:14:28Z
---

# CfgVehicles Config Reference

### Introduction

TokenName Config.cpp Reference

Simply put, Token Name & Value pairs are as follows

```cpp
SomeName = SomeValue;
```

Token Names are used extensively throughout Operation Flashpoint 'text' files.

An example is, when creating a model using class statements inside a [Config.cpp](../topics/Config.cpp~2Fbin_File_Format.md), to access it later, via the mission editor

```cpp
scope = 2;
```

This article details the token-names specifically available within the **CfgVehicles** class of a [Config.cpp](../topics/Config.cpp~2Fbin_File_Format.md). The primary focus of this document is the TokenNames used for various aspects of controlling models within **Addons**.

Unlike a command reference, where one meaning fits all, Token names are **not** verbs. The meaning of the name, it is effect, can be different, depending on context. You are advised therefore, that these names, as listed, apply *only* to the CfgVehicles class. They may, or may not, have identical meanings (if found), in other classes.

This article lists token names, their value ranges, and their type.

#### TokenTypes

| Token Type | Description | Example |
|---|---|---|
| Integer | A signed value that will be held in 4 bytes. | `token = 1;` |
| Boolean | An Integer value of 0 or 1. This is a 'convenience type' in humanly readable text. The engine stores it as an integer.<br>For Elite only: **All strings must be enclosed in quotes**. | `token = true;` |
| String | Any string value | `token = "SomeString";` |
| Array | An array | `token[] = { ... };` |
| Float Array | An array of floats | `token[] = { 0.5, 0.3, 0.05 };` |
| String Array | An array of strings | `token[] = { "String1", "String2" };` |
| Integer Array | An array of integers | `token[] = { 0, 1, 2 };` |
| Complex Array | A mixture of multiple types, including embedded arrays. | `token[] = { "String", 1, 0.5, true };` |
| Variable Array | The number of elements for **this** array in **this** class model can have a varying number of elements (depending on context) |  |

#### Filenames and Paths

Filenames are case **in**sensitive.

##### Pbo File conventions

The root path of the filename is (generally) the name of the pbo

```cpp
model= "\anypbofile\anywhere\....";
```

note the pbo extension is inferred

**anywhere** is an (optional) (series of) folder(s) INSIDE the pbo.

Depending on the file referred to, eg a p3d file for a model, the extension (in this case .p3d) is not required.

##### p3d files

```cpp
model = "\anypbofilename\anyp3d(.p3d)";
```

##### paa/pac

Wherever these file types are indicated, the default extension is paa

```cpp
icon = "\somepbo\anyicon(.paa)";
```

##### jpeg

jpeg pictures are usable anywhere a pac (or pac) file is indicated. It is never default.

Exception: Operation Flashpoint: Elite specifically, cannot handle jpg.

```cpp
picture = "\AnyPbo\AnyPicture.jpg";
```

##### Sound files

wss is the default extension if not declared.

```cpp
sound = "\AnyPbo\AnySoundFolder\AnySound(.wss)";
```

Otherwise use Ogg Vorbis format (extension .ogg).

#### Vehicle vs 'Vehicle'

In this document. a vehicle, is a true vehicle of some kind. Be it a tank, or a car.

A 'vehicle' on the other hand covers cfgVehicles as defined in a config.cpp which would include **men** or **buildings**, since Operation Flashpoint considers them *all* to be 'vehicles'

#### Config.bin vs Config.cpp

By convention only, [config.**cpp**](../topics/Config.cpp~2Fbin_File_Format.md) is the humanly readable text equivalent of [config.**bin**](../topics/Config.cpp~2Fbin_File_Format.md).

The engine will accept either or **both**.

When both are encountered, it is the text file that is predominant (the raPified file is ignored). (Which is the text file, and which is the 'binary' is moot, see below).

While unusual to have both, it is common for an addon, eg a pbo, to have **both** inside where the config.cpp is a 'work in progress' that might later be 'binarised' to raP, and the cpp removed.

#### raP files

So-called 'binarised' or 'binary' files are encoded in raP file format. They are not in the conventional sense a "binary"—machine readable code or data—but rather a more convenient encoded form of the text file (from the engine's perspective). They represent the stripping out of comments and extraneous crud, with bells on. For example, save files are raP encoded, just like config.bin is.

By convention only, a config.cpp is a text file. The engine does not actually care; if it encounters a config.cpp with a raP signature, it is treated as per a config.bin.

The engine unconditionally converts text files to raP encoding before it uses it further. This (obviously) slows game or mission loading and (less obviously) is a source of 'undocumented features'. Prior to finishing your addon, it is a Good Idea™ to 'binarise' the config into raP encoding and rename the cpp file to .txt for documentation purposes.

### Alphabetical Order

#### A

##### ...Action

String : defaults ManActCargo

```cpp
commanderAction =    "ManActM60CommanderOut";
driverAction =        "ManActShipDriver";
gunnerAction =        "ManActJeepGunner";
commanderInAction =    "ManActTestDriver";
driverInAction =    "ManActM113Driver";
gunnerInAction =    "ManActM1A1Gunner";
getInAction =        ManActGetInTank;    // default
getOutAction =        ManActGetOutTank;    // default
```

###### cargoAction

Variable String Array: default {ManActCargo}

```cpp
cargoAction[] = { "ManActM113Medic", "ManActM113Medic", "ManActM113Injured" };
```

**Note** that unlike driverAction and gunnerAction this is an array. (for multiple positions)

The number of elements in this array correspond to the [#transportSoldier](../topics/CfgVehicles_Config_Reference.md#transportsoldier) value declared for this class.

see [#cargoIsCoDriver](../topics/CfgVehicles_Config_Reference.md#cargoiscodriver)

##### ...AngleX/Y

Float Degrees

```cpp
initAngleX = 0;
minAngleX = -30;
maxAngleX = 30;
```

```cpp
initAngleY = 0;
minAngleY = -100;
maxAngleY = 100;
```

```cpp
initFov = 0.700000;
minFov = 0.420000;
maxFov = 0.850000;
```

used by car.ViewPilot class

##### angle

Float: Degrees

```cpp
angle = -240;
```

see [#Indicator... Class](../topics/CfgVehicles_Config_Reference.md#indicator-class) Or [#Hatch... Class](../topics/CfgVehicles_Config_Reference.md#hatch-class)

##### access

Integer: Determines the manipulability of the class.

```cpp
access = 1;
```

0 ReadAndWrite additional values can be added
1 ReadAndCreate only adding new class members is allowed
2 ReadOnly no modifications enabled
3 ReadOnlyVerified no modifications enabled, CRC test applied

All *BIS* classes are **ReadOnlyVerified** and can only be inherited into a new class

##### accuracy

Float: Default value = 0.02.

Determines how easy an object is to identify. Smaller values are easier to detect.

Typically, buildings are 0.2, vehicles, 0.5

**A value of 1000 causes the underlying class to be identified instead**. Eg bushy trees, pink trees and yellow trees, can all be 'identified' as "trees". The description "bushy trees" is then used solely when Editing. See [#VehicleClass](../topics/CfgVehicles_Config_Reference.md#vehicleclass)

```cpp
accuracy = 0.2;            // buildings
accuracy = 0.5;            // small vehicles
accuracy = 0.9;            // truck
accuracy = 3.500000;    // sniper
accuracy = 1.500000;    // lawsoldier
accuracy = 1000;        // soldier - identify (most) soldiers as 'man'
```

Relationship to [#camouflage](../topics/CfgVehicles_Config_Reference.md#camouflage):

**accuracy** defines how hard it is for the AI to recognise the correct class of a unit. But even if it can't recognise the correct class it can still recognise it as an enemy and engage it.

**camouflage** defines how hard it is for the AI to *see* that the unit is there.

Related TokenNames
[#scope](../topics/CfgVehicles_Config_Reference.md#scope), [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy), [#displayName](../topics/CfgVehicles_Config_Reference.md#displayname), [#vehicleClass](../topics/CfgVehicles_Config_Reference.md#vehicleclass), [#nameSound](../topics/CfgVehicles_Config_Reference.md#namesound), [#camouflage](../topics/CfgVehicles_Config_Reference.md#camouflage)

##### acceleration

Float: metres per second

```cpp
acceleration = 7;
```

##### airFriction

Array: 3 separate tokens, airFriction0[], airFriction1[], airFriction2[] that define the X Y and Z component respectively.

```cpp
airFriction2[] = { 25, 12, 2.500000 };
```

##### airFrictionCoefs...

Array: tokens for defining the friction behaviour of planes, introduced with Arma 3 Jets DLC. They define the airfriction for planes with simulation = "PlaneX". Untested if applicable to other objects as well. The values in each array define the X, Y and Z coefficients respectively. The friction force in a certain axis is calculated ingame by F_friction = v * abs( v ) * airFrictionCoefs2+ v * airFrictionCoefs1+ (sign of v) * airFrictionCoefs0; where "v" is the speed of the plane in that particular axis.

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

##### ambient

Float Array:

```cpp
ambient[] = { 0.07, 0.07, 0.07, 1.0 };
```

See [#Reflectors Class](../topics/CfgVehicles_Config_Reference.md#reflectors-class), [#Light Class](../topics/CfgVehicles_Config_Reference.md#light-class), [#CargoLight Class](../topics/CfgVehicles_Config_Reference.md#cargolight-class)

##### animated

Boolean : Default Value true

Used by class models that inherit an animated 'vehicle' to turn those aspects of the vehicle off.

```cpp
animated = false;
```

model is animated, or not.

when set true, the animation class, if any, happens, otherwise it doesn't

see animations class

##### animPeriod

Float: Seconds.

This TokenName is generally used inside AnimationSources class (ArmA only). It's use in OFP:R is as follows

```cpp
animPeriod = 1.33; // a fountain
```

##### animation...

String: These animation strings point to rtm files to create the movement.

```cpp
animationFlag = "\AnyAddon\AnyRTM(.rtm)";    // to wiggle flag in wind
animationOpen = "\AnyAddon\AnyRTM(.rtm)";    // to open or close doors (eg)
animationDrop = "\AnyAddon\AnyRTM(.rtm)";
```

##### animationList[]

Array format [String, Float]

(possibly introduced in Arma 3 v1.24 when other randomisation features were added)

Array of animation sources to randomize the vehicle with similar to facewear/headgear randomization for characters (See [Arma 3: Characters And Gear Encoding Guide - FIA headgear and facewear randomization](../topics/Characters_And_Gear_Encoding_Guide.md#fia-headgear-and-facewear-randomization); format is:

```cpp
animationList[] = { "animation1", weight1, "animation2", weight2, etc. };
```

Animations must be classes from the vehicle's AnimationSources. If all the weights are the same value, it functions as straight equal randomisation.

Example:

```cpp
class MyAPC : B_APC_Wheeled_01_cannon_F
{
    animationList[] = {
        "showBags", 0,
        "showCamonetHull", 0.5,
        "showCamonetCannon", 0.75,
        "showCamonetTurret", 1,
        "showSLATHull", 1,
        "showSLATTurret", 1
    };
};
```

##### animationSource...

String

```cpp
animationSourceBody = "Turret_2";
animationSourceGun = "Gun_2";
animationSourceHatch = "hatchCommander";
animationSourceElevation = ""; // new in Arma 3
animationSourceCamElevation =""; // new in Arma 3
```

##### armor (integer)

Float: A strength value of the object, how much external damage can be taken before 'destruction'. It is calculated together with object volume size! (bounding sphere calculated in geometry) Below are general ranges to give some idea.

```cpp
approx strength = (0.27/tgtRadius)^2 / armorInConfig

armor = 3;            // man
armor = 10;            // motorcycle
armor = 20;            // a small car
armor = 15..60;        // aircraft
armor = 150;        // buildings
armor = 150..300;    // bmp
armor = 400...900;    // tank
armor = 300;        // boat
armor = 10000;        // ship
```

If unspecified (or not inherited) the default value is 30

- 1 bullet will kill armor <= 20
- 2 bullets <= 40
- 3 bullets 50

##### armor (float)

Float: The floating version of armor type is only used in Hit... classes, eg HitTurret HitBody

```cpp
armor = 1.4;    // a bee
armor = 0.8;    // a turret
```

Related TokenNames: [#armor (float)](../topics/CfgVehicles_Config_Reference.md#armor-float), [#material](../topics/CfgVehicles_Config_Reference.md#material), [#name](../topics/CfgVehicles_Config_Reference.md#name), [#passThrough](../topics/CfgVehicles_Config_Reference.md#passthrough)

##### armor...

Float:

```cpp
// for vehicles general
armorStructural= 1;    // ranges between 1 and 4.0, default 1
armorFuel = 1.4;    // default
armorGlass = 0.5;    // default
armorLights = 0.4;    // default 0.4 in all models.
armorWheels = 0.05;    // default
// for tanks
armorHull = 1;
armorTurret = 0.8;
armorGun = 0.6;
armorEngine = 0.8;
armorTracks = 0.6;
// for men
armorHead = 0.7;
armorHands = 0.5;
armorLegs = 0.5;
// helicopters
armorHull = 0.5;
armorEngine = 0.6;
armorAvionics = 1.4;
armorVRotor = 0.5;
armorHRotor = 0.7;
armorMissiles = 1.6;
armorGlass = 0.5;
```

##### assembleInfo

Used for both vehicles that can be diassembled and backpacks that are assembled into vehicles (static guns, drones, etc.)

Class values for backpacks, primary part:

```cpp
class assembleInfo
{
    assembleTo = "I_G_HMG_02_high_F";    // Backpack assembles into this vehicle
    primary = 1;                        // This backpack is main part, when assembly is done, its "assembleTo" class will be used for created vehicle
    base[] = { "B_HMG_02_support_high_F", "O_HMG_02_support_high_F" , "I_HMG_02_support_high_F" }; // And requires these entities as second part (tripod), can be any number of classnames
    displayName = "Static MG";            // String that will be shown in "Assemble X" mouse wheel menu action
    dissasembleTo[] = {};                // Backpacks are not disassembled futher, but empty array is required here anyways
};
```

Second part (tripod) only needs `primary = 0;`:

```cpp
class assembleInfo
{
    assembleTo = "";
    primary = 0;
    base = "";
    displayName = "";
    dissasembleTo[] = {};
};
```

If no second part is needed for assembly, primary backpack's "base" have to be empty string: `base = "";`

Vehicles disassembly info:

```cpp
class assembleInfo
{
    assembleTo = "";
    primary = 0;
    base = "";
    displayName = "";
    dissasembleTo[] = { "B_HMG_02_high_weapon_F", "B_HMG_02_support_high_F" }; // Vehicle will be disassembled into these backpacks. Max 2 allowed.
};
```

Note the typo in "dissasembleTo" property, engine expects it like this. Empty values have to be provided to avoid missing config values errors.

Note: Vehicle keeps track which second part (tripod) was used when it was assembled and its used again when you disassemble it back.

##### attendant

Boolean: Default false

Used for 'vehicles' to repair other 'vehicles'. Thus a hospital has an attendant that can repair soldiers. Adds the action "Heal at XXX"

```cpp
attendant = true;
```

Related TokenNames: [#hiddenSelections](../topics/CfgVehicles_Config_Reference.md#hiddenselections)

##### audible

Float: Default Value 1

```cpp
audible = .05;    // man
audible = 3;    // motorcycle
audible = 6;    // tank/ship
```

How loud you are. The bigger value, the better the unit is heard.

see [#camouflage](../topics/CfgVehicles_Config_Reference.md#camouflage)

##### autocenter

Boolean: Default true

```cpp
autocenter = false;    // man
```

##### axis

String:

```cpp
axis = "osa_poklop_driver";
```

see [#Indicator... Class](../topics/CfgVehicles_Config_Reference.md#indicator-class) Or [#Hatch... Class](../topics/CfgVehicles_Config_Reference.md#hatch-class), [IndicatorWatch Class](../topics/CfgVehicles_Config_Reference.md#hour)

#### B

##### body

String:

```cpp
body = "mainTurret";
```

see [#Turret Class](../topics/CfgVehicles_Config_Reference.md#turret-class)

##### brakeDistance

Float: default 5 meters per sec

```cpp
brakeDistance = 1;    // man
brakeDistance = 14;    // tank
brakeDistance = 500;// plane
brakeDistance = 50;    // boat
```

##### bounding

String: Memorypoint which extends vehicle bounding box depending on position of this point. Defined for base class of Tanks. Default memorypoint is the tip of the tank's barrel (usti hlavne) - this means that when tank is pointing to the left, its bounding box is extended. You can observe bounding box extending in i.e. Zeus.

```cpp
bounding = "usti hlavne";
```

##### brightness

Float:

```cpp
brightness = 1.0;
```

See [#Reflectors Class](../topics/CfgVehicles_Config_Reference.md#reflectors-class), [#Light Class](../topics/CfgVehicles_Config_Reference.md#light-class), [#CargoLight Class](../topics/CfgVehicles_Config_Reference.md#cargolight-class)

#### C

##### ...CanSee

Integer

Used to describe which sensory inputs are available to which crew members.

| Numeric value | CanSee.. define | Description |
|---|---|---|
| 1 | Radar | Enables top left radar (OA) for a vehicle (top centre in arma and OFP). |
| 2 | Eye | Effect unknown - maybe affects AI capabilities? |
| 4 | Optics | Effect unknown - maybe affects AI capabilities? |
| 8 | Ear | Effect unknown - maybe affects AI capabilities? |
| 16 | Compass | Enables top centre compass bar and digital compass in A2/OA. |
| 32 | Peripheral | Enables small colored blobs at the edge of the screen that indicate nearby units. |

Multiple values can be added (or binary ored, giving the same result) together.

```cpp
commanderCanSee = 31;        // default
gunnerCanSee = 4 + 8 + 16;    // default
driverCanSee = 2 + 8 + 16;    // default
```

```cpp
#define CanSeeRadar            1
#define CanSeeEye            2
#define CanSeeOptics        4
#define CanSeeEar            8
#define CanSeeCompass        16
#define CanSeeAll            31
#define CanSeePeripheral    32
#define CanSeeRadarC        CanSeeRadar + CanSeeCompass
```

```cpp
commanderCanSee = CanSeeAll;
gunnerCanSee = CanSeeOptics + CanSeeEar + CanSeeCompass;
driverCanSee = CanSeeEye + CanSeeEar + CanSeeCompass;
```

##### ...CargoAngleY

Float Degrees

Found within vehicle classes.

Orientation of the man sitting in the cargo space.

```cpp
initCargoAngleY = 185;    // Truck5t
initCargoAngleY = 90;    // M113
```

```cpp
initCargoAngleY = 10;    // UH60
minCargoAngleY = -60;
maxCargoAngleY = 120;
```

##### camouflage

Float: Default Value = 2.

how difficult to spot. bigger = easier

```cpp
camouflage = 0.6;    // snipers
camouflage = 1;        // man
camouflage = 4;        // trucks
camouflage = 8;        // tanks
```

Relationship to [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy):

**camouflage** defines how hard it is for the AI to *see* that the unit is there. The AI will not spot an enemy that has a camouflage setting of 0 (maybe this needs some more testing) even if it stands directly in front of it *as long as the enemy doesn't fire*.

**accuracy** defines how hard it is for the AI to recognise the correct class of a unit. But even if it can't recognise the correct class it can still recognise it as an enemy and engage it.

Related TokenNames
[#scope](../topics/CfgVehicles_Config_Reference.md#scope), [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy), [#displayName](../topics/CfgVehicles_Config_Reference.md#displayname), [#vehicleClass](../topics/CfgVehicles_Config_Reference.md#vehicleclass), [#nameSound](../topics/CfgVehicles_Config_Reference.md#namesound), [#camouflage](../topics/CfgVehicles_Config_Reference.md#camouflage)

##### can...

###### canBeShot

Boolean: Declares whether bullets have any effect

```cpp
canBeShot = true;
```

###### canDeactivateMines

Boolean: Default false

part of the man class.

```cpp
canDeactivateMines= true;    // SoldierEngineer
```

###### canFloat

Boolean: Default value: false

Used to allow vehicles (such as BMP) not to sink !

```cpp
canFloat = true;
```

###### canHideBodies

Boolean: Default false

part of the man class.

```cpp
canHideBodies = true;    // SoldierWSaboteur
```

##### cargoIsCoDriver

Variable Boolean Array : Default {false};

This token declares which (if any) cargo positions are 'in the front' (Ie front windscreen)

```cpp
cargoIsCoDriver[] = { true, true, false };    // 1st two passenger positions for a 5T truck
```

The number of elements in **this** array correspond to the [#transportSoldier](../topics/CfgVehicles_Config_Reference.md#transportsoldier) value declared for **this** class model.

##### cargoReversedGetOut (Arma 3 v2.04)

Array
**Description:** Settings this to 0 will force the unit to face the vehicle when getting out of a vehicle. 1 is the default behaviour where the facing direction is opposit of the get in direction.

```cpp
cargoReversedGetOut[] = { 0 };
```

##### cast...Shadow

Boolean: Default false

```cpp
castCargoShadow = false;
castCommanderShadow = false;
castDriverShadow = false;
castGunnerShadow = true;
```

Normally used to shadow 'soldiers' standing up in vehicle objects, such as the MG Jeep and Machine Guns.

##### Classes Embedded

see [#Embedded ClassNames](../topics/CfgVehicles_Config_Reference.md#embedded-classnames)

##### cloud...

Various(Strings, Floats, Arrays)

```cpp
cloudletDuration = 0.9;
cloudletAnimPeriod = 1.0;
cloudletSize = 0.1;
cloudletAlpha = 0.8;
cloudletGrowUp = 0.4;
cloudletFadeIn = 0.0;
cloudletFadeOut = 5.0;
cloudletAccY = -0.1;
cloudletMinYSpeed = 0.3;
cloudletMaxYSpeed = 1.5;
cloudletShape = "\ca\data\cl_basic";
cloudletColor[] = { 1, 1, 1, 0 };
```

See [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

##### cobraLight

String : Used as a core model for all other 'air' craft.

```cpp
cobraLight = "AnyAddon\AnyP3d(.p3d)";
```

##### coefInside...

Float:

```cpp
coefInside = 2;            // cost for movement inside buildings
coefInsideHeur = 4.3;    // estimation of cost based on in/out points
coefSpeedInside = 2; // we must go slowly inside houses
```

Used by the static class for non moving objects such as buildings

```cpp
coefInside = 1;    // forest
coefInsideHeur = 0.25;
```

##### collisionLight

Float Boolean: Default: false.

Default state of collision lights

```cpp
collisionLight = true; // spawn vehicle with collision lights on
```

##### color

Float Array: of floats.

```cpp
color[] = { 0.8, 0.8, 1.0, 1.0 };
```

This is a fixed four dimension array consisting of the color values for a RGBA model.

See [#Reflectors Class](../topics/CfgVehicles_Config_Reference.md#reflectors-class), [#Light Class](../topics/CfgVehicles_Config_Reference.md#light-class), [#CargoLight Class](../topics/CfgVehicles_Config_Reference.md#cargolight-class), [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

##### commanding

Integer: part of Turret class

```cpp
commanding = -1;
```

##### cost

Float: Default Value 50.0000

This value reflects the attractiveness of the target to the enemy AI. When *all other considerations are equal*.
A soldier eg is not interested in Air, despite it is highly attractive cost values.
On the other hand, he is interested in a medic, since a medic (in normal configs) has a (while small) a higher cost, than others in the group, including the officer.

```cpp
cost = 10000000;    // an air vehicle is typically this value
cost = 8;            // a medic;
cost = 1;            // a grunt
cost = 4;            // an officer
cost = 0;            // most buildings;
```

Related TokenNames: [type](../topics/CfgVehicles_Config_Reference.md#type-threat), [#cost](../topics/CfgVehicles_Config_Reference.md#cost), [#threat](../topics/CfgVehicles_Config_Reference.md#threat)

##### count

String or Integer: (math formula).

```cpp
weapon = "M60";
count = "30 * 1"; // or 'count = 30 * 1;'
```

this token is always associated in a weapon or magazine couplet, inside a TransportWeapons, or
TransportMagazines class.

The value is mostly represented as a string as above (a math formula), or it can be (unusually)

```cpp
count = 2;
```

See At the End of the Day in the TokenNameValueTypes page for an explanation how this duality is possible.

##### crew

String: Default Civilian

Reflects whether vehicle is manned, and what with.

```cpp
crew = <ClassName>
crew = "SoldierWPilot";
```

'SoldierWPilot' is a class declared in same file.

##### crewCrashProtection

Float

Multiplier of damage to crew of the vehicle. Lower number means better protection.

```cpp
crewCrashProtection = 0.05;
```

#### D

##### dammage [sic]...

Variable String Array:

```cpp
dammageHalf[] = { "\AnyAddon\AnyPAA.paa", "\AnyAddon\AnyOtherPAA.paa", ... };
dammageFull[] = { "\AnyAddon\AnyPAA.paa", "\AnyAddon\AnyOtherPAA.paa", ... };
```

When 'vehicle' is considered at least half way to destruction, the series of pictures is applied to the model.

###### damageResistance (Armed Assault v1.00)

Only for AI, to know when to shoot and when not.

```cpp
damageResistance = 0.004;
```

It can be calculated from vehicle armor and hit value of weapon that should be able to harm the vehicle. tgtRadius is radius of virtual bounding sphere calculated in vehicle geometry. [CfgVehicles_Config_Reference#armor_.28integer.29](../topics/CfgVehicles_Config_Reference.md#armor-integer)

```cpp
damageResistance = (HIT*HIT)/Armor*((0.27/tgtRadius)*(0.27/tgtRadius))
```

##### driveThroughEnabled

Determines if AI can decide to go through the object. This parameter skips regular mass checking if object can smashed through

```cpp
driveThroughEnabled            = 1; // test parameter for AI knowing they can drive through the object
```

##### damper...

Float:

```cpp
damperSize = 0.1;    // default
damperForce = 3;    // default
```

##### deltaT

Float

```cpp
deltaT = -500;
```

See [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

##### density

Float

```cpp
density = 0.5;
```

See [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

##### destrType

String: Default Value = "DestructDefault"

Used for animation, sound, and final 'look' of vehicle. Since Arma 3 v2.22 Powerline colums and radio tower get new type of destruction "DestructColumn". The tall column leans 22.5 degrees, away from the source that caused damage (for example satchel charge). The lean direction is synced for JIP, the anchor supports and powerlines destruction is scripted and JIP synced as well.

```cpp
destrType = "DestructNo";        // nothing happens
destrType = "DestructBuilding";    // smoke. explosion
destrType = "DestructEngine";    // smoke only
destrType = "DestructTree";        // smoke, crushing, falls over
destrType = "DestructTent";        // smoke, crushing, flattens
destrType = "DestructMan";
destrType = "DestructDefault";    // = building
destrType = "DestructWreck";
destrType = "DestructColumn"; // Power line columns, radio tower
```

Tent and Tree are no longer identifiable when destroyed if not class 'things'

##### disableDriverAttenuation

Number: Default 0;

Disables attenuation for the driver.

```cpp
disableDriverAttenuation = 1;
```

##### disappearAtContact

Boolean: Default false;

```cpp
disappearAtContact = true;    // FxCartridge
```

##### direction

String:

```cpp
direction = "konec L svetla";
```

see [#Reflectors Class](../topics/CfgVehicles_Config_Reference.md#reflectors-class)

##### displayName

String: Default value = "Unknown" or "Vehicle"

Selects object uniquely in the Mission Editor, and separately, is used to identify object in game according to [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy). For instance when pointing your men to an object while in a mission, it is this *displayName* that is used.

It is good practice to use a stringtable.csv that should accompany your addon so that

1. All names and labels are in one place instead of hunting for them.
1. For language differences

```cpp
displayName = "$STR_DN_AH1Z";
```

Note, that will careful crafting of classes, different colored 'rocks' can all be called the same displayName (rock) in the mission itself. See [#scope](../topics/CfgVehicles_Config_Reference.md#scope) and [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy) for details.

See [#nameSound](../topics/CfgVehicles_Config_Reference.md#namesound) for definition of what is actually 'said'

Related TokenNames
[#scope](../topics/CfgVehicles_Config_Reference.md#scope), [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy), [#displayName](../topics/CfgVehicles_Config_Reference.md#displayname), [#vehicleClass](../topics/CfgVehicles_Config_Reference.md#vehicleclass), [#nameSound](../topics/CfgVehicles_Config_Reference.md#namesound), [#camouflage](../topics/CfgVehicles_Config_Reference.md#camouflage)

###### displayNameShort

String:

```cpp
displayNameShort = "$STR_DN_UH60";
```

##### driverIsCommander

Boolean : Default false. When not set, the turret [commanding](../topics/CfgVehicles_Config_Reference.md#commanding) values are used to determine who is the commander. (*source* (dead link))

```cpp
driverIsCommander = true;
```

For boat, MG Jeep and helicopters

see [#has...](../topics/CfgVehicles_Config_Reference.md#has)

##### driverForceOptics

Boolean
**Description:** Determines if the driver can freely look around inside the vehicle or if he is locked to looking forward through the hatch/optics.

```cpp
driverForceOptics = true;
```

##### driverReversedGetOut (Arma 3 v2.04)

Integer

**Description:** setting this to 0 will force the unit to face the vehicle when getting out of a vehicle. 1 is the default behaviour where the facing direction is opposit of the get in direction.

```cpp
driverReversedGetOut = 0;
```

##### ...DustEffect

String

Defines the effect that will be spawned at the position of the LandContact points.

```cpp
leftDustEffect = "vbs2_fx_lowTrackDustEffects";
rightDustEffect = "vbs2_fx_lowTrackDustEffects";
```

see [#...WaterEffect](../topics/CfgVehicles_Config_Reference.md#watereffect)

#### E

##### editorCategory

Eden Editor main category. See [Eden Editor: Object Categorization](../topics/Eden_Editor~3A_Object_Categorization.md) for more details.

```cpp
editorCategory = "EdCat_Structures";
```

##### editorPreview

Eden Editor preview picture. See [Configuring Asset Previews](../topics/Eden_Editor~3A_Configuring_Asset_Previews.md) for more details.

```cpp
editorPreview = "\A3\EditorPreviews_F\Data\myObject.jpg";
```

##### editorSubcategory

Eden Editor sub-category. See [Eden Editor: Object Categorization](../topics/Eden_Editor~3A_Object_Categorization.md) for more details.

```cpp
editorSubcategory = "EdSubcat_Drones";
```

##### enableGPS

Boolean: If enabled vehicle will allow crew to use Minimap even if they do not posses GPS terminal.

```cpp
enableGPS = 1;
```

##### ...Elev

Integer: Degrees

**Description:** How far the mounted weapon and viewpoint (through optics only) can be lowered or raised, and how much the initial elevation is. Values of max and min = 90 effectively allows a weapon to be lowered into the ground/straight into the air.

```cpp
initElev = -80;
minElev = -60;
maxElev = 10;
```

part of any [#Turret Class](../topics/CfgVehicles_Config_Reference.md#turret-class) (tanks eg)

##### ejectDamageLimit

Float: If the damage value of the vehicle is higher than the ejectDamageLimit, AI will disembark the vehicle.

```cpp
ejectDamageLimit = 0.75;
```

##### ejectDead...

Boolean : Default false

```cpp
ejectDeadGunner = false;
ejectDeadCargo = false;
ejectDeadDriver = false;
ejectDeadCommander = false;
```

Causes that unit to 'unmount' the vehicle. Such as an MG nest, or motorcycle.

##### ejectSpeed

Array: Speed vector of ejection seat. Therefore only applies to planes.

```cpp
ejectSpeed[] = { 0, 0, 0 };    // cannot eject in a Cessna
```

##### Embedded ClassNames

Some Token Names are encountered only within an embedded classname, rather than the main 'vehicle' body.

An embedded classname conveniently adds a unique feature to the 'vehicle'. Such as smoke, such as, a turret for a tank.

Embedded class names are used extensively in animated buildings for the quite logical reason that identical Token Names for door1 cannot be the same as Door2.

Below is a list of embedded classnames that (in most cases) use a TokenName uniquely. It is not found elsewhere and is better served describing that Token Name in the context it is found in, ie, an embedded class.

###### Hatch... Class

```cpp
class HatchDriver
{
    selection = "poklop_driver";
    axis = "osa_poklop_driver";
    angle = -100;
};
```

###### Indicator... Class

```cpp
class IndicatorSpeed
{
    selection = "ukaz_rychlo";
    axis = "osa_rychlo";
    angle = -240;
    min = 0;
    max = 60 / 3.6;
};
```

###### Light Class

```cpp
class Light
{
    ambient[] = { 0.3, 0.15, 0.0, 1.0 };
    brightness = 0.08;
    color[] = { 1.0, 0.5, 0.0, 1.0 };
    position = "ohniste";
    shape = "koulesvetlo";
    size = 0.3;
};
```

###### CargoLight Class

```cpp
class CargoLight
{
    ambient[] = { 0.6, 0, 0.15, 1 };
    brightness = 0.007;
    color[] = { 0, 0, 0, 0 };
};
```

###### Reflectors Class

```cpp
class Reflectors : LandVehicle    // old
{
    ambient[] = { 0.1, 0.1, 0.1, 1.0 };
    brightness = 0.25;
    color[] = { 0.9, 0.8, 0.8, 1.0 };
    position = "L svetlo";
    size = 0.5;
    direction = "konec L svetla";
    hitpoint = "L svetlo";
    selection = "L svetlo";
};

class Reflectors                // new
{
    class Light_1
    {
        ambient[] = { 10, 10, 11 };
        color[] = { 1000, 1000, 1100 };
        size = 1;
        dayLight = 1;
        useFlare = 1;
        intensity = 1;
        coneFadeCoef = 2;
        innerAngle = 89;
        outerAngle = 90;
        position = "light_start_memoryPoint";
        direction = "light_end_memoryPoint";
        hitpoint = "";
        selection = "";

        class Attenuation // see https://community.bistudio.com/wiki/setLightAttenuation
        {
            start = 0;
            constant = 0;
            linear = 0;
            quadratic = 0;
            hardLimitStart = 9;
            hardLimitEnd = 10;
        };
    };
};

// Arma 3 example value
class Reflectors
{
    class Left // main landing light
    {
        position = "L svetlo";
        direction = "konec L svetla";
        hitpoint = "L svetlo";
        selection = "L svetlo";
        color[] = { 7000, 7500, 10000 }; // R, G, B
        ambient[] = { 70, 75, 100 }; // R, G, B
        intensity = 50;
        size = 1;
        innerAngle = 15;
        outerAngle = 65;
        coneFadeCoef = 10;
        useFlare = 1;
        flareSize = 10;
        flareMaxDistance = 250;
        dayLight = 0;
        class Attenuation
        {
            start = 0;
            constant = 0;
            linear = 1;
            quadratic = 1;
            hardLimitStart = 100;
            hardLimitEnd = 200;
        };
    };
    class LG : Left // left door gunner searchlight
    {
        position = "LG svetlo";
        direction = "konec LG svetla";
        hitpoint = "LG svetlo";
        selection = "LG svetlo";
    };
    class Right : Left // right door gunner searchlight
    {
        position = "P svetlo";
        direction = "konec P svetla";
        hitpoint = "P svetlo";
        selection = "P svetlo";
    };
};

// example red cabin light in helicopter

class Cabin
{
    position = "cabin_light";
    direction = "cabin_light_dir";
    hitpoint = "cabin_light";
    selection = "cabin_light";
    color[] = { 1000, 0, 0 };
    ambient[] = { 100, 0, 0 };
    intensity = 5;
    size = 1;
    innerAngle = 15;
    outerAngle = 150;
    coneFadeCoef = 1;
    useFlare = 1;
    flareSize = 0.1;
    flareMaxDistance = 1;
    dayLight = 0;

    class Attenuation
    {
        start = 0;
        constant = 0;
        linear = 1;
        quadratic = 1;
        hardLimitStart = 1;
        hardLimitEnd = 2;
    };
};
```

Notes for Arma 3:

Add a light to an object in class cfgvehicles.\
Each reflector requires a selection in relevant model vis LODs (e.g. "L svetlo") for the flare effect. \
Requires two memory points in memory LOD - light spawn position and direction e.g. position "L svetlo" and direction "konec L svetla".

The memory point you assign to position parameter is where the light source itself will be.\
The one you put to direction is the way your light will shine.\
The cone itself is set using innerAngle, outerAngle and coneFadeCoef.\
innerAngle sets the cone in which the light has it is full intensity.\
outerAngle sets the cone outside of which the light has zero intensity.\
coneFadeCoef is a coefficient that describes attenuation of the light between innerAngle and outerAngle. 1 equals linear attenuation, higher or lower value changes it, meaning how sharp/blurred will the edge of the lightcone as a whole be.\
Note that both the angles represent full angle of the cone, not just "angular offset" from direction of the light. If you set it to 90 degrees, it means the cone is 45 degrees to the "left" and 45 to the "right" of the direction specified by your memory points.\
As a spot light, reflectors are not made for cones above 180 degrees.\
Some time ago BIS made changes to the lighting system to allow for higher light variety during night time. One of the effects it had on configs of lights was that you need to set higher intensity than before the change to get the same results.\
color[] and ambient[] seem to have changed from RGB from 0-1 to way higher values - see example.

See [setLightAttenuation](../commands/setLightAttenuation.md) notes for explanation of attenuation values.\
See also [Arma 3 Cars Config Guidelines - Reflectors](../topics/Cars_Config_Guidelines.md#reflectors)\
aggregateReflectors are described here [link](https://manuals.bisimulations.com/vbs3/3-6/devref/Content/Config_Manual/CfgVehicles/A_cpp/cpp_aggregateReflectors.htm)

###### Smoke Class

```cpp
class Smoke
{
    density = 0.5;
    deltaT = -500;
    in = 0.0;
    out = 0.0;
    initT = 1000;
    initYSpeed = 1.7;
    interval = 0.01;
    size = 0.1;
    timeToLive = 100000002004087730000.0;

    cloudletDuration = 0.9;
    cloudletAnimPeriod = 1.0;
    cloudletSize = 0.1;
    cloudletAlpha = 0.8;
    cloudletGrowUp = 0.4;
    cloudletFadeIn = 0.0;
    cloudletFadeOut = 5.0;
    cloudletAccY = -0.1;
    cloudletMinYSpeed = 0.3;
    cloudletMaxYSpeed = 1.5;
    cloudletShape = "cl_basic";
    cloudletColor[] = { 1, 1, 1, 0 };

    class Table
    {
        class T1
        {
            maxT = 0;
            color[] = { 0.8, 0.8, 0.8, 1 };
        };
        class T2
        {
            maxT = 900;
            color[] = { 0.3, 0.3, 0.3, 1 };
        };
        class T3
        {
            maxT = 1000;
            color[] = { 1, 0.5, 0, 0.5 };
        };
    };
};
```

##### Turret Class

(Tanks eg)

```cpp
class TurretBase
{
    body = "OtocVez";
    gun = "OtocHlaven";
    gunAxis = "OsaHlavne";
    gunBeg = "usti hlavne";
    gunEnd = "konec hlavne";
    minElev = -4;
    maxElev = 20;
    minTurn = -360;
    maxTurn = 360;
    soundServo[] = { "Vehicles\gun_elevate", 0.031623, 1.0 };
    turretAxis = "OsaVeze";
};
```

For details see [Turret Config Reference](../topics/Turret_Config_Reference.md)

##### Embedded TokenNames

see [#Embedded ClassNames](../topics/CfgVehicles_Config_Reference.md#embedded-classnames)

##### enableSweep

Boolean: Default true. Used by Helicopter class

```cpp
enableSweep = false;    // UH60MG
```

Is sweeping over the target a valid technique for given helicopter?

##### envelope

Float Array

```cpp
// lift (G) based on speed
envelope[] = {
    // speed relative to max. speed -> lift
    // 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 1.1 1.2 1.3 1.4    // rel. speed
    0.0, 0.2, 0.9, 2.1, 2.5, 3.3, 3.5, 3.2, 2.5, 2.0, 1.5, 1.0, 0.9, 0.7, 0.5    // lift
};
```

Info by [RKSL-Rock](http://forums.bistudio.com/showpost.php?p=2037721&postcount=9):

The top speed is set via the mass. So you will need MLODs to alter it. So it is the same issue as the original OP.

The config maxspeed value is only really used by the AI and the engine as a base variable in some calculations.

You can change the acceleration though by using the envelope command.
This will change the vertical speed relative to the maxspeed in the config in steps of 10% of the stated max speed.

This is the envelope from the RKSL Lynx AH7:

```cpp
envelope[] = { 1.7, 2.50, 3.50, 4.50, 5.50, 5.50, 5.15, 5.15, 5.15, 5.15, 4.15, 3.15, 2.15, 2.15, 1.15 };
```

There are normally 15 values representing the vertical lift in m/s at 10% steps from 0 to 140% of the max speed.

So, if the max speed is 500 and the first value is always 0:

2nd value = 50kph and 2.5 m/s vertical speed
3rd value = 100kph and 3.5 m/s vertical speed
...
11th value = 500kph and 4.15 m/s vertical speed
...
15th value = 700kph and 1.15 m/s vertical speed.

You wont affect the top speed but it will make it easier to handle.

##### EventHandlers... Class

Pre-defined object Event Handlers. Property with class matches the handler name.

```cpp
class EventHandlers
{
    init = "myAddon_object = _this select 0;";
};
```

Arma 3 v1.54
Arma 3 introduced **extended event handlers**. It's possible to define event handlers within unique sub-classes, which prevents compatibility issues when multiple addons wants to set the same handler type to single vehicle class.

```cpp
class EventHandlers
{
    class MyAddon
    {
        init = "myAddon_object = _this select 0;";
    };
    class YourAddon
    {
        init = "yourAddon_object = _this select 0;";
    };
};
```

##### extCameraPosition[]

float Array: { X, Z, Y }; Default { 0, 2, -20 };

External (third-person) camera offset relative to the vehicle's `aimpoint` memory point, around which the camera orbits.

```cpp
extCameraPosition[] = { 0, 5, -30 };                // plane
extCameraPosition[] = { 0, 1, -10 };                // cars
extCameraPosition[] = { 0, 1.500000, -9 };            // tanks
extCameraPosition[] = { 0, 0.300000, -3.500000 };    // man
```

##### extCameraParams[]

float Array: Default { 0.5, 10, 50, 0.5, 1, 10, 30, 0, 1 };

Smoothing of external camera movement

extCameraParams[] = { multFactor, speedMin, speedMax, factorSpeeedMin, factorSpeeedMax, heightMin, heightMax, factorHeightMin, factorHeightMax };

factor = multFactor * interpolate(speed, speedMin, speedMax, factorSpeeedMin, factorSpeeedMax) * interpolate(heightAGL, heightMin, heightMax, factorHeightMin, factorHeightMax)

factor == 0 -> camera follow horizon

factor == 1 - > camera follow vehicle heading

factor (0, 1) interpolation between horizon and vehicle heading

```cpp
extCameraParams[] = { 0.5, 10, 50, 0.5, 1, 10, 30, 0, 1 }; // helicopters & UAV
```

to force the old external camera behavior

```cpp
extCameraParams[] = { -1 }
```

#### F

##### featureType

Integer: Default 0. 1 means the object is always visible within object view distance, 2 means always visible within terrain view distance. Same as [setFeatureType](../commands/setFeatureType.md).

```cpp
featureType = 2;
```

##### minFireTime

Integer: Default 20 seconds

```cpp
minFireTime = 20;
```

Minimal time spent firing on single target.

##### fired

String: Event Handlers

```cpp
fired = "_this exec ""\AnyAddon\AnySQS.sqs""";    // note the ""
```

##### flapsFrictionCoef

Float: Default 0.5

```cpp
flapsFrictionCoef = 2;    // can be integer too.
```

##### forceHide...

Boolean : Default false

```cpp
forceHideDriver = true;    // shilka
forceHideGunner = true;    // tank
forceHideCommander = true;
```

Disables the turnout option for that particular crew member

##### forceSupply

Boolean : Default

```cpp
forceSupply = true;
```

Found only in Weapon holders. Is used to make the weaponholder disappear when empty.

##### formation...

Integer:

```cpp
formationX = 10;    // default meters
formationZ = 20;    // default meters
formationTime = 10;    // default seconds
```

One or both X Z values are used to keep objects separated (in meters) depending on
wedge, echelon, V, single line, formations.

##### fov

Float

```cpp
fov = 0.85;    // Cessna
fov = 0.85;    // man
fov = 1.0;    // truck
```

##### ...Fov

Float

```cpp
minFov = 0.420000;    // man
maxFov = 0.850000;
minFov = 0.600000;    // truck
maxFov = 1.400000;
```

also used by [ViewPilot Classes](../topics/CfgVehicles_Config_Reference.md#anglex-y)

##### fuelCapacity

Float: Default Value 0. Has nothing to do with liters.

Arma 3: for a vehicle using tankX simulation consumption seems to be exclusively determined by engine rpm. With a 700 idle-rpm and 3000 max-rpm engine - a fuelCapacity of 1 will give you 640 seconds operation time at idle rpm, and 300 seconds of operation at maximum rpm. If the idle rpm was 200, you would get 865 seconds of operation, the max rpm time would not change. The amount of thrust from controllerinput is completely irrelevant.

A2 examples:

```cpp
fuelCapacity = 50;    // motorcycle
fuelCapacity = 100;    // car
fuelCapacity = 700;    // tank
fuelCapacity = 1000;// air
```

The required fuelCapacity value to achieve a specific operation TIME (in seconds) at a specific engine RPM (revolution per minute) can be estimated with:

```cpp
fuelCapacity = (8E-7 * RPM + 0.001) * TIME
```

##### fuelConsumptionRate

Integer: Default Value 0.01. Has no units. Works only on helicopters.

#### G

##### _generalMacro

String: in Arma 3. Has no purpose whatsoever. It is generated automatically by BI developer tools for debugging.

> « Some config properties are generated automatically (e.g., "nameSound", which sets how to unit appears in radio protocol, is computed based on unit's role and equipment, so coders won't need to set it manually). _generalMacro property is added to all objects which underwent this process to help with debugging. » – Karel Mořický ([source](https://forums.bohemia.net/forums/topic/179378-what-does-_generalmacro-do/))

##### getIn....ActionNamedSel

String: Named selection for get in actions working in same principle as actionNamedSel in UserActions. Available variants:

```cpp
getInDriverActionNamedSel
getInGunnerActionNamedSel
getInCommanderActionNamedSel
getInCargoActionNamedSel
getInTurretActionNamedSel
getInUnitActionNamedSel
```

##### ...Gun...

Integer:degrees

```cpp
minGunElev = -60;
maxGunElev = 60;
minGunTurn = -5;
maxGunTurn = 5;
minGunTurnAI = -30;
maxGunTurnAI = 30;
```

##### ...GunnerMayFire

Boolean: Default false

```cpp
outGunnerMayFire = true;    // m113
inGunnerMayFire = false;
```

##### ...GunClouds Class

This is a reference to the external WeaponCloudsGun classes

most models simply inherit the defaults

```cpp
class GunClouds : WeaponCloudsGun {};
class MGunClouds : WeaponCloudsMGun {};
```

here is an example of over-rides for class man

```cpp
class GunClouds : WeaponCloudsGun
{
    cloudletGrowUp = 0.200000;
    cloudletFadeIn = 0;
    cloudletFadeOut = 0.400000;
    cloudletDuration = 0.200000;
    cloudletAlpha = 1;
    cloudletAccY = 2;
    cloudletMinYSpeed = -10;
    cloudletMaxYSpeed = 10;
    interval = 0.020000;
    size = 0.300000;
    sourceSize = 0.015000;
};
```

##### ...GunFire Class

This is a reference to the external WeaponFireGun classes

most models simply inherit the defaults

```cpp
class GunFire : WeaponFireGun {};
class MGunFire : WeaponFireMGun {};
```

##### gearbox[]

Array

**Description:** Changes acceleration and max speed values of certain Vehicles. If changed, impact to the acceleration is minor (if notable at all!) to catastrophic (worsened acceleration/maxspeed). Best to leave as-is.

```cpp
gearbox[] = { -18, 0, 110, 16.15, 14.44, 13.33 };
```

##### gearRetracting

Boolean: Default true

```cpp
gearRetracting = false;    // Cessna
```

more correctly viewed as HasRetractingGear.

##### gestures

String:

Same as moves but refers to a gestures class

```cpp
gestures = "CfgGesturesMale";
```

##### gun

String:

```cpp
gun = "OtocHlaven";
```

see [#Turret Class](../topics/CfgVehicles_Config_Reference.md#turret-class)

##### gunAimDown

Float

**Description:** Aircraft only. How far a hardpoint-mounted gun "aims down"; high values allow for strafing runs without the need to nose-dive down too much, but also shift the targeting reticle in the aircraft's HUD; if too high, targeting reticle is only visible in 3rd Person (if available).

```cpp
gunAimDown = 0.07;
```

##### gunAxis

##### gunBeg

##### gunEnd

see [#Turret Class](../topics/CfgVehicles_Config_Reference.md#turret-class)

##### gunnerHasFlares

Boolean

```cpp
gunnerHasFlares = false;
```

##### gunnerName

String

```cpp
gunnerName = "$STR_POSITION_CREWCHIEF";
```

##### gunnerOutOptics...

String

```cpp
gunnerOutOpticsModel = "";
```

Array

```cpp
gunnerOutOpticsColor[] = { 0, 0, 0, 1 };
```

Boolean

```cpp
gunnerOutForceOptics = false;
```

Boolean

```cpp
gunnerOutOpticsShowCursor = false;
```

##### gunnerType

String

Part of [#Turret class](../topics/CfgVehicles_Config_Reference.md#turret-class).

Defines the character class that inhabits this turret by default, replaces the pilot which would usually be in this turret. Used primarily to add helicopter crewmen to helicopter turrets.

```cpp
class MyHelicopter : B_Heli_Transport_01_F
{
    class Turrets : Turrets
    {
        class MyTurret : MainTurret
        {
            gunnerType = "B_RangeMaster_F";
        };
    };
};
```

Because turrets are sub-members of the Turrets class of the base vehicle, all the classes must be fully exposed to their source (Helicopter class) to be inherited from, otherwise all turrets must be overwritten.

#### H

##### HeadAimDown

Float: Default: 0.

How much to tilt the driver's head forward in degrees.

```cpp
HeadAimDown = 10;    // tilt driver's head forward 10 degrees.
```

##### ...Height

Integer:

```cpp
minHeight = 5;    // Min height in metres above sea-level.
maxHeight = 50;    // Max height above sea level.
avgHeight = 10;
```

##### has...

Boolean:

```cpp
hasDriver = true;        // default
hasGunner = false;        // default
hasCommander = true;    // default
```

Depending on vehicle model.

Controls the "get in" commands.

Since 1.82 there is alternative syntax available for hasDriver property

```cpp
hasDriver = -1;    // t80auto
```

This will disable driver seat and add control ability to commander (turret with highest commanding value aka seat with highest effectiveCommander value)

see [#driverIsCommander](../topics/CfgVehicles_Config_Reference.md#driveriscommander)

##### ...HeadTurnAI

Integer Degrees

```cpp
minHeadTurnAI = -70;    // man class
maxHeadTurnAI = 70;
```

##### hiddenSelections

String Array: Default none.

Here you can define selections on the model, which are not shown at mission startup. This is useful for creating variations of one model, where the different selections are left out with hiddenSelections. (ex: Soldiers have the hidden selection "medic", as they should not have a red cross at their body):

Aside from this, the hidden selections are used for runtime texture assignment. Every element in the hidden selection-array corresponds to an index, with the first element being 0. Only 10 elements are allowed in the array and are numbered 0-9.

```cpp
hiddenSelections[] = { "pruh" }; // bmp/tank
```

Try `this setObjectTexture [0, "\data\duha.pac"];` in the initline of a BMP and you'll see which parts are meant by the selection "pruh".

Don't forget to add the model and the selections in the CfgModels, as the hidden selections won't work otherwise (at least not after [binarizing](../topics/Binarize.md)).

##### hide...

Boolean

```cpp
hideProxyInCombat        = false;    // default (true for tanks); if true, disables turn-in option for all crew
hideUnitInfo            = false;    // default see [[#unitInfoType]]
hideWeaponsCargo        = false;    // default
hideWeaponsCommander    = true;        // default
hideWeaponsDriver        = true;        // default
hideWeaponsGunner        = true;        // default
```

##### hitpoint

String:

```cpp
hitpoint = "L svetlo";
```

See [#Reflectors Class](../topics/CfgVehicles_Config_Reference.md#reflectors-class)

##### hitSound...

```cpp
hitSound1[] = { "voices\Hit11", 0.056234, 1 };
...
hitSound20[] = { "voices\Hit30", 0.056234, 1 };
...
hitSounds[] = { "hitSound1", 0.05, "hitSound2", 0.05, ...
```

hitSounds is used by the engine to reference user generated hitSound...s

there is no limit to the number of user-generated sounds.

##### hour

part of the IndicatorWatch class

```cpp
class IndicatorWatch
{
    hour = "hodinova";
    minute = "minutova";
    axis = "osa_time";
    reversed = 0;
};
```

##### hullExplosionDelay

Array: Time ranage when catastrophic explosion (when HitHull > 0.9 & hullDamageCauseExplosion is set to 1) happens. First number is minimum time in seconds & 2nd - maximum

```cpp
hullExplosionDelay[] = { 10, 20 };
```

##### hullDamageCauseExplosion

Integer: Determines if vehicle explodes after HitHull is above 0.9

```cpp
hullDamageCauseExplosion = 1; // vehicle will explode if HitHull is above 0.9
```

#### I

##### icon

String: Default Value = "unknown_object.paa"

This value us used by the map editor to show the building or vehicle when editing. It is not normally visible during game play. (but can be)

The icon can be any jpg, paa, or pac file. paa is default. Note that Elite cannot handle jpegs.

```cpp
icon = "\AnyAddon\AnyPAA(.paa)";
```

Related TokenName(s): [#mapSize](../topics/CfgVehicles_Config_Reference.md#mapsize)

##### in/out

Float: These TokenNames are used inside the [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

```cpp
in = 0.0;
out = 0.0;
```

##### init

String: Event Handlers
The Event Handler receives an array **_this** (the exact content of which still has to be documented), of which the first element contains the vehicle (e.g. _this select 0).

```cpp
init = "[(_this select 0)] exec ""\AnyAddon\AnySqs.sqs""";
```

##### initT

Integer: This TokenName is used inside the [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

```cpp
initT = 1000;
```

##### initYSpeed

Float: This TokenName is used inside the [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

```cpp
initYSpeed = 1.7;
```

##### insideSoundCoef

Float: default 0.5

```cpp
insideSoundCoef = 0.05;    // air vehicles are 2%
```

##### interval

Float: This TokenName is used inside the [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

```cpp
interval = 0.01;
```

##### irScanGround

Boolean: Default true.

Probaly used to stop ai looking down

```cpp
irScanGround = false;    // tanks
```

##### irScanRange...

Integer: Default 0

```cpp
irScanRange = 4000;        // outdated (since Resistance)
irScanRangeMin = 500;    // tanks general
irScanRangeMax = 4000;
irScanRangeMin = 2000;    // air
irScanRangeMax = 10000;
irScanRangeMin = 4000;    // a vulcan
irScanRangeMax = 10000;
```

##### irScanToEyeFactor

Integer: Default 1

```cpp
irScanToEyeFactor = 2;    // air
irScanToEyeFactor = 5;    // shilka
```

##### irTarget

Boolean: Default true.

Used for (some) buildings so that they don't show up on tank radar. Save for very limited exceptions, this token should be enabled for all vehicle units.

Disabling it will make the vehicle NOT to be engaged by infantry anti-tank gunners nor vehicle weapons. It will only be engaged by small arms, and only if its armor value is low enough for AI infantry to think it can damage it by shooting at it.

```cpp
irTarget = false;    // man
```

##### isBicycle

Boolean: Default false.

this value inside the motorcycle class is used to turn it on when inheriting to a real bicycle

##### isMan

Boolean: Default true.

```cpp
isMan = 1;
```

Defined within the man class

#### K

##### killed

String: Event Handlers

```cpp
killed = "[(_this select 0), 1, 1, 0, 0] exec ""\AnyAddon\AnySQS.sqs""";    // note the ""
```

#### L

##### ladders

Embedded Array: The ladders array is used to declare one or more ladder pairs inside the model.

```cpp
ladders[] = { {"start", "end" } };                            // a building with one ladder
ladders[] = { {"start1", "end1" }, {"start2", "end2" } };    // two ladder building
// ...etc
```

Note that unfortunately, the 'start' and 'end' labels are arbitrary for *each* model. You cannot have a generic ladder building as such.

Since 1.79.143080 it is possible to define radius of action & component in geometry LOD. Action will be visible then when player is looking at selected component

```cpp
// { Starting point (memory LOD), Ending point (memory LOD), radius (in meters), Named Selection (geometry LOD) }
ladders[] = { { "Ladder_1_start", "Ladder_1_end", 2.5, "Ladder_1_action" }, { "Ladder_2_start", "Ladder_2_end", 2.5, "Ladder_2_action" }, { "Ladder_3_start", "Ladder_3_end", 2.5, "Ladder_3_action" } };
```

##### laser...

Boolean: Default false

Determines if a vehicle has laser capability.

```cpp
laserScanner = true;
laserTarget = true;    // used as a generic class of All {} to default things true
```

##### landingAoa

MathFormula String Default 10*3.1415/180

Landing Angle of Approach. Used by plane class

```cpp
landingAoa = 7*3.1415/180;    // Cessna
```

##### landingSpeed

Integer: Default 0 Kph.

```cpp
landingSpeed = 75;    // plane vehicles
```

##### library

String: This TokenName is associated with the library class of a vehicle (if any). It is used to give a 'memo' style full screen info on the given object. Example of use:

```cpp
class Library
{
    libTextDesc = "$STR_LIB_AH1Z";
};
```

##### LODDriverTurnedIn

Integer Defines the LOD that is to be used when the Driver is turned in. Value = -1 seems to default to the standard LOD (for Turret's that is Gunnerview).

```cpp
LODDriverTurnedIn = -1
```

Value:

- -1 = Default LOD
- 1 = first resolution LOD
- 1000 = Gunnerview
- 1100 = Pilotview
- 1200 = Cargoview.

##### LODDriverTurnedOut

Integer Defines the LOD that is to be used when the Driveris turned out. The same rules as with LODDriverTurnedIn apply.

```cpp
LODDriverTurnedOut = -1
```

#### M

##### magazine

Array: used in TransportMagazines class this specifies the type of ammo in the magazine and the amount.

```cpp
{
    magazine = "30Rnd_556x45_Stanag";
    count = "30*1";
}
```

Each of these couplets are contained within a 'weapon' classname within the magazine*S* class itself. Example

```cpp
class TransportMagazines
{
    class _xx_M16
    {
        magazine = "M16";
        count = 30 * 1;
    };
    class _xx_M60
    {
        // ...
    };
    class _xx_PK
    {
        // ...
    };
    // ...
};
```

##### magazines

Variable string Array: default {}

see [#weapons](../topics/CfgVehicles_Config_Reference.md#weapons) for proper description

##### mapSize

Float: Default Value = 10 (meters).

Used for the map editor to show the [icon](../topics/CfgVehicles_Config_Reference.md#icon) associated with this model class.

There is no x y component to this, the measurement units are meters.

To create a circular, rectangular or other 'non square' image, you need to make a pac file for the icon with, a transparent layer.

```cpp
mapSize = 0.7;    // small object such as a tree
mapSize = 4;    // a smallish building
```

The Mission Editor map is not very good in this regard (as noted above). However, the main problem is the base classes of the engine. The mapSize= for most objects, *particularly* buildings, is a one shoe fits all. A forest, eg, is the same mapSize= as a tree !!!

Later Oem addons, *generally* are better and more specific in this regard, making position and fitting a little easier.

##### marker

String : used as a core for all other air craft when looking on map.

```cpp
marker = "\AnyAddon\AnyP3d.(p3d")";
```

##### material

Integer:

Used in Hit... classes, eg HitTurret HitBody

```cpp
material = 50;
```

Related TokenNames: [#armor (float)](../topics/CfgVehicles_Config_Reference.md#armor-float), [#material](../topics/CfgVehicles_Config_Reference.md#material), [#name](../topics/CfgVehicles_Config_Reference.md#name), [#passThrough](../topics/CfgVehicles_Config_Reference.md#passthrough)

##### maximumLoad

The maximumLoad value defines the number of units of cargo storage.

```cpp
maximumLoad = 2000;
```

An item's storage value (the amount of space it takes up) is defined by it is mass value. For example:

```cpp
// CfgMagazines >> "Titan_AT"
mass = 100;
```

The following parameter are used by just Eden:

```cpp
transportMaxMagazines
transportMaxWeapons
transportMaxBackpacks
```

##### maxT

Integer: This TokenName is used inside the [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

```cpp
maxT = 0;
```

##### min/max

String Degrees Math Formula

```cpp
min = 0;
max = 60 / 3.6;
```

Note for readability, these values are *normally* expressed as strings which the engine itself will convert.

see [Indicator Class](../topics/CfgVehicles_Config_Reference.md#selection)

##### memoryPointExhaust...

String:

```cpp
memoryPointExhaust = "exhaust_start";
memoryPointExhaustDir = "exhaust_end";
```

##### memoryPointGun

String:

```cpp
memoryPointGun = "machinegun";
```

##### memoryPointGunnerOptics

String

```cpp
memoryPointGunnerOptics = "gunnerview";
```

##### memoryPointGunnerOutOptics

String

```cpp
memoryPointGunnerOutOptics = "commander_weapon_view";
```

##### memoryPoint...Missile

String:

```cpp
memoryPointLMissile = "Missile_1";
memoryPointRMissile = "Missile_2";
```

##### memoryPoint...Rocket

String:

```cpp
memoryPointLRocket = "Rocket_1";
memoryPointRRocket = "Rocket_2";
```

##### memoryPointsGetIn...

String:

```cpp
memoryPointsGetInCargo = "pos_cargo";
memoryPointsGetInCoDriver = "pos_codriver";
memoryPointsGetInCommander = "pos_commander";
memoryPointsGetInDriver = "pos_driver";
memoryPointsGetInGunner = "pos gunner";
```

###### memoryPointsGetIn...Dir

String:

```cpp
memoryPointsGetInCargoDir = "pos_cargo_dir";
memoryPointsGetInCoDriverDir = "pos_codriver_dir";
memoryPointsGetInCommanderDir = "pos_commander_dir";
memoryPointsGetInDriverDir = "pos_driver_dir";
memoryPointsGetInGunnerDir = "pos gunner dir";
```

##### memoryPointSupply

String:

```cpp
memoryPointSupply = "supply";
```

##### memoryPointTrack...

String:

```cpp
memoryPointTrackFLL = "tyreTrack_1_1l";
memoryPointTrackFLR = "tyreTrack_1_1r";
memoryPointTrackBLL = "tyreTrack_1_2l";
memoryPointTrackBLR = "tyreTrack_1_2r";
memoryPointTrackFRL = "tyreTrack_2_1l";
memoryPointTrackFRR = "tyreTrack_2_1r";
memoryPointTrackBRL = "tyreTrack_2_2l";
memoryPointTrackBRR = "tyreTrack_2_2r";
```

##### microMimics

String: Man class

This token refers to the class within the external cfgMimics class

```cpp
microMimics = "Micro";
```

##### minute

part of the IndicatorWatch class

see [#hour](../topics/CfgVehicles_Config_Reference.md#hour)

##### model

String: Default Value= "empty.p3d"

Location in the addon where the p3d model resides.

```cpp
model = "\AddonName\anyp3d(.p3d)";
```

Where a class is not a visible 'object', such as a BaseClass. You can specify

```cpp
model = "";
```

this cuts down on load and access.

Related TokenName: [#simulation](../topics/CfgVehicles_Config_Reference.md#simulation), [#reversed](../topics/CfgVehicles_Config_Reference.md#reversed)

##### moves

String: Default = "NoDefaultMoves"

applies to the man class and refers to a cfgMoves class

```cpp
moves = "CfgMovesMC";    // civilian, in fact, there isn't another
```

#### N

##### ...NightLights...

Float:

```cpp
spotableNightLightsOff = 0.05;    // default
spotableNightLightsOn = 4;        // default
visibleNightLightsOff = 0.1;    // default
visibleNightLightsOn = 0.2;        // default
```

##### name

String:

```cpp
name = "motor";
```

Used in Hit... classes, eg HitTurret HitBody

Related TokenNames: [#armor (float)](../topics/CfgVehicles_Config_Reference.md#armor-float), [#material](../topics/CfgVehicles_Config_Reference.md#material), [#name](../topics/CfgVehicles_Config_Reference.md#name), [#passThrough](../topics/CfgVehicles_Config_Reference.md#passthrough)

##### nameSound

String: Default value: "Target"

Namesound is used by the AI audio to indicate verbally where to go, what 'vehicle' to attack. Thus the audio speech "move to 'rock' 3 o'clock' is derived from the *nameSound*.

```cpp
nameSound = "rock";
```

Many different nameSounds can be selected. Here are just a few.

```cpp
nameSound = "crew";
nameSound = "target";
nameSound = "tank";
nameSound = "house";
```

The actual descriptive text accompanying the 'sound' can be different see [#displayName](../topics/CfgVehicles_Config_Reference.md#displayname)

Typically, a collection of buildings (eg) will be configured as follows

```cpp
class GenBuilding : NonStrategic
{
    scope = private; // internal use only
    VehicleClass = "Some Editor Group Name";
    nameSound = "house";
};
class YellowBuilding : GenBuilding
{
    scope = public;
    name = "YellowBuilding";
    model = "Some yellow building.p3d";
};
```

Related TokenNames
[#scope](../topics/CfgVehicles_Config_Reference.md#scope), [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy), [#displayName](../topics/CfgVehicles_Config_Reference.md#displayname), [#vehicleClass](../topics/CfgVehicles_Config_Reference.md#vehicleclass), [#nameSound](../topics/CfgVehicles_Config_Reference.md#namesound), [#camouflage](../topics/CfgVehicles_Config_Reference.md#camouflage)

##### noseDownCoef

Float: Default 1.0 used by Plane class

```cpp
noseDownCoef = 0.025;    // Cessna
```

How much the nose drops when banking.

*Note: Not used in ArmA any more*

##### nightVision

Boolean: Default false

```cpp
nightVision = true;
```

present in lawsoldier, sniper, saboteur, tank, and air crew

*Note: obsolete, not used, NVG item is used instead*

#### O

##### ...OpticsColor

Float Array : Default {0, 0, 0, 1};

```cpp
driverOpticsColor[] = { 0, 0, 0, 1 };
gunnerOpticsColor[] = { 0.910000, 0.230000, 0.230000, 1 };
commanderOpticsColor[] = { 0.910000, 0.230000, 0.230000, 1 };
```

##### ...OpticsModel

String: Default ""

```cpp
commanderOpticsModel= "\AnyPbo\AnyP3d(.p3d)";
driverOpticsModel = "\AnyPbo\AnyP3d(.p3d)";
gunnerOpticsModel= "\AnyPbo\AnyP3d(.p3d)";
```

##### gunnerOpticsShowCursor

Boolean

```cpp
gunnerOpticsShowCursor = true;
```

#### P

##### passThrough

Boolean: Default true

If true, destroying this part of the vehicle will destroy the whole vehicle. If false, damage will only affect this part of the vehicle.

This value is only taken into account in Arma 2. It was ignored by the game engine in previous games (that includes OFP).

```cpp
passThrough = 1;
```

Used in Hit... classes, eg HitTurret HitBody

Related TokenNames: [#armor (float)](../topics/CfgVehicles_Config_Reference.md#armor-float), [#material](../topics/CfgVehicles_Config_Reference.md#material), [#name](../topics/CfgVehicles_Config_Reference.md#name), [#passThrough](../topics/CfgVehicles_Config_Reference.md#passthrough)

##### picture

String: Default: iaston.paa

I think this is for briefing Information icon click

```cpp
picture = "\AnyAddon\AnyPAA(.paa)";
```

"Picture" is used in config.cpp to display the 128 x 64
graphic file of the unit in the HUD and the bottom
of the screen while in game. A .pac file can be used
also. If using a .pac make your alpha channel pink -
RGB 255, 0, 255. Pink is invisible in .pac file.

##### pilotLight

Boolean: Default: false

Default state of headlights on vehicle.

```cpp
pilotLight = true; // spawn vehicle with headlights on
```

##### position

String:

```cpp
position = "ohniste";
position = "L svetlo";
```

See [#Reflectors Class](../topics/CfgVehicles_Config_Reference.md#reflectors-class), [#Light Class](../topics/CfgVehicles_Config_Reference.md#light-class)

##### precision

```cpp
precision = 1;        // man
precision = 200;    // air
precision = 50;        // boat
```

##### ...preciseGetInOut

Integer: Defines location of getin point. 0 = use memoryPointGetIn , 1 = use model center as get in point, 2 = use proxy of crew position as get in point. Default is 0.

```cpp
preciseGetInOut = 0;        // for vehicle crew
cargoPreciseGetInOut = 0;    // for passengers
```

##### preferRoads

Boolean: Default false

```cpp
preferRoads = true;    // all vehicles
```

##### primary

Boolean: For models that can have, (but don't necessarily do have) multiple internal objects of the same type (turrets eg). One of them, is declared the main, or primary turret. There may indeed be only one 'turret'. (Note: this entry has been replaced by the **primary..**. entries. Please use those for your turret definitions to ensure maximal compatibility.)

```cpp
primary = true;
```

##### primary...

Boolean A vehicle can have multiple turrets, but one of them normally is the primary gunner turret and one the primary vehicle commander turret (this can be the same turret or two different turrets, but you cannot have several primary gunner or commander turrets). Please use these entries instead of the more general **primary** entry.

```cpp
primaryGunner = false;
primaryObserver = true;    // Commander
```

##### proxyIndex

Integer

```cpp
proxyIndex = 2;
```

##### proxyType

String

```cpp
proxyType = "CPCommander";
```

#### R

##### ...Radius

Float:

Represents a circular area (radius in meters from **centre** of object for action to take place

```cpp
getInRadius = 2.5;    // default
getInRadius = 3.5;    // tank
getInRadius = 10;    // ship

supplyRadius = 2.5;    // for fuel dumps ammo trucks etc
```

##### ...RotorSpeed

Float: Helicopters

```cpp
mainRotorSpeed = 1.0;    // default
backRotorSpeed = 1.5;    // default

mainRotorSpeed = 1.0;    // ch47d
backRotorSpeed = -1.0;
```

##### ...RotorDive

Float: Helicopters, Default 0.0

```cpp
minMainRotorDive = -9;    // CH47D
maxMainRotorDive = 15;
neutralMainRotorDive = -5;
minBackRotorDive = -15;
maxBackRotorDive = 9;
neutralBackRotorDive = -5;
```

##### ReloadAnimations Class

General useage in Helicopters, this class is 'looked for' by the engine. Various models, but normally only one, are specified as follows

```cpp
class ReloadAnimations
{
    class SomeThingA
    {
        // ...
    };
    // ...
    class SomeThingZ
    {
        // ...
    };
};
```

here is an example for an Mi24 helicopter

```cpp
class MachineGun30E
{
    weapon = "MachineGun30E";
    angle0 = 0;
    angle1 = -2 * 3.141592654;
    multiplier = 500;
    type = "rotation";
    animPeriod = 0.500000;
    selection = "gatling";
    begin = "usti hlavne";
    end = "konec hlavne";
};
```

##### rotL/R

defined within a tank.Wheels class to describe the series of small wheels on each side

```cpp
rotR[] = { kolL1, kolL2, kolL3, kolL4, kolL5, kolL6, kolL7, kolL8 };
rotL[] = { kolP1, kolP2, kolP3, kolP4, kolP5, kolP6, kolP7, kolP8 };
upDownL[] = { koloP1, podkoloP1, koloP2, podkoloP2, koloP3, podkoloP3, koloP4, podkoloP4, koloP5, podkoloP5, koloP6, podkoloP6, koloP7, podkoloP7, koloP8, podkoloP8 };
upDownR[] = { koloL1, podkoloL1, koloL2, podkoloL2, koloL3, podkoloL3, koloL4, podkoloL4, koloL5, podkoloL5, koloL6, podkoloL6, koloL7, podkoloL7, koloL8, podkoloL8 };
```

##### reversed

Boolean: Default true

Normally, models ARE reversed with respect to how they present on the screen after editing with tools like oxygen (eg) This overrides the default. See [#model](../topics/CfgVehicles_Config_Reference.md#model)

```cpp
reversed = false;    // class thing
```

##### rotor...

String: Helicopters

```cpp
rotorBig = "vrtule_velka";    // cobra
rotorBigBlend = "vrtule_velka_bl";
rotorSmall = "vrtule_mala";
rotorSmallBlend = "vrtule_mala_bl";
```

#### S

##### ...Sensitivity

Float: Default 1.0 Used by Plane Class

```cpp
aileronSensitivity = 0.33;        // Cessna
elevatorSensitivity = 0.1;        // Cessna
wheelSteeringSensitivity = 1.0;    // default
```

##### ...Simul/Plan

Float: in meters

```cpp
steerAheadSimul = 0.5;    // default
steerAheadPlan = 0.35;    // default
steerAheadSimul = 0.2;    // man
steerAheadPlan = 0.2;

predictTurnSimul = 1.2;    // default
predictTurnPlan = 1.2;    // default
predictTurnSimul = 3;    // ship
predictTurnPlan = 3;
```

##### scope

Integer: Default value is 0 (private).

```cpp
scope = 2;
```

Scope is used to limit access to the class in the Mission Editor (such as Eden Editor) and scripts. The value can be one of **0** (private), **1** (protected/hidden), and **2** (public).

[Defines](../topics/PreProcessor_Commands.md#define) normally exist at the top of a well written config.cpp to make meanings clearer.

```cpp
#define private 0
#define protected 1
#define public 2
```

The meaning of each is as follows

**private:**

No object can be created using this class, neither in Mission Editor nor via scripts. This property marks the class as a "base" class, which other classes inherit from.

private is a common method of grouping base characteristics together and inheriting all those common characteristics into a class that can be viewed or accessed.

**public:**

Public classes are usable in scripting commands (such as [createVehicle](../commands/createVehicle.md)) and can be shown in the Mission Editor.

**protected:**

Identical to public, except the class will not be listed in the Mission Editor. A very common form of use for this is

```cpp
class Vegetables
{
    scope = protected;
    VehicleClass = "Fruit and Onions";    // a generic group in mission editor
    displayName = "Generic Vegetable";
    namesound = "whatever";
    icon = "vegetableIcon.paa";
    // put any other common characteristics in here
};
class GreenOnions : Vegetables
{
    scope = public;
    displayName = "Green Onion";
}
class PurpleOnion : Vegetables
{
    ....
}
```

The effect here is to reduce (considerably) not only the amount of typing, but memory storage too.

It is only the public classes that are listed in the Mission Editor.

So in above example while each one of these has a separate *displayName=*, they are ALL 'grouped' in the Editor's "Fruit and Onions", and **all** of them will be referred to *in the mission* as "Generic Vegetable". If you follow along, you should fully expect to see another protected class called "Generic Fruit"

In the above example, it is just as useful to declare the base class '*private*. But, see below, and see [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy)

Protected classes are CamCreatable in the mission.sqm.

Protected classes are immensely useful to 'hide' obsolete models that are still required to maintain compatibility with older missions. Ie older missions will still be playable, but newly created ones will only 'get at' the newer improvements specified in a public class. This

```cpp
class OriginalThing
{
    scope = protected;
    // ...
    // lots of original things
    // ...
};
class ImprovedThing : OriginalThing // inherits it all
{
    scope = public;
    // ...
    // lots of new improved things
    // ...
};
```

Related TokenNames
[#scope](../topics/CfgVehicles_Config_Reference.md#scope), [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy), [#displayName](../topics/CfgVehicles_Config_Reference.md#displayname), [#vehicleClass](../topics/CfgVehicles_Config_Reference.md#vehicleclass), [#nameSound](../topics/CfgVehicles_Config_Reference.md#namesound), [#camouflage](../topics/CfgVehicles_Config_Reference.md#camouflage)

##### secondaryExplosion

Integer: Default disabled (-1)

```cpp
secondaryExplosion = -1;
```

##### sensitivity

Float: Default 1.0

```cpp
sensitivity = 0.6;    // cars
sensitivity = 2;    // sniper
```

The higher the sensitivity value for an unit, the better it can see.

The effect is not linear, but logarithmic. So for an unit with value 1 vs one with value 3 it must be 1.7 times closer (square root of 3). This example does not take into account other factors like zoom, binocular use, optics, camouflage and accuracy (knowsAbout value needed to detect the type and side).

1 equals roughly to 100 meters, 2.5 to 210m, 3 to 250m.

OA 1.62 state:

```cpp
class All
    sensitivity = 2.5;
    sensitivityEar = 0.0075;
class AllVehicles : All
class Land : AllVehicles
class LandVehicle : Land
class Car : LandVehicle
    sensitivity = 3;
class Motorcycle : LandVehicle
    sensitivity = 3;
class Bicycle : Motorcycle
class Tank : LandVehicle
    sensitivityEar = "0.0075 /3";
class APC : Tank
class Man : Land
    sensitivity = 3;
    sensitivityEar = 0.5;
class Animal : Man
class Air : AllVehicles
class Helicopter : Air
class Plane : Air
class Ship : AllVehicles
class AH6X_EP1 : AH6_Base_EP1
    sensitivity = 2;
class Ka137_Base_PMC : Helicopter
    sensitivity = 2;
```

##### sensitivityEar

Float: Default 0.0075

Sets how well can the given unit hear others.
The bigger the value, the better the hearing.

```cpp
sensitivityEar = 0.13;    // man
```

##### selection

String:

```cpp
selection = "L svetlo";
```

See [#Reflectors Class](../topics/CfgVehicles_Config_Reference.md#reflectors-class), [#ReloadAnimations Class](../topics/CfgVehicles_Config_Reference.md#reloadanimations-class) (Arma Only), [#Hatch... Class](../topics/CfgVehicles_Config_Reference.md#hatch-class), [#Indicator Class](../topics/CfgVehicles_Config_Reference.md#indicator-class)

##### selection...

String:

```cpp
selectionBackLights = "light_back";
selectionBrakeLights = "light_brake";
selectionFireAnim = "muzzleflash";
selectionHRotorStill= "mainRotorStatic";
selectionHRotorMove = "mainRotorBlurred";
selectionVRotorStill = "tailRotorStatic";
selectionVRotorMove = "tailRotorBlurred";
selectionFabric = "latka";
```

The selections

```cpp
selectionLeftOffset = "PasOffsetL";
selectionRightOffset = "PasOffsetP";
```

are used to animate tank track textures. You must have the appropriate Named Selections in the model and the selection must have an rvmat in order to work.

##### shape

Float: This TokenName is used inside the [#Light Class](../topics/CfgVehicles_Config_Reference.md#light-class)

```cpp
shape = "koulesvetlo";
```

See [#Light Class](../topics/CfgVehicles_Config_Reference.md#light-class), [#Reflectors Class](../topics/CfgVehicles_Config_Reference.md#reflectors-class)

##### showgunneroptics

Boolean:

```cpp
showgunneroptics = 0;
```

##### showWeaponCargo

Boolean:Default ?

```cpp
showWeaponCargo = true;
```

Found inside weapon holders (ammo boxes)\
OFP: If it is set to true player won't be able to put weapons/magazines to container.

##### sound

String:
Used by animated objects (campfire eg) to give sound effect. Or, simply by ambients(wolves)

```cpp
sound = "Fire";
sound = "Fountain";
sound = "OwlSfx";
```

##### SoundEnvironExt Class

class SoundEnvironExt

This is a Class used within the man class. Some/ None, or all sections of it can (of course) be overridden by inheritance.

The external class **CfgManActions** accesses the **SoundEnvironExt** class defined (or inherited) for any 'man' (soldier eg).

External class **CfgManActions** contains many clauses

```cpp
soundOverride = "fallbody";    // e.g
```

for instances of when it wants sounds for that 'action' to take place.

thus, you can define none some or all arrays (within class with your SoundEnvironExt{}) for the following

```cpp
normalExt[] =
normal[] =
road[] =
rock[] =
water[] =
gravel[] =
sand[] =
drygrass[] =
grass[] =
forest[] =
mud[] =
wood[] =
metal[] =
snow[] =
hallway[] =
fallbody[] =
laydown[] =
standup[] =
crawl[] =
```

Example

```cpp
snow[] = {
    { "People\snow_L", 0.000032, 1 },
    { "People\snow_R", 0.000032, 1 }
};
```

snow is a Variable length Sound Array

see [sounds\[\]](../topics/CfgVehicles_Config_Reference.md#sounds-various)

##### Sounds Various

Complex Array:

All the following use

```cpp
nameOfSound[] = { "\AddonName\AnySound(.wss)", 0.000000, 1, 1 };
```

- 1st parameter: Sound file (path). *.wss is default, *.ogg can be specified.
- 2nd parameter: Change of volume compared to the strongest sound that is audible at the camera's (player's) position. It means that the strongest sound is played on 100% and this sound is played weaker (calculated from dB value, distance, occlude, ...). If this sound is alone in sound scene then it is played on 100% every time.
- 3rd parameter: Speed of playing, 1 = normal speed/time of playing, 2 = 2 times slower, with half lower pitch.

###### ...Sound

```cpp
flySound[] = { "\AddonName\AnySound.wss", 0.000000, 1, 1 };
singSound[] = { "\AddonName\SoundFile.ogg", 0.031623, 1, 1 };
scudSound[] = { "weapons\rocketflying", 316.227783, 0.200000 };
scudSoundElevate[] = { "vehicles\gun_elevate", 0.010000, 1 };
```

###### sound...

```cpp
soundCrash[] = { "\AnyAddon\AnySound(.wss)", 0.010000, 1 };
soundSetSonicBoom[] = { "Plane_Fighter_SonicBoom_SoundSet" }; // Sonic Boom for jet fighters at supersonic speeds; defined in cfgSoundSets
```

default values

```cpp
soundCrash[] = { "Vehicles\crash", 0.316228, 1 };
soundDammage[] = { "", 1, 1 };
soundEngine[] = { "", 1, 1 };
soundEnviron[] = { "", 1, 1 };
soundLandCrash[] = { "Explosions\intoground", 0.316228, 1 };
soundWaterCrash[] = { "Explosions\intowater", 0.316228, 1 };
soundGetIn[] = { "Vehicles\get_in", 0.000316, 1 };
soundGetOut[] = { "Vehicles\get_out", 0.000316, 1 };
soundServo[] = { "Vehicles\gun_elevate", 0.010000, 0.500000 };
soundGear[] = { "\AnyAddon\AnySound(.wss)", 0.316228, 1 };            // no default
additionalSound[] = { "\AnyAddon\AnySound(.wss)", 0.000000, 1 };    // man only
```

###### sound[]

used by animations

```cpp
sound[] = { "\anyPbo\AnySound(.wss)", 10.000000, 1 };
```

##### side

Integer: Default Value: NEUTRAL.

The side, when declared, sets the 'vehicle' to east, west, resistance, civilian. The effect differs according to the 'vehicle' itself. Eg soldiers, versus hospitals or repair trucks that can only be used by same side, if specifically sided.

Well written missions (and configs) use defines at top of file to make this more legible.

```cpp
#define NO_SIDE -1
#define EAST 0            // (Russian)
#define WEST 1            // (NATO)
#define RESISTANCE 2    // Guerilla
#define CIVILIAN 3
#define NEUTRAL 4
#define ENEMY 5
#define FRIENDLY 6
#define LOGIC 7

side = EAST;
```

NEUTRAL is the general case for all objects.

NO_SIDE is used for ambient seagulls and wolves (see [#sound](../topics/CfgVehicles_Config_Reference.md#sound)). It differs from NEUTRAL in that the engine spends no time looking for interraction with other objects.

##### simulation

String: Default value: invisible.

The engine behaviour with this [#model](../topics/CfgVehicles_Config_Reference.md#model).

```cpp
simulation = "SeaGull";
simulation = "thing";
simulation = "fire";
simulation = "flag";
simulation = "house";
// simulation = airplane, helicopter, tank
```

Related TokenName: [#model](../topics/CfgVehicles_Config_Reference.md#model)

##### size

Float: This TokenName is used inside the Smoke class and Reflector class

```cpp
size = 0.1;
```

part of [Reflectors class](../topics/CfgVehicles_Config_Reference.md#direction)

##### source

String: found in animationSources

```cpp
source = "reload";
source = "time";
```

##### sourceAddress

String: found in animationSources

```cpp
sourceAddress = "loop";
```

##### sourceSize

Float: This TokenName is used inside the [#Light Class](../topics/CfgVehicles_Config_Reference.md#light-class)

```cpp
sourceSize = 0.015;
```

##### ...Speed

Float: In Kph.

Setting maxSpeed for infantry units too low might cause problems when working with waypoints (units won't be able to fully complete them or won't move towards them).

```cpp
minSpeed = -0.5;    // range 0->1
maxSpeed = 80;        // default
maxSpeed = 30;        // tractor
maxSpeed = 60;        // boat
```

##### scud...

String: Default ""

```cpp
scudLaunch = "scudlunch.rtm";
scudStart = "scudstart.rtm";
scudModel = "scud_strela_proxy";
scudModelFire = "scud_strela_ohen";
```

##### straightDistance

Integer:

```cpp
straightDistance = 50;
```

##### submerged..

Float: default 0.0

Almost all 'objects' are **not** submerged. This parameter is used to hide objects such as effects

```cpp
submerged = -0.5;        // thing effect
submergeSpeed = 0.25;    // positive value makes it go deeper (sound goes quieter)
```

#### T

##### ...Turn

Integer Degrees

```cpp
initTurn = 90;
minTurn = -70;
maxTurn = 70;
```

part of any Turret class (tanks eg)

see[#gun](../topics/CfgVehicles_Config_Reference.md#gun)

##### TokenNames Embedded

see [#Embedded ClassNames](../topics/CfgVehicles_Config_Reference.md#embedded-classnames)

###### turning

Boolean:

```cpp
turning = 1;
```

###### turnCoef

Float: Default 2.0

```cpp
turnCoef = 6.0;    // truck
turnCoef = 9.0;    // tractor
```

##### terrainCoef

Float: Default 3.0

- Pre A3: multiplier to torque and speed (pForce)
- A3: multiplier to maxSpeedCoef (1 - maxSpeedCoef) [cfgSurfaces parameter] for speedCoef

```cpp
Pre A3::
        terrainCoef = 6.0;    // skoda
---
A3:
    class Car_F : Car
        terrainCoef = 2;

    class MRAP_03_base_F : Car_F
        terrainCoef = 1;
    class UGV_01_base_F : Car_F
        terrainCoef = 1.2;
    class Quadbike_01_base_F : Car_F
        terrainCoef = 1.4;
    class MRAP_01_base_F : Car_F
        terrainCoef = 1.5;
    class MRAP_02_base_F : Car_F
        terrainCoef = 1.5;
    class SUV_01_base_F : Car_F
        terrainCoef = 2.5;
    class Hatchback_01_base_F : Car_F
        terrainCoef = 4.5;
    class Kart_01_Base_F : Car_F
        terrainCoef = 5;

    class Truck_F : Car_F
        terrainCoef = 2.5;

    class Truck_03_base_F : Truck_F
        terrainCoef = 1.8;
    class Truck_02_base_F : Truck_F
        terrainCoef = 2;
    class Van_02_base_F : Truck_F
        terrainCoef = 3;

    class Wheeled_APC_F : Car_F
        terrainCoef = 1.5;
```

##### textureList[]

Complex (string, float) Array

Introduced with Arma 3 v1.24, the Bootcamp Update, along with a lot of other randomization features.

Array of texture sources to randomize the vehicle with similar to facewear/headgear randomization for characters (See [Arma 3: Characters And Gear Encoding Guide#FIA headgear and facewear randomization](../topics/Characters_And_Gear_Encoding_Guide.md#fia-headgear-and-facewear-randomization)); format is:

```cpp
textureList[] = { "texture1", weight1, "texture2", weight2, etc. };
```

Textures must be classes from the vehicle's TextureSources. If all the weights are the same value, it functions as straight equal randomization.

Example:

```cpp
class MyPlane : C_Plane_Civil_01_F
{
    textureList[] = { "Racer_1", 0.5, "Racer_2", 1 };
};
```

##### threat

float Array: Default Value {0.700000, 0.500000, 0.300000};

How threatening you are to unit [types](../topics/CfgVehicles_Config_Reference.md#type-threat) {Soft, Armor, Air}, respectively.

The ai for this model selects targets of opportunity, based on these values.

```cpp
threat[] = { 1, 0.0500000, 0.050000 };            // soldier
threat[] = { 1, 0.900000, 0.100000 };            // law soldier
threat[] = { 0.900000, 0.700000, 0.300000 };    // bmp
```

Related TokenNames: [type](../topics/CfgVehicles_Config_Reference.md#type-threat), [#cost](../topics/CfgVehicles_Config_Reference.md#cost), [#threat](../topics/CfgVehicles_Config_Reference.md#threat)

##### timeToLive

Float: Default 10 000 000 000.0; // seconds?

```cpp
timeToLive = 20;    // thing effects (bullets)
timeToLive = 100000002004087730000.0;    // campfire
```

See [#Smoke Class](../topics/CfgVehicles_Config_Reference.md#smoke-class)

##### transport...

###### transportAmmo

Integer: Used by supply 'vehicles' to determine total amount available for entire mission. Once depleted...

A 'vehicle' in this case can be a genuine repair truck, or, a building.

```cpp
transportAmmo = 300000;            // reammo truck
transportAmmo = 10000000;        // bigship

transportFuel = 3000;            // refueltruck
transportRepair = 200000000;    // repairtruck
```

###### transportMax...

These parameters appear not to be used in Arma 3 and are only included for backwards compatibility. See [maximumLoad](../topics/CfgVehicles_Config_Reference.md#maximumload) to define a vehicle's storage capacity.

```cpp
transportMaxMagazines = 50;        // car
transportMaxWeapons = 10;
transportMaxMagazines = 5;        // motorcycle
transportMaxWeapons = 0;
transportMaxMagazines = 50;        // tank
transportMaxWeapons = 10;
transportMaxMagazines = 20;        // air
transportMaxWeapons = 3;
transportMaxMagazines = 100;    // boat
transportMaxWeapons = 20;
transportMaxMagazines = 500;    // ship
transportMaxWeapons = 200;
transportMaxMagazines = 200;    // truck
transportMaxWeapons = 50;
transportMaxMagazines = 100;    // apc
transportMaxWeapons = 20;
transportMaxMagazines = 200;    // helicopter
transportMaxWeapons = 50;
transportMaxWeapons = 500;        // ammo boxes
transportMaxMagazines = 2000;
```

Values vary depending on exact type of 'boat' eg.

These TokenNames ate used to indicate how many units of each type an object can hold. Most objects can't hold anything.

###### transportSoldier

Integer: Default Value= 0.

Number of 'passengers' this vehicle can carry. The value does **not** include the driver, **nor** any vehicle positions such as gunner (if any) or commander(if any). See the JeepMg below for a 3 person vehicle which can only transport ONE soldier.

```cpp
transportSoldier = 3;        // jeep/car
transportSoldier = 50;        // large ship
transportSoldier = 6to10;    // SmallShip
transportSoldier = 3;        // a10
transportSoldier = 8to12;    // helicopters
transportSoldier = 2or3;    // ambulance
transportSoldier = 8;        // apc/bmp
transportSoldier = 12;        // truck
transportSoldier = 1;        // jeepmg
transportSoldier = 1or2;    // repair type truck
```

to make the game 'interesting', similar vehicles on different sides, can carry non equivalent numbers.

##### transportVehiclesCount

Integer : default 0

```cpp
transportVehiclesCount = 15; // a Carrier (big ship)
```

##### TransportMagazines Class

##### transportVehiclesMass

Integer: Default 0

```cpp
transportVehiclesMass = 0;    // not used by any model
```

##### TransportWeapons Class

##### tracksSpeed

Integer: Default 1

Speed of tracks UV animation. Use negative number to move tracks in opossite direction

```cpp
tracksSpeed = 1.4;
```

##### TransportWeapons Class

##### turretAxis

String:

```cpp
turretAxis = "OsaVeze";
```

see [#Turret Class](../topics/CfgVehicles_Config_Reference.md#turret-class)

##### type (threat)

Integer: Default Value: Armored

This indicates the threat type of the 'vehicle'.

In well written configs, the 3 possible values are declared as defines at top of file for legibility

```cpp
#define VSoft 0
#define VArmor 1
#define VAir 2

type = VAir;
```

Vehicles (and buildings) are armoured, humans are 'soft' and aircraft (obviously) are air

Related TokenNames: [type](../topics/CfgVehicles_Config_Reference.md#type-threat), [#cost](../topics/CfgVehicles_Config_Reference.md#cost), [#threat](../topics/CfgVehicles_Config_Reference.md#threat)

##### type (animation)

**old** Unknown: Default Value: rotation

This appears in the ReloadAnimations class

```cpp
type = "rotation";
```

##### typicalCargo

Variable String Array:Array of units classes which are assumed to be onboard of vehicle. Used by AI to determine potential threat of vehicle in case they are not able to see units inside vehicle.

This array can have zero or more strings.

```cpp
typicalCargo[] = { "Soldier", "Soldier", "SoldierLAW", "SoldierLAW" };
```

Note that these are *ClassNames* of soldiers.

#### U

##### ...UsesPilotView

Boolean: : Default false

```cpp
gunnerUsesPilotView = false;    // some choppers (mi17)
commanderUsesPilotView = true;
```

##### uavHacker

Boolean\
Allows unit to hack UAVs. Used on UAV operators in vanilla (Arma 3)

```cpp
uavHacker = 1;
```

##### unitInfoType

String

```cpp
unitInfoType = "UnitInfoSoldier";
```

Certain 'vehicles' hide this information.

see [#hideUnitInfo](../topics/CfgVehicles_Config_Reference.md#hide)

##### unloadInCombat

Boolean: default true

```cpp
unloadInCombat = false;
```

All true vehicles will cause ai to disembark when in combat.

##### upDownL/R

wheels class
see [#rotL/R](../topics/CfgVehicles_Config_Reference.md#rotl-r)

#### V

##### vehicleClass

String: Default Value= "Objects"

Used for Mission Editor basic category selection

```cpp
vehicleClass = "Air";
vehicleClass = "Support";
vehicleClass = "My Great Addon";
```

Related TokenNames
[#scope](../topics/CfgVehicles_Config_Reference.md#scope), [#accuracy](../topics/CfgVehicles_Config_Reference.md#accuracy), [#displayName](../topics/CfgVehicles_Config_Reference.md#displayname), [#vehicleClass](../topics/CfgVehicles_Config_Reference.md#vehicleclass), [#nameSound](../topics/CfgVehicles_Config_Reference.md#namesound), [#camouflage](../topics/CfgVehicles_Config_Reference.md#camouflage)

##### vehicleClass[]

String Array:

```cpp
vehicleClass[] = { "Men", "Car", "Armored", "Air", "Support", "Camera", "Objects", "Ammo", "Sounds", "Mines" };
```

##### view...Shadow

Boolean:

```cpp
viewCargoShadow = true;
viewGunnerShadow = true;
```

##### viewDriverInExternal

Boolean: default false

```cpp
viewDriverInExternal = true;    // Show the driver in third person view
```

##### viewGunnerInExternal

Boolean: default false

```cpp
viewGunnerInExternal = true;    // for some turrets and M113
```

#### W

##### ...WaterEffect

String

Defines the effect that will be spawned at the position of the LandContact points when vehicle is in/on the water.

```cpp
leftWaterEffect = "vbs2_fx_lowWaterEffects";
rightWaterEffect = "vbs2_fx_lowWaterEffects";
```

see [#...DustEffect](../topics/CfgVehicles_Config_Reference.md#dusteffect)

##### weapon

String:

```cpp
weapon = "M197";
```

Selects a weapon from the CfgWeapons class

##### weapons

Variable String Array: default {};

Weapons and Magazines contain individual description of what a 'vehicle' IS carrying.

```cpp
weapons[] = { "FFARLauncher", "TwinM134" };    // aircraft
weapons[] = { "CarHorn" };    // truck

weapons[] = { "M21", "LAWLauncher", "Throw", "Put" };    // soldier
magazines[] = { "M21", "M21", "M21", "M21", "HandGrenade", "HandGrenade", "LAWLauncher" };
```

The amount of weapons (and magazines) that can be carried by the 'man' is determined by [#weaponSlots](../topics/CfgVehicles_Config_Reference.md#weaponslots)

The names M21, Carhorn etc are external references to the cfgWeapons / cfgMagazines classes

##### weaponsGroup

Integer:

The weapons grouping for a vehicle, determined by enumerated weapon category definitions.

```cpp
weaponsGroup1 = WEAPONGROUP_CANNONS + WEAPONGROUP_MGUNS;                                // Adds Cannons and Machine Guns to Weapons Group 1
weaponsGroup2 = WEAPONGROUP_ROCKETS;                                                    // Adds Rockets to Weapons Group 2
weaponsGroup3 = WEAPONGROUP_AAMISSILES + WEAPONGROUP_ATMISSILES + WEAPONGROUP_MISSILES; // Adds All Missile types to Weapons Group 3
weaponsGroup4 = WEAPONGROUP_BOMBS + WEAPONGROUP_SPECIAL;                                // Adds Bombs and Laser Designators to Weapons Group 4
```

```cpp
#define WEAPONGROUP_CANNONS        1    // Cannons
#define WEAPONGROUP_MGUNS        2    // Machine Guns
#define WEAPONGROUP_ROCKETS        4    // Rockets
#define WEAPONGROUP_AAMISSILES    8    // Anti-Air Missiles
#define WEAPONGROUP_ATMISSILES    16    // Anti-Tank Missiles
#define WEAPONGROUP_MISSILES    32    // All / Other Missiles
#define WEAPONGROUP_BOMBS        64    // Bombs
#define WEAPONGROUP_SPECIAL        128    // Laser Designator + Misc
```

##### weaponSlots

Integer:

Weaponslots apply to man class (soldier, civilian, etc)

It indicates the 'gear' capacity.

```cpp
weaponSlots = 1 + 4 + 12 * 256 + 2 * 4096 + 2 + 8 * 16;    // all soldiers/civilians
weaponSlots = 1 + 4 + 8 * 256 + 2 * 4096 + 2 + 4 * 16;    // medics

// 1 = primary weapon
// 2 = handgun slot
// 4 = secondary weapon (launcher)
// 16 = handgun magazines (8x)(or grenades for M203/GP-25)
// 256 = magazine slots (12x / 8x for medics)
// 4096 = goggle slot (2x)
// 131072 = ?
```

##### wheelCircumference

Float Default 2.513 meters

```cpp
wheelCircumference = 8;    // tractor
```

##### wounds

string Array:

```cpp
wounds[] = { "xicht_a.paa", "xicht_a_zranen", ... };
```

this token is used in the man class to show a series of pac/paa files depending on damaged state of the body.

<sub>Source: [BI Community Wiki — CfgVehicles Config Reference](https://community.bistudio.com/wiki/CfgVehicles_Config_Reference) (revision 378791).</sub>