Open up our AwesomeActor.uc class in ConTEXT and add this line after our class declaration:

var bool bIsItRaining;

The var tells the game that we're declaring a variable. After that, is the variable type, in this case bool for boolean. After that, we tell the game our variable's name, bIsItRaining. Spaces can't be used in variable names, but underscore characters ( _ ) are allowed. The semicolon finishes the line. It's important never to forget the semicolon at the end of the line. Without it the compiler will think any lines after it are part of this line and will look at us confused, as well as give us an error.

Now let's add a log to our PostBeginPlay function to see our variable in action. Change the PostBeginPlay function to this (don't forget the tilde):

function PostBeginPlay()
{
'log("Is it raining?" @ bIsItRaining);
}

This will output our text as well as tell us the value of bIsItRaining. The @ operator combines the text with the value of the variable into one sentence which the log uses. This is known as concatenation and will be discussed later in the chapter.

Our AwesomeActor class should look like this now:

class AwesomeActor extends Actor
placeable;
var bool bIsItRaining;
function PostBeginPlay()
{
'log("Is it raining?" @ bIsItRaining);
}
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_NavP'
HiddenGame=True
End Object
Components.Add(Sprite)
}

Now let's compile it. If we get any errors go back and make sure everything is spelled correctly and that we haven't missed any semicolons at the end of lines.

Open the editor and open our test map with the AwesomeActor placed, and run the game. Nothing obvious will happen, but let's close the game and see what our Launch2.log file looks like:

[0008.59] ScriptLog: Is it raining? False

Our variable is working! As we can see, even without doing anything to it our variable has a default value. When created, booleans automatically start out false. This is a good thing to know when creating variables, especially booleans. It's best to avoid words like Not or No in boolean names to avoid having double negatives. For example, if we had a bool named bIsNotActive, and it was False, would the object be active or not? In this case it would be active, but to avoid confusion it would be better to have a variable named bIsActive so it would be easier to tell what it means when it's true or false.

Now that we have our bool, how do we change it? Let's add a line to our PostBeginPlay function.

bIsItRaining = true;

Now our function should look like this:

function PostBeginPlay()
{
bIsItRaining = true;
'log("Is it raining?" @ bIsItRaining);
}

Compile and run the game again, and we should see the change in the log:

[0007.68] ScriptLog: Is it raining? True

There we go!

We can also change it back just as easily. Let's add a line after our log to change it to false, and then add another log to see the change.

bIsItRaining = false;
'log("Is it raining?" @ bIsItRaining);

Now our PostBeginPlay function should look like this:

function PostBeginPlay()
{
bIsItRaining = true;
'log("Is it raining?" @ bIsItRaining);
bIsItRaining = false;
'log("Is it raining?" @ bIsItRaining);
}

Let's compile and test out the changes!

[0007.65] ScriptLog: Is it raining? True
[0007.65] ScriptLog: Is it raining? False

Declaring an integer is similar to what we did with bools, so let's replace our bool declaration line with this:

var int NumberOfKittens;

We can see that we have the same var text that declares our variable, and then we tell the game that our variable is an int. Finally, we set the name of our int to NumberOfKittens.

The name of the variable should give a hint as to the difference between ints and floats, and why we need ints to begin with instead of using floats for everything. Since we don't want to hurt any defenseless kittens we should only be using whole numbers to represent the number of them. We don't want to have half of a kitten.

As with our bool variable ints have a default value, in this case zero. We can check this by changing our PostBeginPlay function:

function PostBeginPlay()
{
'log("Number of kittens:" @ NumberOfKittens);
}

Now our AwesomeActor.uc class should look like this:

class AwesomeActor extends Actor
placeable;
var int NumberOfKittens;
function PostBeginPlay()
{
'log("Number of kittens:" @ NumberOfKittens);
}
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_NavP'
HiddenGame=True
End Object
Components.Add(Sprite)
}

Let's compile and run the game to test it out!

[0007.63] ScriptLog: Number of kittens: 0

Notice there is no decimal place after the 0; this is what makes an int an int. We use this type of variable for things that wouldn't have fractions, like the number of kills a player has made in deathmatch or the number of people in a vehicle.

