Unreal Development Kit Game Programming with UnrealScript: Beginner's Guide: Create games beyond your imagination with the Unreal Development Kit

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...

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;
...

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...

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...

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...

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...

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...

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...

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...

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...

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...

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...

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...

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...

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...

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...

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!