1. CIS 488/588 Bruce R. Maxim UM-Dearborn
Unreal Script Syntax
CIS 488/588
Bruce R. Maxim
UM-Dearborn
11/20/2018

2. Based on Tim Sweeney’s UnrealScript Language Reference
11/20/2018

3. Variable Declarations
var int a; // integer
var byte Table[64]; // array of 64 bytes
// max 32-character string.
var string[32] PlayerName;
var actor Other; // an actor.
11/20/2018

4. Data Types - 1 byte (0 to 255). int (32-bit).
bool (either "true" or "false“)
float (32-bit)
string (string of characters)
name (item in Unreal - function, state, class, etc). Names are stored as a 16-bit index into the global name table. Names correspond to simple strings of 1-31 characters.
enum (similar to C++ enum)
11/20/2018

5. Data Types - 2 struct (similar to C++, passed by value)
For example, two commonly-used structs are "vector", which consists of an X, Y, and Z component; and "rotator", which consists of a pitch, yaw, and roll component.
object and actor references (use . operator like C++)
Object references may also contain a special value called "None", which is the equivalent of the C "NULL" pointer: it says "this variable doesn't refer to any object".
11/20/2018

6. Variable Modifiers - 1
const (treats the contents of the variable as a constant - used for variables which the engine is responsible for updating),
editconst (variable can be seen in UnrealEd but not edited)
input (variable accessible to Unreal's input system, so that input (such as button presses and joystick movements) can be directly mapped onto it. Only relevant with variables of type "byte" and "float“).
Transient (transient variables are not saved to disk and are initialized to zero when an actor is loaded)
11/20/2018

7. Variable Modifiers - 2
native (variable is loaded and saved by C++ code, rather than by UnrealScript).
private (variable may only be accessed by the class's script; no other classes or subclasses)
travel (only supported for PlayerPawn,this is the mechanism that keeps your health and ammo counts intact when switching levels)
skip (only used for logical operators like && and ||)
export (only meaningful for the Brush variable in Actor classes)
11/20/2018

8. Arrays
UnrealScript supports only single-dimensional arrays, though you can simulate multidimensional arrays by carrying out the row/column math yourself
Dynamic arrays are possible (discussed later)
// Declares an array of 20 integers
var int MyArray[20];
11/20/2018

9. Editability - 1
You can make an instance variable "editable", so that users can edit the variable's value in UnrealEd via Actor Properties
// Declare an editable integer in the default category
var ( ) int MyInteger;
// Declare an editable bool in "MyCategory".
var (MyCategory) bool MyBool;
11/20/2018

10. Editability - 2
You can also declare a variable as "editconst", which means that the variable should be visible but not editable UnrealEd (can be changed using a script).
// MyBool is visible but not editable in UnrealEd
var(MyCategory) editconst bool MyBool; 
// and not changeable in script
var(MyCategory) const editconst bool MyBool;
11/20/2018

11. Actor References // Declare two variables that refer to a pawns.
var pawn P, Q; 
// Here is a function that makes use of P.
MyFunction( ) {
// Set P's enemy to Q.
P.Enemy = Q; 
// Tell P to play his running animation.
P.PlayRunning( ); }
11/20/2018

12. Class Reference Variables - 1
Classes are objects just like actors, textures, and sounds are objects.
Class objects belong to class named "class"
You can store a reference to a class object, so that you can spawn an actor belonging to that class (without knowing what the class is at compile-time).
11/20/2018

13. Class Reference Variables - 2
var ( ) class C;
var actor A;
// Spawn an actor belonging to some arbitrary
// class C.
A = Spawn( C );
You can optionally use the special class<classlimiter> syntax to limit the variable to only containing references to classes which extend a given superclass
11/20/2018

14. Enumerations // EColor enumeration, with three values. enum Ecolor {
CO_Red,
CO_Green,
CO_Blue };
// Now, declare two variables of type EColor.
var EColor ShirtColor, HatColor;
11/20/2018

15. Structs // A point or direction vector in 3D space. struct Vector {
var float X;
var float Y;
var float Z };
// Declare a bunch of variables of type Vector.
var Vector Position;
var Vector Destination;
11/20/2018

16. Pre-defined Structs Vector (3D point in space, with an X, Y, Z)
Plane (3D plane is defined by its X, Y, Z components, which are assumed to be normalized plus its W component - distance of the plane from the origin)
Rotator (Pitch, Yaw, Roll components)
Coords (coordinate system in 3D space)
Color (RGB color value)
Region (unique convex region within level)
11/20/2018

17. Expressions
UnrealScript expressions and operators are similar to those found in C++
Named constants can be defined
const LargeNumber=123456;
const PI= ;
const MyName="Tim";
const Northeast=Vect(1.0,1.0,0.0);
UnrealScript does automatic type conversions among most numeric types
11/20/2018

18. Non-Automatic Type Conversions - 1
String to Byte, Int, Float
Byte, Int, Float, Vector, Rotation to String
String to Vector, Rotation
String to Bool
Bool to String
Byte, Int, Float, Vector, Rotation to Bool
Bool to Byte, Int, Float
Name to String
11/20/2018

19. Non-Automatic Type Conversions - 2
Rotator to Vector
Vector to Rotator
Object (or Actor) to Int
Object (or Actor) to Bool
Object (or Actor) to String
11/20/2018

20. Typecasting - 1
All actors have a variable named "Target", which is a reference to another actor
If you need to check and see if your Target belongs to the "Pawn" actor class, and you need to do something special with your target that only makes sense when it’s a pawn
For example, you may need to call one of the Pawn functions.
11/20/2018

21. Typecasting - 2 var actor Target; function TestActorConversions ( ) {
local Pawn P;  // See if my target is a Pawn.
P = Pawn(Target); // Attempt typecast
if ( P != None ) // P set to None if typecast fails
// Target is a pawn, so set its Enemy to Self P.Enemy = Self; }
11/20/2018

22. Functions - 1 Similar to function definition in C++
Functions can have return types and make recursive calls
Arguments are passed by value (the default)
Arguments can be passed by reference (if the key word out precedes the formal argument declaration)
Functions can have their own local variable declarations if local precedes the declarations
11/20/2018

23. Functions - 2 // Compute minimum and component of a vector.
function VectorRange( vector V, out float Min) {
if ( V.X<V.Y && V.X<V.Z )
Min = V.X;
else if ( V.Y<V.Z )
Min = V.Y;
else
Min = V.Z;  }
11/20/2018

24. Overriding Functions - 1
You can override function definitions (for example every actor has a Touch function and a Message function)
// Called when something touches this actor.
function Touch( actor Other ) {
Log( "I was touched!")
Other.Message( "You touched me!" ); }
11/20/2018

25. Overriding Functions - 2
UnrealScript can be declared as "final".
The "final" keyword (which appears immediately before the word "function") says "this function cannot be overridden by child classes".
This should be used in functions which you know nobody would want to override, because it results in faster script code.
11/20/2018

26. Fuction Calling Specifiers
class MyClass extends Pawn; 
function MyExample( actor Other ) {
// calls Touch residing in class Pawn or higher
Super(Pawn).Touch( Other );
// call most derived (non-state) version of Touch
Global.Touch( Other );
// call Touch defined in parent class
Super.Touch( Other ); }
11/20/2018

27. Control Structures – for Loops
function ForExample( ) {
local int i;
log( "Demonstrating the for loop" );
for ( i = 0; i < 4; i++ )
log( "The value of i is " $ i ); }
log( "Completed with i=" $ i);
11/20/2018

28. Control Structures – do..until
function DoExample( ) {
local int i;
log( "Demonstrating the do loop" ); do
log( "The value of i is " $ i );
i = i + 1;
} until( i == 4 );
log( "Completed with i=" $ i); }
11/20/2018

29. Control Structures - while
function WhileExample( ) {
local int i;
log( "Demonstrating the while loop" );
while( i < 4 )
log( "The value of i is " $ i );
i = i + 1; }
log( "Completed with i=" $ i);
11/20/2018

30. Break function WhileExample( ) { local int i;
log( "Demonstrating break" );
for( I = 0; I < 10; i++ )
if( i == 3 )
break; }
11/20/2018

31. goto function GotoExample( ) { log( "Starting GotoExample" );
goto Hither;
Yon: log( "At Yon" );
goto Elsewhere;
Hither: log( "At Hither" );
goto Yon;
Elsewhere: log( "At Elsewhere" ); }
11/20/2018

32. Control Structures – if..else - 1
// Example of simple "if".
if ( LightBrightness < 20 )
log( "My light is dim" ); 
// Example of "if-else".
if ( LightBrightness < 20 )
log( "My light is dim" );
else
log( "My light is bright" );
11/20/2018

33. Control Structures – if..else - 2
// Example of "if-else if-else".
if ( LightBrightness < 20 )
log( "My light is dim" );
else if ( LightBrightness < 40 )
log( "My light is medium" );
else if ( LightBrightness < 60 )
log( "My light is kinda bright" );
else
log( "My light is very bright" );
11/20/2018

34. Control Structures - switch
switch( LightType ) {
case LT_None: log( "There is no lighting" );
break;
case LT_Steady: log( "There is steady lighting" ); break;
case LT_Backdrop: log( "There is backdrop lighting" ); break;
default: log( "There is dynamic" ); break; }
11/20/2018

35. foreach and Iterators - 1
UnrealScript's "foreach" command makes it easy to deal with large groups of actors
For example all of the actors in a level, or all of the actors within a certain distance of another actor.
"foreach" works in conjunction with a special kind of function called an "iterator" function whose purpose is to iterate through a list of actors.
11/20/2018

36. foreach and Iterators - 2
function Something( ) {
local Actor A;
log( "Lights:" ); // Display a list of all lights in the level.
foreach AllActors( class 'Actor', A ) // all level actors
if( A.LightType != LT_None )
log( A ); }
11/20/2018

37. Iterator Functions
AllActors ( class BaseClass, out actor Actor, optional name MatchTag )
ChildActors( class BaseClass, out actor Actor )
BasedActors( class BaseClass, out actor Actor )
TouchingActors( class BaseClass, out actor Actor )
TraceActors( class BaseClass, out actor Actor, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent )
RadiusActors( class BaseClass, out actor Actor, float Radius, optional vector Loc )
VisibleActors( class BaseClass, out actor Actor, optional float Radius, optional vector Loc )
11/20/2018