Now let's see what happens when we change the variable. At the beginning of our PostBeginPlay function add this:

NumberOfKittens = 5;

Now the function should look like this:

function PostBeginPlay()
{
NumberOfKittens = 5;
'log("Number of kittens:" @ NumberOfKittens);
}

Let's compile and test!

[0008.07] ScriptLog: Number of kittens: 5

What would happen if we tried to add a fraction to our int? Only one way to find out! Change the line to this and compile:

NumberOfKittens = 5.7;

Well, it compiles, so the engine obviously doesn't care about that .7 of a kitten, but what actually happens? Run the game and then check the log to find out.

[0007.99] ScriptLog: Number of kittens: 5

Interesting! We can see that not only did it ignore the fraction, but also truncated it instead of trying to round it up to 6. This is important behavior to remember about ints. Ints will also act this way when we use math on them.

Change the line to this:

NumberOfKittens = 10 / 3;

This should end up as 3.333333, but with the truncation, we can see that it ignores the fraction.

[0007.72] ScriptLog: Number of kittens: 3

Replace our int declaration with this:

var float DistanceToGo;

Floats have a default value of 0.0. Let's change our PostBeginPlay function to check this.

function PostBeginPlay()
{
'log("Distance to go:" @ DistanceToGo);
}

Compile and test, and our log should look like this:

[0007.61] ScriptLog: Distance to go: 0.0000

We can see that unlike ints, floats will log with a decimal place. Let's see if we can change the value. Add this line to the beginning of our PostBeginPlay function:

DistanceToGo = 0.123;

Compile and test, and we should see the fraction show up in the log:

[0007.68] ScriptLog: Distance to go: 0.123

Let's see what happens when we use the same line we did for our int. Change the line to this:

DistanceToGo = 10 / 3;

Compile and test, and our log should look like this:

[0007.68] ScriptLog: Distance to go: 3.3333

Change our float declaration to this:

var string DeathMessage;

By default, strings are empty. We can see this... or not see this, rather, by changing our PostBeginPlay function:

function PostBeginPlay()
{
'log("Death message:" @ DeathMessage);
}

Compile and test to see that nothing shows up:

[0007.74] ScriptLog: Death message:

Well that doesn't help much. Let's change that.

Add this line to our PostBeginPlay function:

DeathMessage = "Tom Stewart killed me!";

Now it looks like this:

function PostBeginPlay()
{
DeathMessage = "Tom Stewart killed me!";
'log("Death message:" @ DeathMessage);
}

Compile and run the code, and check the log.

[0007.67] ScriptLog: Death message: Tom Stewart killed me!

Add the enum below our class line.

enum EAltitude
{
ALT_Underground,
ALT_Surface,
ALT_Sky,
ALT_Space,
};

The E isn't necessary, but it helps to follow standard guidelines to make things easier to read.

Now we need to declare a variable as that enum type. This is similar to declaring other variables.

var EAltitude Altitude;

Now we have a variable, Altitude, that's been declared as the enum type EAltitude. Enums default to the first value in the list, so in this case it would be ALT_Underground. Let's see if we can change that in our PostBeginPlay function.

function PostBeginPlay()
{
Altitude = ALT_Sky;
'log("Altitude:" @ Altitude);
}

Now our class should look like this:

class AwesomeActor extends Actor
placeable;
enum EAltitude
{
ALT_Underground,
ALT_Surface,
ALT_Sky,
ALT_Space,
};
var EAltitude Altitude;
function PostBeginPlay()
{
Altitude = ALT_Sky;
'log("Altitude:" @ Altitude);
}
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_NavP'
HiddenGame=True
End Object
Components.Add(Sprite)
}

Compile and test, and we'll see the enum show up in the log:

[0007.69] ScriptLog: Altitude: ALT_Sky

To see how they compare to each other, let's add another log after our first one:

'log("Is ALT_Sky greater than ALT_Surface?");
'log(EAltitude.ALT_Sky > EAltitude.ALT_Surface);

Doing a comparison like this will come back with a boolean true or false for the answer, which we'll see in the log when we compile and test:

