Arma Reforger:Scripting: Values

A value describes a data holder; a value is either a variable (that can be changed) or a constant (that cannot be changed).

Values are declared in Enfusion with a type, in format type identifier = value (= value being optional). Enfusion Script uses strong types, which means a value's type cannot be changed along its lifetime.

Identifier

An identifier is the actual name of a value; it identifies the value. The naming rules are:

• an identifier can be composed of ASCII letters, numbers and underscores
• an identifier must start with an underscore or a letter (cannot start with a number)
• an identifier is case-sensitive
• an identifier cannot be identical to a keyword

The regular expression to be respected is: ^[a-zA-Z_][a-zA-Z0-9_]*$

It is recommended to write variable identifiers in camelCase, (e.g aNewVariable) and constants' in UPPER_CASE (e.g A_NEW_CONSTANT). See Arma Reforger Variable Conventions for naming conventions.

int myNumber = 10; int _myNumber = 10; int myNUMBER = 10; // different from myNumber int 1number = 1; // wrong - starts with a number int my#variable = 1; // wrong - contains a character that is not letter/number/underscore int auto = 1; // wrong - the "auto" keyword exists and cannot be replaced

Value Declaration

Declaring a value is done by using a type and an identifier:

int myNumber; // variable myNumber is declared and auto-initialised to 0 myNumber = 10; // myNumber is now 10

It can also be directly created with a value:

int myNumber = 10;

const

A value can be made constant, meaning that it will remain the same along its lifetime.

string value1 = "value"; // value1's value is "value" const string CONST_VALUE = "value"; value1 = "new value"; // value1 is now "new value" CONST_VALUE = "new value"; // error: cannot modify a const value

An object (array, set, map, other class instance) can be const yet still have its values changed - const here only keeps the reference and does not "freeze" the object in place.

const ref array<string> STRINGS = {}; STRINGS.Insert("Hello there"); // OK: the array remains the same, its content is changed STRINGS = null; // error: cannot modify a const value

Passing a Value

By Content

// integers (whole numbers) are passed by content int myVar1 = 33; int myVar2 = myVar1; // myVar2 is 33 - it copied myValue1's content myVar2 = 42; // myVar2 is now 42, myVar1 is still 33 - they are two different values

By Reference

// arrays (list of values) are passed by reference array<int> myArray1 = { 0, 1, 2, 3 }; array<int> myArray2 = myArray1; // myArray2 targets myArray1 object - value is not copied but referenced myArray2[0] = 99; // myArray1 is now { 99, 1, 2, 3 };

Types

Values can be of various types, listed below.

Notions:

• Passed by: content or reference - see above
• Naming prefix: used in Object's (member) variable convention: m_prefixVariableName (e.g: m_bPlayerIsAlive = true)
• Default value: the default value given when a value is declared without content (e.g: int value - the variable here is 0, integer's default value)

Incorrect	Correct
bool variable = true; if (variable) { variable = "it works!"; // not - variable is and remains a boolean Print(variable); }	bool variable = true; if (variable) { string display = "it works!"; // correct Print(display); }

Primitive Types

Type name	C++ equivalent	Range	Default value	Size (Bytes)
int	int32	-2,147,483,648 through +2,147,483,647	0	4
float	float	±1.18E-38 through ±3.402823E+38	0.0	4
bool	bool	true or false	false	4
string	char*	-	"" (empty string)	8 (pointer) + (length × 1 byte)
vector	float[3]	like float	{ 0.0, 0.0, 0.0 }	8 (pointer) + (3 × float) 12*
void	void	-	-	-
class	Instance*	pointer to any script object	null	8
typename	VarType*	pointer to type structure	null	8

*the asterisk in C++ means a pointer.

Boolean

Passed by: value

Naming prefix: b

Default value: false

A boolean is a value that can be either true or false . For example, boolean result = 10 > 5; result can either be true or false.

Example:

bool myValue; // myValue is false myValue = 10 > 0; // myValue is true

Integer

Passed by: value

Naming prefix: i

Default value: 0

Range: -2,147,483,648 to 2,147,483,647

Description: An integer (or int) is a whole number, meaning a value without decimals. It can be positive or negative.

Example:

int myValue; // myValue is 0 myValue = 20; // myValue is 20 myValue /= 3; // myValue is 6: 20 / 3 = 6.666… which gets floored to 6 (and not rounded)

Float

Passed by: value

Naming prefix: f

Default value: 0.0

Range: 1.18 E-38 to 3.40 E+38

A float, or its full name floating-point number is a number that can have decimals.

Precision is a matter at hand when working with floats; do not expect exact calculations: 0.1 + 0.1 + 0.1 != 0.3 - rounding would be needed to have the result one can expect.

ⓘ

The further away from 0 the float value is, the less precision it has.
For "almost equal" comparison, see float.AlmostEqual; the default accepted difference (epsilon) is 0.0001 (1/10000) and can be set for each operation as an optional third argument.

Example:

float myValue; // myValue is 0 (or 0.0) myValue = 1; // myValue is 1 (or 1.0) myValue /= 3; // myValue is 0.333333… float originalValue = 1; float divisionResult = originalValue/3333; float result = divisionResult * 3333; originalValue == result; // returns false due to floating point precision float.AlmostEqual(originalValue, result); // returns true

String

Passed by: value

Naming prefix: s

Default value: "" (empty string)

Maximum length: 2,147,483,647 characters

Description: a string is a sequence of characters; it supports the following escape characters: \n (line return) \r (caret return) \t (horizontal tabulation) \\ (antislash) \" (double quote).

ⓘ

• A string cannot be null
• String comparison is case-sensitive; e.g
  "abc" != "ABC"

Example:

string username; // username is "" (empty string) username = "Player 1"; // username is "Player 1";

Enum

Passed by: value

Naming prefix: e

Default value: 0 (which may not exist in the enum)

An enum is a value that offers a choice between defined options.

"Behind the curtains" it is also an integer that can be assigned to an int variable.

Examples:

enum EHealthState { ALIVE, INJURED, UNCONSCIOUS, DEAD, }; EHealthState healthState; // healthState is ALIVE (0) healthState = EHealthState.UNCONSCIOUS; // healthState is UNCONSCIOUS (4) int myValue = EHealthState.ALIVE; // valid

By default, the first value is equal to 0 and the next values are incremented by 1.

enum EHealthState { ALIVE = 42, INJURED, // equals 43 UNCONSCIOUS = 50, DEAD, // equals 51 }; EHealthState healthState; // healthState is 0 (no corresponding enum) healthState = EHealthState.INJURED; // healthState is 43 (INJURED) int myValue = EHealthState.ALIVE; // 42

// an enum value can also be defined through bit shifting for e.g flag usage enum ELifeStatus { HEALTHY = 1 << 0, // 1 HAS_HOUSE = 1 << 1, // 2 HAS_FOOD = 1 << 2, // 4 };

Vector

Passed by: value

Naming prefix: v

Default value: { 0, 0, 0 }

A vector is a type that holds three float values. Two vectors can be compared with == for value comparison.

Example:

// there are three ways to create a vector vector myVector; // myVector is { 0, 0, 0 } vector myVector = { 0, 1.5, 2 }; vector myVector = "0 1.5 2"; vector otherVector = "0 1.5 2"; myVector == otherVector; // true // edition of one vector value vector myVector2 = myVector; myVector[1] = 42; // myVector is now { 0, 42, 2 } myVector == myVector2; // false // edition of the whole vector myVector2 = { 0, 42, 2 }; // syntax "0 42 2" works too myVector == myVector2; // true

Array

Passed by: reference (dynamic array) or value (static array)

Naming prefix: a

Default value: null (not an empty array)

Maximum size:

An array is a list of values. In Enforce Script, an array can only hold one type of data (defined in its declaration).

There are two types of array in Enfusion:

• dynamic array: "list" that will extend the more items are added
• static array: fixed-size list of items - items can be changed, but the array size cannot

Example:

array<string> dynamicArray = {}; string staticArray[2] = { "Hello", "" }; dynamicArray.Insert("Hello"); // dynamicArray = { "Hello" }; dynamicArray.Insert(""); // dynamicArray = { "Hello", "" }; dynamicArray[1] = "there"; // dynamicArray = { "Hello", "there" }; staticArray[1] = "there"; // staticArray = { "Hello", "there" }; // dynamic/static arrays cannot be directly compared for values; == would compare pointers (a.k.a is it the same array, not the same values) dynamicArray == staticArray; // false dynamicArray[0] == staticArray[0]; // true dynamicArray[1] == staticArray[1]; // true

Set

Passed by: reference

Naming prefix: none

Default value: null (not an empty set)

A set is a list that ensures uniqueness of values. Due to this uniqueness check, item insertion is slower than for an Array; however, checking if an item is contained is faster.

Example:

set<string> setInstance = new set<string>(); setInstance.Insert("Hello there"); setInstance.Insert("General Kenobi"); setInstance.Insert("Hello there"); // setInstance will still only contain "Hello there" and "General Kenobi" setInstance.Get(0); // the values order is never guaranteed as it can change on value insertion!

Map

Passed by: reference

Naming prefix: m

Default value: null (not an empty map)

A map is a list of key-value pairs, also known as a dictionary. Two keys cannot be identical as they are used to index the values.

A float cannot be a map key.

Example:

map<int, string> mapInstance = new map<int, string>(); mapInstance.Set(5712, "Hello there"); mapInstance.Set(5716, "General Kenobi"); mapInstance.Get(5712); // returns "Hello there" mapInstance.Get(5715); // /!\ returns "" (default string) mapInstance.Get(5716); // returns "General Kenobi" mapInstance.GetKeyByValue("Hello there"); // returns 5712 mapInstance.GetKeyByValue("test"); // /!\ returns 0 (default int) mapInstance.Contains(5716); // true mapInstance.ReplaceKey(5716, 5715); // replaces "General Kenobi" key mapInstance.Contains(5716); // false mapInstance.Contains(5715); // true mapInstance.Remove(5715); // removes "General Kenobi" from the map mapInstance.Contains(5715); // false

Class

Passed by: reference

Naming prefix: none

Default value: null

A class is what defines an object's structure - said from the other end, an object is an instance of a class.

ⓘ

For more information on classes and Object Oriented Programming, see Object Oriented Programming Basics and Object Oriented Programming Advanced Usage.

Example:

class ObjectClass { protected int m_iHealth = 100; int getHealth() { return m_iHealth; } bool setHealth(int health) { if (health < 0 || health > 100) { return false; } m_iHealth = health; return true; } } void HealthMethod() { ObjectClass myObjectInstance; // myObjectInstance is null myObjectInstance = new ObjectClass(); int objectHealth = myObjectInstance.getHealth(); Print(objectHealth); }

Typename

Passed by: reference

Naming prefix: none

Default value: null

A typename is class information (WIP: talk about reflection?)

Example:

class ObjectClass { int Health = 100; } typename t; // t is null t = ObjectClass; string classname = TypeName(t); // returns "ObjectClass"; t = Type(classname); // returns ObjectClass typename too

Scope

A value has a lifetime, whether it is the game instance, mission or script duration; but it also has a scope that defines its existence and its accessibility.

void SetDammage(int dammage) { int newHealth; // newHealth variable is declared newHealth = m_iHealth - dammage; if (newHealth < 0) { newHealth = 0; } else if (newHealth > 100) { int difference = newHealth - 100; // difference variable is declared Print("health overflow: " + difference); newHealth = 100; // difference variable is destroyed after leaving the "else" scope and doesn't exist outside of it } // difference variable does not exist in this scope and cannot be used m_iHealth = newHealth; // newHealth variable's last usage - the variable still exists Print("Health has been set"); // newHealth is destroyed after this line (on closing the "SetDammage" scope) }

Incorrect	Correct	Best
if (soldiersHealth > 75) { string message = "I'm doing well"; } else { // no conflict with the previous variable as scopes are different string message = "I don't feel so good"; } Print(message); // error: message variable is undefined here	string message; if (soldiersHealth > 75) { message = "I'm doing well"; } else { message = "I don't feel so good"; } Print(message); // OK	string message = "I don't feel so good"; if (soldiersHealth > 75) { message = "I'm doing well"; } Print(message); // OK

Casting

A value can sometimes be returned as one of its inherited classes or interfaced type - it can be casted ("forced" into a type) if the underlying type is known.

⚠

A wrong cast will return a null value - no exception will be thrown.

class Soldier_Base { int scope = 0; } class B_Soldier_F : Soldier_Base { int scope = 2; void SayHello() { Print("Hello there"); } } Soldier_Base aSoldier = new B_Soldier_F(); // valid aSoldier.SayHello(); // invalid - Soldier_Base does not have the SayHello method B_Soldier_F mySoldierF = B_Soldier_F.Cast(aSoldier); mySoldierF.SayHello(); // valid