Scripting: Keywords – Arma Reforger
Jump to navigation
Jump to search
Lou Montana (talk | contribs) m (Some wiki formatting) |
Lou Montana (talk | contribs) m (Remove after class' semicolons) |
||
(4 intermediate revisions by the same user not shown) | |||
Line 2: | Line 2: | ||
== Class Keywords == | == Class Keywords == | ||
{| class="wikitable" | {| class="wikitable valign-top" | ||
|- | |- | ||
! | ! | ||
=== class === | === class === | ||
| Declares a class | | Declares a class | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== modded === | === modded === | ||
| See {{Link|Arma Reforger:Object Oriented Programming Advanced Usage#Modding}}. | | See {{Link|Arma Reforger:Object Oriented Programming Advanced Usage#Modding}}. | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 24: | Line 24: | ||
{ | { | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== sealed === | === sealed === | ||
| A class marked with the '''sealed''' keyword cannot be inherited from | | A class marked with the '''sealed''' keyword cannot be inherited from | ||
< | <enforce> | ||
sealed class Infertile | sealed class Infertile | ||
{ | { | ||
Line 37: | Line 37: | ||
{ | { | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== extends === | === extends === | ||
| states that the declared class inherits from another | | states that the declared class inherits from another | ||
< | <enforce> | ||
class ChildClass extends ParentClass | class ChildClass extends ParentClass | ||
{ | { | ||
Line 51: | Line 51: | ||
{ | { | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== typedef === | === typedef === | ||
| Declares an alias for a type | | Declares an alias for a type | ||
< | <enforce> | ||
typedef string Text; | typedef string Text; | ||
Line 63: | Line 63: | ||
Text m_sMyText = "This is my text, that is a string"; | Text m_sMyText = "This is my text, that is a string"; | ||
} | } | ||
</ | </enforce> | ||
|} | |} | ||
Line 69: | Line 69: | ||
== Method Keywords == | == Method Keywords == | ||
{| class="wikitable" | {| class="wikitable valign-top" | ||
|- | |- | ||
! | ! | ||
=== proto === | === proto === | ||
| Prototyping of internal function (Engine side). | | Prototyping of internal function (Engine side). | ||
|- | |- | ||
! | ! | ||
=== native === | === native === | ||
| Native call convention of internal function (Engine side). | | Native call convention of internal function (Engine side). | ||
|- | |- | ||
! | ! | ||
=== volatile === | === volatile === | ||
| Internal function that may call back to script (hint for compiler that context need to be saved on stack). | | Internal function that may call back to script (hint for compiler that context need to be saved on stack). | ||
|- | |- | ||
! | ! | ||
=== private === | === 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. | | 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. | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 103: | Line 103: | ||
classInstance.PublicHelloWorld(); // works - calls PublicHelloWorld() that calls HelloWorld() | classInstance.PublicHelloWorld(); // works - calls PublicHelloWorld() that calls HelloWorld() | ||
classInstance.HelloWorld(); // compilation error - HelloWorld() is private and cannot be accessed | classInstance.HelloWorld(); // compilation error - HelloWorld() is private and cannot be accessed | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== protected === | === 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. | | 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. | ||
< | <enforce> | ||
class ParentClass | class ParentClass | ||
{ | { | ||
Line 131: | Line 131: | ||
ParentClass classInstance = new ParentClass(); | ParentClass classInstance = new ParentClass(); | ||
classInstance.HelloWorld(); // compilation error - HelloWorld() is protected and cannot be accessed | classInstance.HelloWorld(); // compilation error - HelloWorld() is protected and cannot be accessed | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== static === | === 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. | | 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. | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 149: | Line 149: | ||
ExampleClass classInstance = new ExampleClass(); | ExampleClass classInstance = new ExampleClass(); | ||
classInstance.HelloWorld(); // works | classInstance.HelloWorld(); // works | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== event === | === event === | ||
| Hint for tools that the function should be exposed as Entity script event. | | Hint for tools that the function should be exposed as Entity script event. | ||
|- | |- | ||
! | ! | ||
=== override === | === 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. | | Modifier for class method indicating overriding of base class method. Compiler checks if is method present in base class and if method signature matches. | ||
< | <enforce> | ||
class ParentClass | class ParentClass | ||
{ | { | ||
Line 180: | Line 180: | ||
ChildClass childClassInstance = new ChildClass(); | ChildClass childClassInstance = new ChildClass(); | ||
childClassInstance.HelloWorld(); // prints "Hello there" | childClassInstance.HelloWorld(); // prints "Hello there" | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== sealed === | === sealed === | ||
| Modifier for class method. The method cannot be overridden in derived classes. | | Modifier for class method. The method cannot be overridden in derived classes. | ||
< | <enforce> | ||
class ParentClass | class ParentClass | ||
{ | { | ||
Line 201: | Line 201: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|} | |} | ||
Line 207: | Line 207: | ||
== Value Keywords == | == Value Keywords == | ||
{| class="wikitable" | {| class="wikitable valign-top" | ||
|- | |- | ||
! | ! | ||
=== owned === | === owned === | ||
| Modifier for returning internal functions. Tells the script-VM that the returning variable (string or array) must not be released. | | Modifier for returning internal functions. Tells the script-VM that the returning variable (string or array) must not be released. | ||
|- | |- | ||
! | ! | ||
=== out === | === out === | ||
| Modifier for function parameters. It tells that variable will be changed by function call. | | Modifier for function parameters. It tells that variable will be changed by function call. | ||
< | <enforce> | ||
void Method(out array<string> parameter) | void Method(out array<string> parameter) | ||
{ | { | ||
Line 228: | Line 228: | ||
array<string> myArray = null; | array<string> myArray = null; | ||
Method(array); // myArray is now { "Hello", "there" } | Method(array); // myArray is now { "Hello", "there" } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== inout === | === inout === | ||
| Modifier for function parameters. It tells that variable will be used and then changed by function call. | | Modifier for function parameters. It tells that variable will be used and then changed by function call. | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 252: | Line 252: | ||
array<string> myArray = null; | array<string> myArray = null; | ||
classInstance.Method(array); // myArray is now { "Hello", "there" } and classInstance.m_aList is referencing myArray | classInstance.Method(array); // myArray is now { "Hello", "there" } and classInstance.m_aList is referencing myArray | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== const === | === const === | ||
| Declares a constant, that is a value that cannot be modified later. | | Declares a constant, that is a value that cannot be modified later. | ||
< | <enforce> | ||
const string MY_TEXT = "Hello there"; | const string MY_TEXT = "Hello there"; | ||
Line 265: | Line 265: | ||
MY_TEXT = "General Kenobi"; // compilation error - a constant is set in stone and cannot be modified | MY_TEXT = "General Kenobi"; // compilation error - a constant is set in stone and cannot be modified | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== reference === | === reference === | ||
| Hint for tools (Material editor) that the value may be used as parameter in material. | | Hint for tools (Material editor) that the value may be used as parameter in material. | ||
|- | |- | ||
! | ! | ||
=== notnull === | === notnull === | ||
| Modifier for function parameter of class pointer type. It tells that function expect the parameter will never be '''null'''. It shows error eventually and function won't be called. | | Modifier for function parameter of class pointer type. It tells that function expect the parameter will never be '''null'''. It shows error eventually and function won't be called. | ||
< | <enforce> | ||
void Method(notnull IEntity entity) // no need to check for "if (!entity)" inside the method | void Method(notnull IEntity entity) // no need to check for "if (!entity)" inside the method | ||
{ | { | ||
Line 284: | Line 284: | ||
Method(myEntity); | Method(myEntity); | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== private === | === private === | ||
| Value can only be accessed from the class/instance methods. Mutually exclusive with "protected". | | Value can only be accessed from the class/instance methods. Mutually exclusive with "protected". | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 302: | Line 302: | ||
ExampleClass classInstance = new ExampleClass(); | ExampleClass classInstance = new ExampleClass(); | ||
Print(classInstance.m_bIsActive); // compilation error - m_bIsActive is private and cannot be accessed | Print(classInstance.m_bIsActive); // compilation error - m_bIsActive is private and cannot be accessed | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== protected === | === protected === | ||
| Value can only be accessed from the class/instance methods or its children. Mutually exclusive with "private". | | Value can only be accessed from the class/instance methods or its children. Mutually exclusive with "private". | ||
< | <enforce> | ||
class ParentClass | class ParentClass | ||
{ | { | ||
Line 329: | Line 329: | ||
ChildClass childClassInstance = new ChildClass(); | ChildClass childClassInstance = new ChildClass(); | ||
Print(childClassInstance.m_bProtected); // compilation error - m_bProtected is protected and cannot be accessed | Print(childClassInstance.m_bProtected); // compilation error - m_bProtected is protected and cannot be accessed | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== static === | === static === | ||
| Value belongs to the class and not an instance of it. If public, it can be accessed without object pointer, just by < | | Value belongs to the class and not an instance of it. If public, it can be accessed without object pointer, just by <enforce>ClassName.variable</enforce> | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 347: | Line 347: | ||
Print(classInstance.bStaticValue); // works | Print(classInstance.bStaticValue); // works | ||
classInstance.bStaticValue = true; // works | classInstance.bStaticValue = true; // works | ||
</ | </enforce> | ||
{{Feature|warning|Due to the nature of per- | {{Feature|warning|Due to the nature of per-scenario mod loading/unloading, {{hl|static}} properties '''are reset game-wide''' on modded scenario start/leave due to game and scripts entire reload.}} | ||
|- | |- | ||
! | ! | ||
=== autoptr === | === 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). | | 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). | ||
{{Feature|informative|This keyword is useless in scripting as all classes inherit {{hl|Managed}}, therefore are managed by [[Arma Reforger:Scripting: Automatic Reference Counting|ARC]].}} | {{Feature|informative|This keyword is useless in scripting as all classes inherit {{hl|Managed}}, therefore are managed by [[Arma Reforger:Scripting: Automatic Reference Counting|ARC]].}} | ||
|- | |- | ||
! | ! | ||
=== ref === | === ref === | ||
| Strong reference. | | Strong reference. See [[Arma Reforger:Scripting: Automatic Reference Counting|Automatic Reference Counting]] for more information. | ||
|} | |} | ||
Line 363: | Line 363: | ||
== Code Keywords == | == Code Keywords == | ||
{| class="wikitable" | {| class="wikitable valign-top" | ||
|- | |- | ||
! | ! | ||
=== new === | === new === | ||
| Creates an instance of the provided class. | | Creates an instance of the provided class. | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 374: | Line 374: | ||
ExampleClass classInstance = new ExampleClass(); | ExampleClass classInstance = new ExampleClass(); | ||
</ | </enforce> | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 385: | Line 385: | ||
ExampleClass classInstance = new ExampleClass(5); // needs Constructor-defined arguments | ExampleClass classInstance = new ExampleClass(5); // needs Constructor-defined arguments | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== delete === | === delete === | ||
| Deletes an object and sets all its references to {{hl|null}}. | | Deletes an object and sets all its references to {{hl|null}}. | ||
{{Feature|important|It is not possible to delete an object if there is an external reference to it, like an array.}} | {{Feature|important|It is not possible to delete an object if there is an external reference to it, like an array.}} | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 418: | Line 418: | ||
delete obj; // throws a VM Exception | delete obj; // throws a VM Exception | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== thread === | === thread === | ||
| Creates a thread | | Creates a script thread from a method. | ||
{{Feature|important| | |||
* {{hl|thread}} is to be used in Workbench plugins. In game, use the <enforce inline>GetGame().GetCallQueue().CallLater()</enforce> method. | |||
* A script thread is not a real thread and member variables are therefore "thread-safe". | |||
}} | |||
<enforce> | |||
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"); | |||
} | |||
} | |||
</enforce> | |||
; Thread methods are only possible within a threaded method<nowiki>:</nowiki> | |||
* {{hl|Sleep}} takes an integer and waits for the provided amount of milliseconds | |||
* {{hl|Wait}} takes a bool condition and holds until the provided condition is true | |||
|- | |||
! | ! | ||
=== null === | === null === | ||
| A null value. | | A null value. | ||
|- | |- | ||
! | ! | ||
=== this === | === this === | ||
| Refers to the method's object itself. | | Refers to the method's object itself. | ||
< | <enforce> | ||
class ExampleClass | class ExampleClass | ||
{ | { | ||
Line 446: | Line 476: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== super === | === super === | ||
| Refers to the '''parent''' class for the requested variable/function. | | Refers to the '''parent''' class for the requested variable/function. | ||
< | <enforce> | ||
class Gen1 | class Gen1 | ||
{ | { | ||
Line 475: | Line 505: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|} | |} | ||
Line 481: | Line 511: | ||
== Code Flow Keywords == | == Code Flow Keywords == | ||
{| class="wikitable" | {| class="wikitable valign-top" | ||
|- | |- | ||
! | ! | ||
=== if === | === if === | ||
| verifies a boolean condition. If the condition is true then the code is executed. | | verifies a boolean condition. If the condition is true then the code is executed. | ||
< | <enforce> | ||
void Method(int value = 0) | void Method(int value = 0) | ||
{ | { | ||
Line 494: | Line 524: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== else === | === else === | ||
| optional, declares code to be executed if the if condition is not met | | optional, declares code to be executed if the if condition is not met | ||
< | <enforce> | ||
void Method(int value = 0) | void Method(int value = 0) | ||
{ | { | ||
Line 511: | Line 541: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== for === | === for === | ||
| processes code while the provided condition is met. The syntax is: | | processes code while the provided condition is met. The syntax is: | ||
< | <enforce> | ||
for (initialisation; loopCondition; completionCode) | for (initialisation; loopCondition; completionCode) | ||
{ | { | ||
// code here | // code here | ||
} | } | ||
</ | </enforce> | ||
< | <enforce> | ||
void MethodA(notnull array<string> words) | void MethodA(notnull array<string> words) | ||
{ | { | ||
Line 548: | Line 578: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== foreach === | === foreach === | ||
| processes code for each element of an iterable object (e.g an array). Iteration separator is{{hl|:}}. | | processes code for each element of an iterable object (e.g an array). Iteration separator is{{hl|:}}. | ||
< | <enforce> | ||
// array example | // array example | ||
void Method(notnull array<string> words) | void Method(notnull array<string> words) | ||
Line 567: | Line 597: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
< | <enforce> | ||
// map example | // map example | ||
void Method(notnull map<string, int> data) | void Method(notnull map<string, int> data) | ||
Line 577: | Line 607: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== while === | === while === | ||
| processes code while condition is met. Beware, as it can lock the program on wrong conditions! | | processes code while condition is met. Beware, as it can lock the program on wrong conditions! | ||
< | <enforce> | ||
void Method(array<string> words) | void Method(array<string> words) | ||
{ | { | ||
Line 592: | Line 622: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== switch === | === switch === | ||
| switches the code to execute depending on the condition | | switches the code to execute depending on the condition | ||
< | <enforce> | ||
void Method(string word) | void Method(string word) | ||
{ | { | ||
Line 615: | Line 645: | ||
} | } | ||
} | } | ||
</ | </enforce> | ||
|- | |- | ||
! | ! | ||
=== return === | === return === |
Revision as of 12:33, 19 May 2023
Class Keywords
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
proto |
Prototyping of internal function (Engine side). |
---|---|
native |
Native call convention of internal function (Engine side). |
volatile |
Internal function 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 function 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
owned |
Modifier for returning internal functions. Tells the script-VM that the returning variable (string or array) must not be released. |
---|---|
out |
Modifier for function parameters. It tells that variable will be changed by function call. |
inout |
Modifier for function parameters. It tells that variable will be used and then changed by function call.
class ExampleClass
{
private ref array<string> m_aList;
void Method(inout array<string> parameter)
{
parameter = new array<string>();
parameter.Insert("Hello");
parameter.Insert("there");
m_aList = parameter;
}
}
ExampleClass classInstance = new ExampleClass();
array<string> myArray = null;
classInstance.Method(array); // myArray is now { "Hello", "there" } and classInstance.m_aList is referencing myArray |
const |
Declares a constant, that is a value that cannot be modified later.
const string MY_TEXT = "Hello there";
void Method()
{
Print(MY_TEXT); // will print "Hello there"
MY_TEXT = "General Kenobi"; // compilation error - a constant is set in stone and cannot be modified
} |
reference |
Hint for tools (Material editor) that the value may be used as parameter in material. |
notnull |
Modifier for function parameter of class pointer type. It tells that function expect the parameter will never be null. It shows error eventually and function won't be 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
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");
}
} |
super |
Refers to the parent class for the requested variable/function.
class Gen1
{
void Method()
{
Print("Gen1 method");
}
}
class Gen2 : Gen1
{
void Method()
{
Print("Gen2 method");
}
}
class Gen3 : Gen2
{
void Method()
{
super.Method(); // prints "Gen2 method"
}
} |
Code Flow Keywords
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++)
{
Print(words[i]);
}
}
void MethodB(notnull array<string> words)
{
int i = 0;
for (; i < words.Count(); i++) // initialisation is optional
{
Print(words[i]);
}
}
void MethodC(notnull array<string> words)
{
for (int i = 0; i < words.Count();) // so is completionCode
{
Print(words[i]);
i++;
}
} |
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;
}
} |
return |
stops the code flow and returns the provided value. No value needs to be provided for void methods. |