[0007.71] ScriptLog: Altitude: ALT_Sky
[0007.71] ScriptLog: Is ALT_Sky greater than ALT_Surface?
[0007.71] ScriptLog: True

Change our variable declaration line to this:

var int Baskets[4];

This will create an array of four baskets. That's easy enough, but how do we change their values?

In our PostBeginPlay function, add these lines:

Baskets[0] = 2;
Baskets[1] = 13;
Baskets[2] = 4;
Baskets[3] = 1;

One important thing to remember about arrays is that they start at 0. Even though we have 4 elements in our array, since it starts at 0 it only goes up to 3. If we tried to add a line like this to our function:

Baskets[4] = 7;

We would get an error.

Let's go ahead and add the line to see what happens. It will compile just fine, but when we test it in the game we will see the error in the log file:

[0007.53] ScriptWarning: Accessed array 'AwesomeActor_0.Baskets' out of bounds (4/4)
AwesomeActor UEDPCAwesomeMap.TheWorld:PersistentLevel.AwesomeActor_0
Function AwesomeGame.AwesomeActor:PostBeginPlay:0046

The out of bounds error lets us know that we tried to access an element of the array that doesn't exist. It takes a bit of getting used to; just remember that the first element of our array will always be 0.

Let's take that line out of our function, and change the log line to look like this:

'log("Baskets:" @ Baskets[0] @ Baskets[1] @ Baskets[2] @ Baskets[3]);

Now our PostBeginPlay function should look like this:

function PostBeginPlay()
{
Baskets[0] = 2;
Baskets[1] = 13;
Baskets[2] = 4;
Baskets[3] = 1;
'log("Baskets:" @ Baskets[0] @ Baskets[1] @ Baskets[2] @ Baskets[3]);
}

Let's compile and test. In our log file we should see this:

[0007.53] ScriptLog: Baskets: 2 13 4 1

Success!

Now for something a bit more complicated. We can also access the elements of our array with an int. Let's see if we can do that. Let's declare an int:

var int TestNumber;

Then set it at the beginning of PostBeginPlay:

TestNumber = 2;

Now let's access the array with it and log the result.

'log("Test Basket:" @ Baskets[TestNumber]);

So now our class should look like this:

class AwesomeActor extends Actor
placeable;
var int Baskets[4];
var int TestNumber;
function PostBeginPlay()
{
TestNumber = 2;
Baskets[0] = 2;
Baskets[1] = 13;
Baskets[2] = 4;
Baskets[3] = 1;
'log("Test Basket:" @ Baskets[TestNumber]);
}
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_NavP'
HiddenGame=True
End Object
Components.Add(Sprite)
}

Now compile and test, then look at the log.

[0007.99] ScriptLog: Test Basket: 4

We can see that it logged the value of Basket[2], which is 4.

Change our variable declaration line to this:

var array<int> Baskets;

As we can see, with dynamic arrays we don't put a number anywhere in it; it can be whatever size we need it to be. By default they're completely empty, so if we tried to log any of its values we would get an out of bounds warning similar to our experiment with static arrays.

We can, however, assign values any time we want, so let's add this line to our PostBeginPlay function:

Baskets[3] = 9;

Then log the value like this:

'log("Baskets:" @ Baskets[3]);

Now our function should look like this:

function PostBeginPlay()
{
Baskets[3] = 9;
'log("Baskets:" @ Baskets[3]);
}

Compile and test, and we can see that the value logs fine, and we didn't get any warnings.

[0007.82] ScriptLog: Baskets: 9

When we assign a value, the size of the array automatically changes to that value. As with before, if we tried to access Baskets[4] we would get an out of bounds warning.

Now that we have our dynamic array, there are a few things we need to know about so we can use them properly. The first thing that would be nice to know is the size of the array. Just how many baskets are there anyway? To find out we can use the length of the array.

Change our log line to look like this:

'log("Basket array length:" @ Baskets.length);

Now our function looks like this:

function PostBeginPlay()
{
Baskets[3] = 9;
'log("Basket array length:" @ Baskets.length);
}

Compile and test, and check the log file.

[0007.67] ScriptLog: Basket array length: 4

Remember that arrays start out at 0, so when we assigned a value to Basket[3] it's the fourth element in the array.

