Scripting: Keywords – Arma Reforger
Jump to navigation
Jump to search
Lou Montana (talk | contribs) (Add debug keyword) |
Lou Montana (talk | contribs) m (Fix vanilla description) |
||
| Line 585: | Line 585: | ||
! | ! | ||
{{ArgTitle|3|vanilla|{{GVI|armaR|1.1.0}}}} | {{ArgTitle|3|vanilla|{{GVI|armaR|1.1.0}}}} | ||
| Refers to the | | Refers to the '''unmodded''' version of the modded variable/method. | ||
<enforce> | <enforce> | ||
class ClassA | class ClassA | ||
Latest revision as of 13:55, 27 June 2024
Contents
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
|
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. |
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". |
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 |
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). |
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)!
|
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.
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.
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");
}
}
|
null |
A null value. |
this |
Refers to the method's object itself.
class ExampleClass
{
void MethodA()
{
this.MethodB();
}
void MethodB()
{
Print("It works");
}
} Since class Gen1
{
static void DoSmth() { Print("A"); }
}
class Gen2 : Gen1
{
static override void DoSmth(Widget utility)
{
Print("B");
Print(this); // > Gen2
}
} |
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 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"
}
} |
vanilla |
Refers to the unmodded version of the modded 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
} |
debug |
Triggers a breakpoint in Script Editor.
class MyClass
{
[Attribute(defvalue: "0", desc: "Use breakpoints in Workbench")]
protected bool m_bUseBreakpoints;
static void Hello()
{
Print("This is debugging");
#ifdef WORKBENCH
if (m_bUseBreakpoints)
debug;
#endif // WORKBENCH
}
} |
Code Flow Keywords
| Keyword | Description |
|---|---|
if |
verifies a boolean condition. If the condition is true then the code is executed.
|
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:.
|
while |
processes code while condition is met. Beware, as it can lock the program on wrong conditions! |
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 |
return |
Exits the method immediately with the provided value if any. |