Arma Reforger:Scripting: Keywords

Class Keywords

Keyword	Description
class	Declares a class class ExampleClass { }
modded	See Object Oriented Programming Advanced Usage - Modding. class ExampleClass { } modded class ExampleClass // inherits and "takes the place" of the original ExampleClass { }
sealed	A class marked with the sealed keyword cannot be inherited from sealed class Infertile { } class Child : Infertile // compilation error - a class cannot inherit from a sealed class { }
extends	states that the declared class inherits from another class ChildClass extends ParentClass { } // alias class ChildClass : ParentClass { }
typedef	Declares an alias for a type typedef string Text; class ExampleClass { Text m_sMyText = "This is my text, that is a string"; }

Method Keywords

Keyword	Description
proto	Disclose an engine-side method to script (Engine side).
external	Compiler hint to link API methods - only applies to proto methods (Engine side).
native	Native call convention of internal method (Engine side).
volatile	Internal method that may call back to script (hint for compiler that context need to be saved on stack).
private	Modifier for class method. The method can be called only from inside of the same class' methods. A modded class will not be able to use it either. class ExampleClass { private void HelloWorld() { Print("Hello there"); } void PublicHelloWorld() { HelloWorld(); // works from within the object } } ExampleClass classInstance = new ExampleClass(); classInstance.PublicHelloWorld(); // works - calls PublicHelloWorld() that calls HelloWorld() classInstance.HelloWorld(); // compilation error - HelloWorld() is private and cannot be accessed
protected	Modifier for class method. The method can be called only from inside of class' methods or methods of its extended (children) classes, or a modded class. class ParentClass { protected void HelloWorld() { Print("Hello there"); } } class ChildClass : ParentClass { void PublicHelloWorld() { HelloWorld(); // works from within the object } } ChildClass classInstance = new ChildClass(); classInstance.PublicHelloWorld(); // works - calls PublicHelloWorld() that calls HelloWorld() classInstance.HelloWorld(); // compilation error - HelloWorld() is protected and cannot be accessed ParentClass classInstance = new ParentClass(); classInstance.HelloWorld(); // compilation error - HelloWorld() is protected and cannot be accessed
static	Modifier for class method. The method can be called without object pointer, just by ClassName.methodName(). Only static values/methods can be accessed from a static method. class ExampleClass { static void HelloWorld() { Print("Hello there"); } } ExampleClass.HelloWorld(); // works ExampleClass classInstance = new ExampleClass(); classInstance.HelloWorld(); // works
event	Hint for tools that the method should be exposed as Entity script event.
override	Modifier for class method indicating overriding of base class method. Compiler checks if is method present in base class and if method signature matches. class ParentClass { void HelloWorld() { Print("Hello world"); } } class ChildClass : ParentClass { override void HelloWorld() { Print("Hello there"); } } ParentClass parentClassInstance = new ParentClass(); parentClassInstance.HelloWorld(); // prints "Hello world" ChildClass childClassInstance = new ChildClass(); childClassInstance.HelloWorld(); // prints "Hello there"
sealed	Modifier for class method. The method cannot be overridden in derived classes. class ParentClass { sealed void HelloWorld() { Print("Hello there"); } } class ChildClass : ParentClass { override void HelloWorld() // compilation error - cannot override a sealed method { Print("Hello world"); } }

Value Keywords

Keyword	Description
owned	Modifier for returning internal methods. Tells the script VM that the returning variable (string or array) must not be released.
out	Modifier for method parameters. It means that the argument may be changed by the method call. void Method(out array<string> parameter) { parameter = {}; parameter.Insert("Hello"); parameter.Insert("there"); } // ... array<string> myArray = null; Method(myArray); // myArray is now { "Hello", "there" }
inout	Modifier for method parameters. It means that the argument will be used and may be changed by the method call. class ExampleClass { private ref array<string> m_aOldParameter; void Method(inout array<string> parameter) { m_aOldParameter = parameter; parameter = {}; parameter.Insert("Hello"); parameter.Insert("there"); } } ExampleClass classInstance = new ExampleClass(); array<string> myArray = null; classInstance.Method(myArray); // myArray is now { "Hello", "there" } and classInstance.m_aList is referencing myArray's old value
const	Declares a constant, that is a value that cannot be modified later. const string MY_TEXT = "Hello there"; void Method1() { Print(MY_TEXT); // will print "Hello there" MY_TEXT = "General Kenobi"; // compilation error - a constant is set in stone and cannot be modified } void Method2() { const string myUnmodifiableString = "Hello there"; // constant valid for method's scope Print(myUnmodifiableString); myUnmodifiableString = "General Kenobi"; // compilation error }
reference	Hint for tools (Material editor) that the value may be used as parameter in material.
notnull	Modifier for method parameter of class pointer type. It means that the method expect the parameter to never be null; if a null value is provided, a VM Exception is raised and the method is not called. void Method(notnull IEntity entity) // no need to check for "if (!entity)" inside the method { entity.DoSomething(); // the argument can be accessed safely } if (myEntity) // it is still needed to check for null before calling the method { Method(myEntity); }
private	Value can only be accessed from the class/instance methods. Mutually exclusive with "protected". class ExampleClass { private bool m_bIsActive; void SetActive(bool value) { m_bIsActive = value; } } ExampleClass classInstance = new ExampleClass(); Print(classInstance.m_bIsActive); // compilation error - m_bIsActive is private and cannot be accessed
protected	Value can only be accessed from the class/instance methods or its children. Mutually exclusive with "private". class ParentClass { protected bool m_bProtected; private bool m_bPrivate; void SetPrivate(bool value) { m_bPrivate = value; } } class ChildClass : ParentClass { void SetProtected(bool value) { m_bProtected = value; // works - m_bProtected declaration reaches ChildClass } } ChildClass childClassInstance = new ChildClass(); Print(childClassInstance.m_bProtected); // compilation error - m_bProtected is protected and cannot be accessed
static	Value belongs to the class and not an instance of it. If public, it can be accessed without object pointer, just by ClassName.variable class ExampleClass { static bool bStaticValue; private static bool m_bPrivate; // it is good practice to make it protected/private and have getters/setters instead } Print(ExampleClass.bStaticValue); // works ExampleClass.bStaticValue = true; // works ExampleClass classInstance = new ExampleClass(); Print(classInstance.bStaticValue); // works classInstance.bStaticValue = true; // works ⚠ Due to the nature of per-scenario mod loading/unloading, static properties are reset game-wide on modded scenario start/leave due to game and scripts' entire reload.
autoptr	Modifier for class/pointer values. Pointed object will be automatically destroyed upon end of variable lifetime (end of scope, or deletion of class, that contain it). ⓘ This keyword is useless in scripting as all classes inherit Managed, therefore are managed by ARC.
ref	Strong reference. See Automatic Reference Counting for more information.

Code Keywords

Keyword	Description
auto	Guess the type of the variable. Its usage is not recommended (see Best Practices)! auto myVar = 5; // understood as int myVar = 5 // but it may have been meant as: float myVar = 5;
new	Creates an instance of the provided class. class ExampleClass { } ExampleClass classInstance = new ExampleClass(); class ExampleClass { void ExampleClass(int myValue) // a method named from the class is the constructor { Print(myValue); } } ExampleClass classInstance = new ExampleClass(5); // needs Constructor-defined arguments
delete	Deletes an object and sets all its references to null. ⚠ It is not possible to delete an object if there is an external reference to it, like an array. class ExampleClass { void Method() { ReferencedClass obj; if (!obj) Print("obj is null"); obj = new ReferencedClass(); if (obj) Print("obj is not null"); delete obj; if (!obj) Print("obj is null"); // everything was fine obj = new ReferencedClass(); if (obj) Print("obj is not null"); array<ref ReferencedClass> list = {}; list.Insert(obj); delete obj; // throws a VM Exception } }
thread	Creates a script thread from a method. ⚠ thread is to be used in Workbench plugins. In game, use the GetGame().GetCallQueue().CallLater() method. A script thread is not a real thread and member variables are therefore "thread-safe". class ExampleClass { // calling this method will print // "MainMethod start" // "ThreadMethod start", // "MainMethod end" // then 500ms later, "ThreadMethod end" void MainMethod() { Print("MainMethod start"); thread ThreadMethod(); Print("MainMethod end"); } protected void ThreadMethod() { Print("ThreadMethod start"); Sleep(500); Print("ThreadMethod end"); } } Thread methods are only possible within a threaded method: Sleep takes an integer and waits for the provided amount of milliseconds Wait takes a bool condition and holds until the provided condition is true
null	A null value.
this	Refers to the method's object itself. class ExampleClass { void MethodA() { this.MethodB(); } void MethodB() { Print("It works"); } } Since 1.1.0, this is supported in static methods and behaves like the current type. class Gen1 { static void DoSmth() { Print("A"); } } class Gen2 : Gen1 { static override void DoSmth(Widget utility) { Print("B"); Print(this); // > ClassB } }
super	Refers to the parent class for the requested variable/method. class Gen1 { void Method() { Print("Gen1 method"); } } class Gen2 : Gen1 { override void Method() { Print("Gen2 method"); } } class Gen3 : Gen2 { override void Method() { super.Method(); // prints "Gen2 method" } } Since 1.1.0, super is supported in static methods and behaves like a type. class Gen1 { static int a = 33; int b = 42; static void ShowMessage() { Print("A"); } } class Gen2 : Gen1 { static override void ShowMessage(Widget utility) { Print("B"); Print(super); // > Gen1 Print(super.a); // > a = 33 // Print(super.b); <- error - not a static property super.ShowMessage(); // > "A" } }
1.1.0 vanilla	Refers to the first unmodded parent class for the requested variable/method. class ClassA { static void Hello() { Print("vanilla"); } } // mod 1 content modded class ClassA { override static void Hello() { Print("modded 1"); } } // mod 2 content modded class ClassA { override static void Hello() { super.Hello(); vanilla.Hello(); Print("modded 2"); } } void Test() { ClassA o = new ClassA(); o.Hello(); // prints modded 1, vanilla, modded 2 }

Code Flow Keywords

Keyword	Description
if	verifies a boolean condition. If the condition is true then the code is executed. void Method(int value = 0) { if (value > 50) Print("value is > 50"); }
else	optional, declares code to be executed if the if condition is not met void Method(int value = 0) { if (value > 50) Print("value is > 50"); else Print("value is <= 50"); }
for	processes code while the provided condition is met. The syntax is: for (initialisation; loopCondition; completionCode) { // code here } void MethodA(notnull array<string> words) { // for (int i = 0; i < words.Count(); i++) // this if for example's sake; use foreach instead for (int i, count = words.Count(); i < count; ++i) // optimised { Print(words[i]); } } void MethodB(notnull array<string> words) { int i; // auto-initialised to zero int count = words.Count(); for (; i < count; i++) // initialisation is optional { Print(words[i]); } } void MethodC(notnull array<string> words) { for (int i, count = words.Count(); i < count;) // so is completionCode { Print(words[i]); i++; // do not forget it! } }
foreach	processes code for each element of an iterable object (e.g an array). Iteration separator is:. // array example void Method(notnull array<string> words) { foreach (string word : words) { Print(word); } foreach (int index, string word : words) { PrintFormat("word #%1 is %2", index, word); } } // map example void Method(notnull map<string, int> data) { foreach (string key, int value : data) { PrintFormat("Key %1's value is %2", key, value); } }
while	processes code while condition is met. Beware, as it can lock the program on wrong conditions! void Method(array<string> words) { int i = 0; while (i < words.Count()) { Print(words[i]); i++; // do not forget it! } }
switch	switches the code to execute depending on the condition void Method(string word) { switch (word) { case "Hello": Print("it's Hello"); break; case "there": Print("it's there"); break; default: Print("it's not interesting."); break; } }
continue	Used to skip to the next iteration in for, foreach, while loops class ExampleClass { // this method will print 0, 1, 2, 4 void Skip3() { for (int i; i < 5; i++) { if (i == 3) continue; Print(i.ToString()); } } void MethodB() { foreach (IEntity entity : m_aEntities) { if (!entity) continue; Print(entity); } } }
return	Exits the method immediately with the provided value if any. class ExampleClass { void PrintHelloThere(bool print) { if (!print) return; // ends here if print is false Print("Hello there"); } float GetDistanceNotZero(vector v1, vector v2) { if (v1 == v2) return -1; return vector.Distance(v1, v2); } }