Now that we know the length of the array, we can use it to add values to the end of it. In our example, the length of the array is 4, with Baskets[3] being the last one. If we wanted to add another one to the array, it would be Baskets[4]. Since 4 is the length of our array right now, we would simply put that in the index.

Let's add these three lines to the end of our function:

Baskets[Baskets.length] = 23;
'log("Basket array length:" @ Baskets.length);
'log("Last basket:" @ Baskets[Baskets.length - 1]);

Our function should look like this now:

function PostBeginPlay()
{
Baskets[3] = 9;
'log("Basket array length:" @ Baskets.length);
Baskets[Baskets.length] = 23;
'log("Basket array length:" @ Baskets.length);
'log("Last basket:" @ Baskets[Baskets.length - 1]);
}

The value 23 will now be assigned to the next element in the array, which now expands to five elements.

Remember that the length is one higher than the last index, so to see what the last value is we need to subtract 1 from the array length. In this case the length would be 5, so to check the last one, Basket[4], we need to use 5-1.

Compile and test, then check the log.

[0008.46] ScriptLog: Basket array length: 4
[0008.46] ScriptLog: Basket array length: 5
[0008.46] ScriptLog: Last basket: 23

Let's create a struct at the top of our AwesomeActor class and put a few things in it.

struct Basket
{
var string BasketColor;
var int NumberOfKittens, BallsOfString;
var float BasketSize;
};

Now we have two types of items in the basket as well as some variables to describe the basket itself.

Now we need a variable of that struct so we can use it:

var Basket MyBasket;

Now we can change the values in our PostBeginPlay function.

function PostBeginPlay()
{
MyBasket.NumberOfKittens = 4;
MyBasket.BasketColor = "Yellow";
MyBasket.BasketSize = 12.0;
MyBasket.BallsOfString = 2; }

That seems easy enough to handle. Let's try something a bit more complex.

I heard you like structs, so we'll Inception-ize it by adding a struct inside a struct.

struct SmallBox
{
var int Chocolates;
var int Cookies;
};

Now let's put a box inside our basket struct.

struct Basket
{
var SmallBox TheBox;
var string BasketColor;
var int NumberOfKittens, BallsOfString;
var float BasketSize;
};

Now our class should look like this:

class AwesomeActor extends Actor
placeable;
struct SmallBox
{
var int Chocolates;
var int Cookies;
};
struct Basket
{
var SmallBox TheBox;
var string BasketColor;
var int NumberOfKittens, BallsOfString;
var float BasketSize;
};
var Basket MyBasket;
function PostBeginPlay()
{
MyBasket.NumberOfKittens = 4;
MyBasket.BasketColor = "Yellow";
MyBasket.BasketSize = 12.0;
MyBasket.BallsOfString = 2;
}
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_NavP'
HiddenGame=True
End Object
Components.Add(Sprite)
}

Now we're getting somewhere. How would we access the struct inside a struct? Using the same method as before, we would access the box like this:

MyBasket.TheBox

So accessing variables inside the box struct would look like this:

MyBasket.TheBox.Chocolates = 2;

Easy enough. It would work the same way with arrays. Let's say we added a static array of fortune cookie messages to our basket. Our new struct would look something like this:

struct Basket
{
var string Fortunes[4];
var SmallBox TheBox;
var string BasketColor;
var int NumberOfKittens, BallsOfString;
var float BasketSize;
};

To assign a value to one of them, we would use the same method as before:

MyBasket.Fortunes[2] = "Now you're programming!";

First we'll declare a vector of our own at the top of our class.

var vector LocationOffset;

Vectors have their X, Y, and Z values set to 0.0 by default. We'll give ours a new value and add that to our actor's current location in our PostBeginPlay function.

function PostBeginPlay()
{
LocationOffset.Z = 64.0;
SetLocation(Location + LocationOffset);
}

When used as a location, the Z float inside a vector represents the up and down axis. Making the values of Z greater means moving it up, lower or more negative means moving it down. In our example we're going to move the actor up 64 units. We use the function in the second line, SetLocation, to tell the game to move our AwesomeActor. Since we already know its current location with the Location variable, we just add our LocationOffset to move it up 64 units.

