Functions in UnrealScript

This page will attempt to explain the basic facts about functions in order to get started. For a more in depth explanation when you are more confident with UnrealScript you can simply search the Unreal Wiki or UDN for any topics about Functions.

Functions always start with the word “function”, this is always followed by the optional return variable type, which in turn is always followed by the function name, then the functions parameters which are always enclosed within parenthesis (brackets). For example.

	function <optional variable type> MyFunction(parameters)

	//Examples...
	function int MyFunction(Actor Other)

	function MyFunction(Actor Other)

	function MyFunction()

Declaring a Function

Function declarations are very simple. For example.

//This function has no return value, an no extra paramters.
//This function has been declared, we have informed the compiler that we
//intend to use it, for example maybe in a sub-class .It has not been defined yet.
function MyFirstFunction();

Defining a Function

To define a function, we just add some code to the body. The body of the function is always enclosed within square brackets. For example.

function MyFirstFunction()
{
	//Code goes here.
}

Functions that have the optional return variable type should always return something. Here is a good and bad example.

//Bad Example.
function int MyFirstFunction()
{
	//This function expects an integer to be returned.
	//But there is no return command!
}

//Good Example.
function float MyFirstFunction()
{
	//This function expects a float value to be returned.
	//We return 1.000000.
	return 1.000000;
}

The parameters can be used to pass information between functions. For example.

//A global integer variable called "FinalValue".
var int FinalValue;

function GetValue()
{
	//This function is calling the MultiplyByTen function.
	//We pass the integer "2" into the function.
	MultiplyByTen(2);
}

//This MultiplyByTen function expects an integer to be passed into it.
//x is set to the value of the integer passed into it.
function MultiplyByTen(int x)
{
	//"x" now has the value of 2. So we can set FinalValue to "x" * 10 (2 * 10).
	FinalValue = x * 10;
	//So FinalValue now has a value of 20.
}

//This is a simplified example of how you could give health to a player by passing variables.
function GiveHealth(int HealAmount)
{
	Health = Health + HealAmount;
}

Probe Functions

Probe functions are special functions that already exist within the game. These functions are called whenever something happens that triggers them. For example if two actors touch each other then the “Touch” function is called. Probe functions can be disabled/enabled, or ignored while in a state. By default they are all enabled. These always start with the keyword “event” instead of the keyword “function”, just for ease of reference more than anything else as event functions that begin with the keyword “function” will work fine. Here are some of the basic and most commonly used probe functions. These all originate in the Actor class. For a more complete list check out this page Probe Function and the Actor class.

Overriding Functions

Functions, (unless declared as being native) can be overridden by any child classes. This allows you to create new classes based on other ones without having to re-write a whole lot of code. For example.

//The PlayVictory function is first declared in the Monster class.
//The SkaarjPupae class defines it and makes it play the "Stab" animation.
function PlayVictory()
{
	//Simplified function from SkaarjPupae class.
	PlayAnim('Stab', 1.0, 0.1);
}

//What if we want to extend the SkaarjPupae class but make it play a different animation when PlayVictory is called?.
//Or what if our new monster has no animation called "Stab", we can simply override the function.
function PlayVictory()
{
	//Execute our new code.
	PlayAnim('Bite');
	//Our function overrides the ones in SkaarjPupae and Monster.
}

Extending Functions

What if we need to extend an already existing function in a parent class but don’t want to override it. We do that by using the special “Super” command. For example, when something is destroyed we need to make sure any effects we made are destroyed. The parent classes may also have things that need destroying. Here’s how to do that.

function Destroyed()
{
	//Check if the effect still exists.
	if(MyEmitter != None)
	{
		//It still exists so destroy it.
		MyEmitter.Destroy();
	}
	//Call the Destroyed function in the parent class.
	Super.Destroyed();
}

What if we want to override a function so that the immediate parent version is not called, but the parent of that parent has important code that we need. We can do that by specifying which class the Super command should point to. If you try to use Super to call a function in a class that is not in a parent class you will most likely crash the game. For example.

//In this example our class extends the Monster class.
class MyMonster extends Monster;

function Destroyed()
{
	if(MyEmitter != None)
	{
		MyEmitter.Destroy();
	}
	//We want to skip the destroyed function in the class Monster, but we want
	//to call it in the class xPawn (which is the parent of Monster).
	Super(xPawn).Destroyed();
}

//Note that the parent function called with the Super command has an opportunity
//to also use the Super command. So in this example the destroyed function in xPawn
//will execute its code then call the destroyed function in Pawn (UnrealPawn does not
//override it) which in turn executes its code and calls the destroyed function in Actor.

TIP – Disable probe functions if you won’t be needing them anymore, especially Tick and Timer.