There's one thing we need to do before we test this out. When we first created our AwesomeActor, we made it invisible in game. Let's change that so we can see what happens. In the default properties of our actor, delete this line:

HiddenGame=False

Now our AwesomeActor should look like this:

class AwesomeActor extends Actor
placeable;
var vector LocationOffset;
function PostBeginPlay()
{
LocationOffset.Z = 64.0;
SetLocation(Location + LocationOffset);
}
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_NavP'
End Object
Components.Add(Sprite)
}

Let's compile and test! In the editor, we can see our AwesomeActor still halfway stuck in the floor:

Run the game from the editor, and we can see that our code has worked! The AwesomeActor has moved up:

That seems like a bit too much code just to add two vectors together. Luckily, there's a much simpler way to use vectors to do what we want here. Vectors can be created and assigned a value at the same time that we're using it in code, like this:

vect(X value, Y value, Z value)

So if we just wanted to move our actor up 64 units, we could do it all on one line.

Let's get rid of our LocationOffset variable line and change our PostBeginPlay to look like this:

function PostBeginPlay()
{
SetLocation(Location + vect(0,0,64));
}

Compile and test, and we get the same result!

Another useful function we can use with vectors is called VSize. If you remember your old geometry lessons, Pythagoras' Theorem lets us find the hypotenuse of a triangle by using the two sides. We can use a 3D version of the same equation to find the length of our vector.

With that diagram, the length of Vector would be expressed as this:

Length = √(X² + Y² + Z²)

With VSize, all of that is done for us:

Length = VSize(Vector)

So with that in mind, let's find out how far our AwesomeActor is from the world origin (0,0,0).

Let's change our PostBeginPlay function to this:

function PostBeginPlay()
{
'log("Distance:" @ VSize(Location));
}

Compile and test, and the answer shows up in the log!

[0007.88] ScriptLog: Distance: 2085.2571

Below the sprite in the default properties, add this:

Begin Object Class=ArrowComponent Name=Arrow
End Object
Components.Add(Arrow)

We're going to log our actor's current rotation, so inside our PostBeginPlay add this:

'log("Rotation:" @ Rotation);

Our class should now look like this:

class AwesomeActor extends Actor
placeable;
function PostBeginPlay()
{
'log("Rotation:" @ Rotation);
}
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_NavP'
End Object
Components.Add(Sprite)
Begin Object Class=ArrowComponent Name=Arrow
End Object
Components.Add(Arrow)
}

Compile and take a look in the editor. Our actor now has an arrow to indicate its current rotation.

By default we know its current rotation is going to be (0,0,0), so let's rotate it in the editor. Click on the AwesomeActor to select it, and then press the Space bar once to change to the rotation tool.

Now click and hold anywhere on the blue part of the rotation tool. We're going to change our actor's Yaw, so move it as close to 90 degrees as you can get. Don't worry if it's not perfect.

Save our map, and then run it in the game. Exit and check the log for our rotation value.

[0008.33] ScriptLog: Rotation: 0,16160,0

Let's start by defining some variables in our AwesomeActor class.

var string MyName;
var int NumberOfKittens;
var float DistanceToGo;

In our default properties block, we can give these variables initial values. These are assigned before any of the code is run.

Defaultproperties
{
MyName="Rachel"
NumberOfKittens=3
DistanceToGo=120.0
}

In our PostBeginPlay function, instead of changing the values we'll just log them to see the default properties in action.

function PostBeginPlay()
{
'log("MyName:" @ MyName);
'log("NumberOfKittens:" @ NumberOfKittens);
'log("DistanceToGo:" @ DistanceToGo);
}

Now our class should look like this:

class AwesomeActor extends Actor
placeable;
var string MyName;
var int NumberOfKittens;
var float DistanceToGo;
function PostBeginPlay()
{
'log("MyName:" @ MyName);
'log("NumberOfKittens:" @ NumberOfKittens);
'log("DistanceToGo:" @ DistanceToGo);
}
defaultproperties
{
MyName="Rachel"
NumberOfKittens=3
DistanceToGo=120.0
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_NavP'
End Object
Components.Add(Sprite)
}

Now let's look at the log.

[0008.73] ScriptLog: MyName: Rachel
[0008.73] ScriptLog: NumberOfKittens: 3
[0008.73] ScriptLog: DistanceToGo: 120.0000

Arrays have a slightly different syntax in the default properties. When used in code we use brackets to define the index, like MyArray[2]. In the default properties, we use parentheses instead.

MyArray(0)=3
MyArray(1)=2

You'll also notice that none of the lines in the default properties block have a semicolon at the end. The default properties block is the only place where we don't use them. You'll also notice that there are no spaces before or after the equal sign. This is also a quirk of the default properties block. If the formatting isn't correct you may get a compiler error or even worse, it may compile but ignore your default properties altogether. Make sure to follow these guidelines for the formatting, including having the curly brackets on their own lines. Some programmers like to have the opening curly bracket on the same line, but with UnrealScript's defaultproperties block, this would cause it to ignore all of the default properties.

Moving on! For structs, we define the default properties right inside the struct, not in the defaultproperties block. So taking our example struct from earlier, we would define the defaults for it like this:

struct Basket
{
var string BasketColor;
var int NumberOfKittens, BallsOfString;
var float BasketSize;
structdefaultproperties
{
BasketColor="Blue"
NumberOfKittens=3
BasketSize=12.0
}
};

This one's simple. To make a variable changeable in the editor, add a set of parentheses after var, like this:

var() int MyEditableInt;

Add that variable to our class, then compile and open the editor. Double-click on the AwesomeActor to open up its properties, and we'll see the variable show up.

We can also put it in a specific category if we wanted to separate our variables into groups. Let's see what it would look like in the Physics tab.

var(Physics) int MyEditableInt;

Let's compile and take a look.

To let the game know that our class needs to save config variables, first we need to let it know which file to use.

class AwesomeActor extends Actor
placeable
config(Game);

This tells the game that our class' config variables will be defined in the Game ini files as opposed to Engine or Input and so on.

Now, let's make a config variable.

var config int MyConfigInt;

Config vars can have parentheses to let level designers change them, but they can NOT be put in the default properties block. Doing so will give a compiler error. Instead, we define their default properties in the INI file we specified. Since we used Game, we would put the default in DefaultGame.ini. Let's open that up now.

In DefaultGame.ini we can see a bunch of different sections, starting with a line surrounded by brackets. The inside of these brackets specifies the package and class that the section is defining defaults for, like this:

[Package.Class]

In our case our package name is AwesomeGame, and the class we need to define is AwesomeActor. At the end of DefaultGame.ini, make a new section surrounded by brackets.

[AwesomeGame.AwesomeActor]

Right after that we can define any default values we need.

MyConfigInt=3

Once we're done, our section should look like this:

[AwesomeGame.AwesomeActor]
MyConfigInt=3

Let's see if it works! In AwesomeActor.uc, change PostBeginPlay to log MyConfigInt.

var config int MyConfigInt;
function PostBeginPlay()
{
'log("MyConfigInt:" @ MyConfigInt);
}

Compile and run, then check the log file.

[0008.66] ScriptLog: MyConfigInt: 3

As an example, take a look at this code.

var float Float1, Float2;
var int Int1;
function PostBeginPlay()
{
Float2 = Int1 / Float1;
'log("Float2:" @ Float2);
}
defaultproperties
{
Int1=5
Float1=2.0
}

We can divide an int by a float or vice versa, and we get the result we expect:

[0008.10] ScriptLog: Float2: 2.5000

However, if we divide an int by an int and assign it to a float, what would we expect the result to be?

Let's take a look at this code:

var float Float1;
var int Int1, Int2;
function PostBeginPlay()
{
Float1 = Int1 / Int2;
'log("Float1:" @ Float1);
}
defaultproperties
{
Int1=5
Int2=2
}

With that it looks like we'd expect the same result. Let's take a look at the log:

[0007.66] ScriptLog: Float1: 2.0000

When dividing ints, the truncating happens before assigning the result, even if it's a float. Depending on what we're doing this may be what we want, but it's good to keep that in mind.

Two other operators that can be used for simple math are increment ( ++ ) and decrement ( -- ).

Int1 = 5;
Int1++;
'log("Int1" @ Int1);

This would give us 6 in the log.

For vectors and rotators, the arithmetic works with each element of the struct individually. For example, with the following code:

var vector Vect1, Vect2, VectResult;
function PostBeginPlay()
{
VectResult = Vect1 + Vect2;
'log("VectResult:" @ VectResult);
}
defaultproperties
{
Vect1=(X=1.0,Y=4.5,Z=12.0)
Vect2=(X=2.0,Y=4.0,Z=8.0)
}

We get the following result in the log:

[0007.74] ScriptLog: VectResult: 3.00,8.5,20.00

As we can see, each individual element has been worked with separately. X added to X, Y to Y, and Z to Z.

Vectors can also be multiplied or divided by floats and ints. This has the effect of changing the vector's VSize while keeping the direction the same.

Let's look at an example.

var int Int1, Int2, IntResult;
function PostBeginPlay()
{
IntResult = Int1 % Int2;
'log("IntResult:" @ IntResult);
}
defaultproperties
{
Int1=28
Int2=5
}

28 divided by 5 is 5 with a remainder of 3.

Let's look at the log:

[0008.12] ScriptLog: IntResult: 3

Let's take a look at two ints and the various comparison operators we can use on them.

var int Int1, Int2;
function PostBeginPlay()
{
'log(Int1 == Int2);
}
defaultproperties
{
Int1=5
Int2=5
}

Setting both of them to the same value and using the equal comparison gives us True in the log:

[0007.79] ScriptLog: True

If the variables weren't exactly the same, we would get False.

The opposite of this comparison is "Not Equal", which is denoted by an exclamation point followed by an equal sign. If we wanted to know if two variables weren't the same, we would use this.

var int Int1, Int2;
function PostBeginPlay()
{
'log(Int1 != Int2);
}
defaultproperties
{
Int1=3
Int2=5
}

Since they have different values, we'll get True in the log again:

[0007.70] ScriptLog: True

Equal or not equal also apply to vectors and rotators. Each element in those structs is compared to each other, and it will return False if any of them are different.

For greater than or less than, we would simply use those symbols.

var int Int1, Int2;
function PostBeginPlay()
{
'log(Int1 < Int2);
'log(Int1 > Int2);
}
defaultproperties
{
Int1=3
Int2=5
}
And the log:
[0007.60] ScriptLog: True
[0007.60] ScriptLog: False

The same works for "greater than or equal to" and "less than or equal to", we simply follow it with an equal sign:

var int Int1, Int2;
function PostBeginPlay()
{
'log(Int1 <= Int2);
'log(Int1 >= Int2);
}
defaultproperties
{
Int1=5
Int2=5
}

The log for this:

[0007.45] ScriptLog: True
[0007.45] ScriptLog: True

Greater than or less than do not apply to vectors or rotators and the compiler will give an error if we try to use them.

A special comparison operator for floats and strings is the "approximately equal to" operator, denoted by a tilde followed by an equal sign ( ~= ). For floats, it returns true, if they are within 0.0001 of each other, useful for making sure complicated equations don't have to return the exact same result, just close enough to account for rounding errors.

var float Float1, Float2;
function PostBeginPlay()
{
'log(Float1 ~= Float2);
}
defaultproperties
{
Float1=1.0
Float2=1.000001
}

This returns True in the log:

[0007.94] ScriptLog: True

For strings, the "approximately equal to" operator is a case-insensitive comparison.

var string String1, String2;
function PostBeginPlay()
{
'log(String1 ~= String2);
}
defaultproperties
{
String1="STRING TEST"
String2="string test"
}

The log:

[0007.74] ScriptLog: True

Let's put our first example in code.

var bool bRaining;
var float CurrentMoney, RequiredMoney;
function PostBeginPlay()
{
'log(!bRaining && CurrentMoney > RequiredMoney);
}
defaultproperties
{
CurrentMoney=20.0
RequiredMoney=15.0
}

Remembering that bools are false by default, let's take a look at the log:

[0007.94] ScriptLog: True

Even though bRaining is False, we're asking the code if it's NOT raining, which is True. You can see why naming booleans is important now. If our variable were called bNotRaining, working with logical operators would get messy pretty quickly.

Let's look at our second example.

var string Day;
function PostBeginPlay()
{
'log(Day == "Tuesday" || Day == "Thursday");
}
defaultproperties
{
Day="Monday"
}

Since the day variable is neither of those two, we'll get False in the log:

[0007.79] ScriptLog: False

One final operator to discuss is the EXCLUSIVE OR, denoted by two carets ( ^^ ). This will return true if one and only one of our statements is true. Let's look at the following code:

var string Day, Month;
function PostBeginPlay()
{
'log(Day == "Tuesday" ^^ Month == "January");
}
defaultproperties
{
Day="Tuesday"
Month="January"
}

If we were using a normal OR, this would return true, but since both of them are true, an EXCLUSIVE OR returns false:

[0007.60] ScriptLog: False

Let's write some code.

var string String1, String2, AtSign, DollarSign;
function PostBeginPlay()
{
AtSign = String1 @ String2;
DollarSign = String1 $ String2;
'log("At sign:" @ AtSign);
'log("Dollar sign:" @ DollarSign);
}
defaultproperties
{
String1="This is"
String2="a test."
}

Looking at the log shows us the minor difference between the two:

[0007.77] ScriptLog: At sign: This is a test.
[0007.77] ScriptLog: Dollar sign: This isa test.

The choice between them is as simple as the space between the joined strings.

The concatenation operators can also be used with equal signs to shorten the code and get rid of the need for extra variables. The @ code could also be written like this:

var string String1, String2;
function PostBeginPlay()
{
String1 @= String2;
'log("String1:" @ String1);
}
defaultproperties
{
String1="This is"
String2="a test."
}

Take the following code:

var int Int1, Int2;
function PostBeginPlay()
{
if(Int1 > Int2)
'log("Int1 is greater than Int2");
else if(Int1 == Int2)
'log("Int1 is equal to Int2");
else
'log("Int1 is less than Int2");
}
defaultproperties
{
Int1=5
Int2=2
}

What would we expect the result to be? Let's look at the log for the answer:

[0007.72] ScriptLog: Int1 is greater than Int2

Let's examine the following code:

var int m;
function PostBeginPlay()
{
for(m = 0; m < 3; m++)
{
'log("Stop hitting yourself." @ m);
}
}

This is a simple way of writing the following code:

m = 0;
'log(m);
m = 1;
'log(m);
m = 2;
'log(m);

As an example of what NOT to do, let's take this code.

var int Int1;
function PostBeginPlay()
{
Int1 = 5;
While(Int1 > 0)
{
Int1 = 5;
}
}

When we run the game with this code, it will crash.

It is EXTREMELY IMPORTANT to always make sure the "while" condition will be met to avoid infinite loop crashes.

Let's take a look at the right way to use it:

var int Int1;
function PostBeginPlay()
{
While(Int1 < 5)
{
'log("Int1" @ Int1);
Int1++;
}
}

In this case, Int1 will keep incrementing until it reaches 5, and the While loop will exit.

We could also use a statement called break to exit the loop:

var int Int1;
function PostBeginPlay()
{
While(Int1 < 5)
{
'log("Int1" @ Int1);
Int1++;
if(Int1 == 3)
break;
}
}

In this case, the loop will exit when Int1 reaches 3 instead of continuing until it hits 5.

Another statement we can use is called continue. Instead of exiting the loop completely, it just skips to the next cycle.

var int Int1;
function PostBeginPlay()
{
While(Int1 < 5)
{
'log("Int1" @ Int1);
Int1++;
if(Int1 == 3)
continue;
'log("This will not log if Int1 is 3");
}
}

Let's take a look at an example of a Switch statement.

var int Int1;
function PostBeginPlay()
{
Int1 = 2;
switch(Int1)
{
case 1:
'log("Int1 == 1");
case 2:
'log("Int1 == 2");
case 3:
'log("Int1 == 3");
default:
'log("Int1 isn't any of those!");
}
}

Running the code, the log looks like this:

[0007.97] ScriptLog: Int1 == 2
[0007.97] ScriptLog: Int1 == 3
[0007.97] ScriptLog: Int1 isn't any of those!