Create a copy of AwesomeTestMap.udk in the UDKGameContentMapsAwesomeGame folder and call it BrokenMap.udk.

Open BrokenMap.udk in the editor.

Delete all of the Kismet, plus all of the AwesomeEnemySpawners and other actors on the map apart from PlayerStart, the ground, and the lights.

Save and close the map.

Create a new folder in the DevelopmentSrc folder called BrokenGame.

Create a folder inside BrokenGame called Classes.

In the BrokenGameClasses folder, create a new file called BrokenActor.uc.

In BrokenActor.uc, write the following code:

class BrokenActor extends Actor
placeable;
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorMaterials.TargetIcon'
Scale=0.35
HiddenGame=true
End Object
Components.Add(Sprite)
}

Before we can compile, we need to add our new package to DefaultEngine.ini. Open UDKGameConfigDefaultEngine.ini, and at the end of the [Engine.ScriptPackages] section add our new package:

[Engine.ScriptPackages]
+NonNativePackages=UTGame
+NonNativePackages=UTGameContent
+NonNativePackages=AwesomeGame
+NonNativePackages=BrokenGame

Also at the end of the [UnrealEd.EditorEngine] section:

[UnrealEd.EditorEngine]
+EditPackages=UTGame
+EditPackages=UTGameContent
+EditPackages=AwesomeGame
+EditPackages=BrokenGame

Save and close DefaultEngine.ini.

Back in ConTEXT, compile our code.

Once it compiles successfully, open BrokenMap in the editor.

Select BrokenActor in the Actor Classes tab of the Content Browser (it will be in the Uncategorized section if you have Show Categories checked), and place one in the map near the player start.

Save the map, but don't close the editor yet.

Let's add a PostBeginPlay function to our class:

simulated function PostBeginPlay()
{
`log("BrokenActor PostBeginPlay!");
}

Compile the code.

At the top of our class, let's change the class declaration:

class Borked extends Actor
placeable;

Now try to compile the code. We'll get this in the log:

[0004.13] Log: R:UDKUDK-AwesomeGameBinaries..DevelopmentSrcBrokenGameClassesBrokenActor.uc : Error, Script vs. class name mismatch (BrokenActor/Borked)

Let's change our BrokenActor to look like this:

class BrokenActor extends Actor
placeable;
var int MyInt;
simulated function PostBeginPlay()
{
if(MyInt > 5)
{
`log("MyInt is greater than 5! MyInt is:" @ MyInt);
}
else
{
`log("MyInt is less than or equal to 5! MyInt is:" @ MyInt);
}
defaultproperties {
MyInt=13
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorMaterials.TargetIcon'
Scale=0.35
HiddenGame=true
End Object
Components.Add(Sprite)
}

Compile the code. We'll see this error pop up:

[0003.94] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(13) : Error, Unexpected end of file at end of Class

Whenever this error shows up, it means we've missed a closing } bracket somewhere. In this case, we haven't properly ended our PostBeginPlay function with one, so let's add it:

simulated function PostBeginPlay()
{
if(MyInt > 5)
{
`log("MyInt is greater than 5! MyInt is:" @ MyInt);
}
else
{
`log("MyInt is less than or equal to 5! MyInt is:" @ MyInt);
}
}

Now let's compile the code. It works this time!

Since we already have BrokenActor placed in our map, we don't need to open the editor for this next step. Instead let's create a copy of our Awesome Test Map.bat batch file and name it Broken Map.bat.

Open Broken Map.bat and change it to look like this:

C:UDKUDK-AwesomeGameBinariesWin32UDK.exe BrokenMap?GoalScore=0?TimeLimit=0 -log

The map name has changed, but also note that we're not running it with AwesomeGame anymore. Goodbye AwesomeGame! You have served us well.

Save and close Broken Map.bat.

Double-click the batch file to run the game. While it's loading think about what we should see in the log. We've set MyInt to 13 in the default properties, so we should see the first log in our script show up. We'll see this isn't the case though:

[0005.20] ScriptLog: MyInt is less than or equal to 5! MyInt is: 0

Well what happened there? Let's change our default properties block. Right now it looks like this:

defaultproperties {
MyInt=13
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorMaterials.TargetIcon'
Scale=0.35
HiddenGame=true
End Object
Components.Add(Sprite)
}

Let's move the first bracket down to the next line, so it looks like this instead:

defaultproperties
{
MyInt=13
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorMaterials.TargetIcon'
Scale=0.35
HiddenGame=true
End Object
Components.Add(Sprite)
}

Now let's compile the code and run the game again:

[0005.40] ScriptLog: MyInt is greater than 5! MyInt is: 13

Let's rewrite our PostBeginPlay function. We'll leave in our MyInt variable and use it for this experiment:

simulated function PostBeginPlay()
{
if(UTGame(WorldInfo.Game != none)
MyInt = UTGame(WorldInfo.Game).DefaultMaxLives;
}

Seems fine, but when we try to compile we get this error:

[0004.84] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(8) : Error, Bad or missing expression for token: UTGame, in 'If'

What could this mean? It seems to be telling us that it doesn't know what UTGame is, even though it's a valid class. If we take a closer look at our if statement, we can see the problem:

if(UTGame(WorldInfo.Game != none)

I'm counting two open parentheses, but only one closed one. If we take the if part out of this line and examine it separately:

UTGame(WorldInfo.Game != none)

To the compiler, it looks like we're trying to call a function called UTGame and that we're trying to send this function a bool (WorldInfo.Game != none). Since it can't find a function called UTGame, it gives us this error:

[0004.84] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(8) : Error, Bad or missing expression for token: UTGame, in 'If'

So the error message might seem misleading, but to the compiler it makes perfect sense.

Let's fix the error by adding the closing parenthesis:

simulated function PostBeginPlay()
{
if(UTGame(WorldInfo.Game) != none)
MyInt = UTGame(WorldInfo.Game).DefaultMaxLives;
}

Now it compiles just fine.

Let's rewrite PostBeginPlay function again:

simulated function PostBeginPlay()
{
MyInt = class'UTGame'.default.CountDown
}

Now let's try to compile.

[0003.91] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(9) : Error, Missing ';' before '}'

Oh, duh, we forgot the semicolon at the end of the line.

simulated function PostBeginPlay()
{
MyInt = class'UTGame'.default.CountDown;
}

Now it compiles!

Let's rewrite our PostBeginPlay function:

simulated function PostBeginPlay()
{
var int AnotherInt;
AnotherInt = class'UTGame'.default.CountDown;
}

Looks fine this time, we have our brackets, parentheses, and semicolons in place. What could go wrong?

[0003.93] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(8) : Error, Instance variables are only allowed at class scope (use 'local'?)

Oh, right. Inside functions we're only allowed to use local variables. Let's fix that real quick:

simulated function PostBeginPlay()
{
local int AnotherInt;
AnotherInt = class'UTGame'.default.CountDown;
}

Now it should work, so let's compile it:

[0004.08] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(10) : Warning, 'AnotherInt' : unused local variable

Well this is new, a warning this time instead of an error! Unused local variable. We're assigning a value to it, but we're never actually using it anywhere. Warnings aren't game breaking and they won't prevent the code from compiling, they're more helpful hints. In this case it's saying hey, if you're not doing anything with this variable do you really need it at all? We can delete it and the line assigning it a value, but instead let's just use it in a log:

simulated function PostBeginPlay()
{
local int AnotherInt;
AnotherInt = class'UTGame'.default.CountDown;
`log("AnotherInt is:" @ AnotherInt);
}

This time it compiles fine, no errors, and no warnings.

Let's add a new function to our class:

simulated function HitWall()
{
}

Compile the code and we'll get this error:

[0003.93] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(4) : Error, Redefinition of 'function HitWall' differs from original; different number of parameters

If we look at Actor.uc we can see the original declaration of this function:

event HitWall( vector HitNormal, actor Wall, PrimitiveComponent WallComp )

When overriding a function, you must use the same parameters as the original. You can change the names if you want, for instance this would work:

simulated function HitWall( vector Norm, actor HitActor, PrimitiveComponent Prim )
{
}

The number and type of parameters must stay the same though.

This type of error usually results from misreading the parameters when overriding a function, or accidentally making up a function that already exists in a superclass.

The same thing can happen with return values. Let's rewrite our HitWall function to look like this:

simulated function bool HitWall( vector Norm, actor HitActor, PrimitiveComponent Prim )
{
}

Compile the code and we'll get this error:

[0003.84] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(4) : Error, Redefinition of 'function HitWall' differs from original: return value mismatch

This is most commonly caused by not including the return value when you write your function.

Along the same lines, we can accidentally leave out the return value for a function. Let's delete HitWall and add this made up function:

function bool AmIAwesome()
{
return;
}

If we try to compile the preceding code we'll get this error:

[0003.82] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(6) : Error, Bad or missing expression in 'Return'

Let's change the function to look like this:

function bool AmIAwesome()
{
return 5;
}

Trying to compile this code would give us a different error stemming from the same problem of the wrong type of return value:

[0003.84] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(6) : Error, Type mismatch in 'Return'

Say we had the following code:

simulated function PostBeginPlay()
{
`log("PostBeginPlay!");
}
simulated function PostBeginPlay()
{
local int SomeInt;
SomeInt = 5;
`log("SomeInt is:" @ SomeInt);
}

The code seems fine, but if we compile it we get:

[0003.86] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(9) : Error, 'PostBeginPlay' conflicts with 'Function BrokenGame.BrokenActor:PostBeginPlay'

This one's easy to avoid. Classes can only have one function with any one name; trying to have more than one with the same name will give us an error.

This next one's a bit obscure, since static functions aren't used that much. Suppose we had this code:

static function float GetRadius()
{
local float Radius, Height;
GetBoundingCylinder(Radius, Height);
return Radius;
}

Trying to compile that would give us this error:

[0003.87] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(7) : Error, Can't call instance functions from within static functions

Let's say this Actor killed anyone who touched it while holding a weapon. We might have a function that looked something like this:

event Bump( Actor Other, PrimitiveComponent OtherComp, Vector HitNormal )
{
if(Other.Weapon != none)
Other.Suicide();
}

Compiling this code gives us an error:

[0003.90] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(6) : Error, Unrecognized member 'Weapon' in class 'Actor'

What's causing this error? If we search Actor.uc we won't find a Weapon variable; what we meant to do is check if the actor bumping us is a Pawn, and check if that Pawn has a weapon. Let's rewrite the function a bit:

event Bump( Actor Other, PrimitiveComponent OtherComp, Vector HitNormal )
{
if(Pawn(Other) != none && Pawn(Other).Weapon != none)
Other.Suicide();
}

Now we're checking if Other is Pawn and if it is, if it has Weapon.

If we try to compile now we'll receive another error message:

[0003.87] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(7) : Error, Unrecognized member 'Suicide' in class 'Actor'

We're running into the same problem here, Actor doesn't have a function called Suicide, but Pawn does. Let's change the function again:

event Bump( Actor Other, PrimitiveComponent OtherComp, Vector HitNormal )
{
if(Pawn(Other) != none && Pawn(Other).Weapon != none)
Pawn(Other).Suicide();
}

Compiling this time works fine.

Of course, the opposite problem is also true. Let's take a look at this function:

function KilledBy( Pawn EventInstigator )
{
if(Pawn(EventInstigator) != none)
Pawn(EventInstigator).Suicide();
}

If we compile that, we get this error:

[0003.88] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(6) : Error, Cast from 'Pawn' to 'Pawn' is unnecessary

We don't need to typecast if the variable is already the type of variable we need. If we rewrote it like this:

function KilledBy( Pawn EventInstigator )
{
if(Actor(EventInstigator) != none)
Actor(EventInstigator).Suicide();
}

We would get the same error:

[0003.89] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(6) : Error, Cast from 'Pawn' to 'Actor' is unnecessary

The correct way to write this particular function would be:

function KilledBy( Pawn EventInstigator )
{
if(EventInstigator != none)
EventInstigator.Suicide();
}

Let's take a look at this PostBeginPlay function:

simulated function PostBeginPlay()
{
local int Int1, Int2;
Int1 = 3;
Int2 = 5;
Int1 + Int2;
}

If we try to compile that, we'll get this error message:

[0003.77] Error: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(11) : Error, ';': Expression has no effect

The source of that error is in this line:

Int1 + Int2;

We're not assigning the result of that to any variable, and we're not using it as a comparison or anything like that. If we wrote it like the following we wouldn't get the error:

Int1 = Int1 + Int2;

Not something you'd come across often, but it's good to know what the error message means.

You would also get the same error message if a function parameter had the same name as another function, and you tried calling that function as in the following code:

function bool UsedBy(Pawn Bump)
{
Bump(none, none, vect(0,0,0));
}

In this case we're naming the parameter Bump, which is the same name as a function that already exists for Actor classes. When we try calling Bump the function, it thinks we're trying to typecast the variable, giving us an error.

Variable declarations themselves are pretty simple as long as we remember when to use var and when to use local. There is one special case that you may come across. If we wanted to make an array of class variables, we would want to write it like the following:

var array<class<Projectile>> ProjectileClasses;

This is different than having an array of actual Projectile actors, here we're just specifying class names.

If we compiled that code, we would get this error:

[0003.87] Log: R:UDKUDK-AwesomeGameDevelopmentSrcBrokenGameClassesBrokenActor.uc(4) : Error, Missing '>' in 'class limitor'

The reason that error comes up is that the compiler thinks that the two greater-than signs ( >> ) are bitwise or vector rotating operator. To fix this, we would put a space in between them:

var array<class<Projectile> > ProjectileClasses;

Let's say we wanted to know the speed of a Projectile. We could add a variable and write a function like this in our PostBeginPlay:

var Projectile MyProjectile;
simulated function PostBeginPlay()
{
local float ProjectileSpeed;
ProjectileSpeed = MyProjectile.Speed;
`log("ProjectileSpeed:" @ ProjectileSpeed);
}

Compile the code and run the game.

Exit the game and check the log:

[0004.99] ScriptWarning: Accessed None 'P'
BrokenActor BrokenMap.TheWorld:PersistentLevel.BrokenActor_0
Function BrokenGame.BrokenActor:PostBeginPlay:004F
[0004.99] ScriptLog: ProjectileSpeed: 0.0000

We're getting an Accessed None warning and the speed is logging as 0. That doesn't seem right, especially when the default for the Projectile class is 2000. Let's add another log to see what's going on:

var Projectile MyProjectile;
simulated function PostBeginPlay()
{
local float ProjectileSpeed;
`log("Projectile:" @ P);
ProjectileSpeed = P.Speed;
`log("ProjectileSpeed:" @ ProjectileSpeed);
}

Compile the code and run the game.

Exit the game and check the log again:

[0005.03] ScriptLog: Projectile: None
[0005.03] ScriptWarning: Accessed None 'P'
BrokenActor BrokenMap.TheWorld:PersistentLevel.BrokenActor_0
Function BrokenGame.BrokenActor:PostBeginPlay:004F
[0005.03] ScriptLog: ProjectileSpeed: 0.0000

Let's add the lines to our PostBeginPlay function:

var Projectile MyProjectile;
simulated function PostBeginPlay()
{
local float ProjectileSpeed;
foreach DynamicActors(class'Projectile', MyProjectile)
break;
`log("Projectile:" @ MyProjectile);
ProjectileSpeed = MyProjectile.Speed;
`log("ProjectileSpeed:" @ ProjectileSpeed);
}

Now the code will search for a Projectile and assign it to our MyProjectile variable.

Compile the code and run the game.

Exit the game and take a look at the log:

[0005.14] ScriptLog: Projectile: None
[0005.14] ScriptWarning: Accessed None 'MyProjectile'
BrokenActor BrokenMap.TheWorld:PersistentLevel.BrokenActor_0
Function BrokenGame.BrokenActor:PostBeginPlay:004F
[0005.14] ScriptLog: ProjectileSpeed: 0.0000

Well that didn't work, and if we think about it it's obvious why. PostBeginPlay is run as soon as the game starts, so there aren't going to be any Projectile actors on the map.

In addition to the warning, when we try to access any variables or functions, we can also get another error if we try to assign any values to variables in a non-existent actor. If we changed our function to this, for instance:

var Projectile MyProjectile;
simulated function PostBeginPlay()
{
foreach DynamicActors(class'Projectile', MyProjectile)
break;
MyProjectile.Speed = 1000.0;
}

Instead of just accessing the Speed variable, we're trying to assign a value here. Let's compile the code and run the game.

Exit the game and take a look at the log:

[0005.15] ScriptWarning: Accessed None 'MyProjectile'
BrokenActor BrokenMap.TheWorld:PersistentLevel.BrokenActor_0
Function BrokenGame.BrokenActor:PostBeginPlay:0029
[0005.16] ScriptWarning: Attempt to assign variable through None
BrokenActor BrokenMap.TheWorld:PersistentLevel.BrokenActor_0
Function BrokenGame.BrokenActor:PostBeginPlay:003D

That second line is new, and is caused by the following line:

MyProjectile.Speed = 1000.0;

The game is letting us know that we're trying to assign a value to a variable in an actor that doesn't exist.

These warnings are helpful, but how do we avoid Accessed None warnings? Let's use a conditional statement to check if our actor variable has anything assigned to it before we try to use it:

var Projectile MyProjectile;
simulated function PostBeginPlay()
{
foreach DynamicActors(class'Projectile', MyProjectile)
break;
if(MyProjectile != none)
MyProjectile.Speed = 1000.0;
else
`log("MyProjectile == none, not doing anything.");
}

Compile the code and run the game.

Exit and take a look at the log:

[0005.06] ScriptLog: MyProjectile == none, not doing anything.

Let's remove our MyProjectile variable and rewrite the PostBeginPlay function:

simulated function PostBeginPlay()
{
AdjustProjectile(none);
}

Now let's write the custom AdjustProjectile function:

function AdjustProjectile(Projectile MyProj)
{
`log("MyProj:" @ MyProj);
MyProj.Speed = 1000.0;
}

Compile the code and run the game.

Exit and take a look at the log. We're getting the same warnings as before:

[0005.09] ScriptWarning: Accessed None 'MyProj'
BrokenActor BrokenMap.TheWorld:PersistentLevel.BrokenActor_0
Function BrokenGame.BrokenActor:AdjustProjectile:0024
[0005.09] ScriptWarning: Attempt to assign variable through None
BrokenActor BrokenMap.TheWorld:PersistentLevel.BrokenActor_0
Function BrokenGame.BrokenActor:AdjustProjectile:0038

Remembering that our PlayerController class is specified in the GameInfo, that is where we need to start. Let's add a new file to our DevelopmentSrcBrokenGameClasses folder called BrokenGame.uc.

Write the following code into BrokenGame.uc:

class BrokenGame extends UTDeathmatch;
defaultproperties
{
PlayerControllerClass=class'BrokenGame.BrokenPlayerController'
bDelayedStart=false
bUseClassicHUD=true
}

Now we need to create the BrokenPlayerController class. Start by creating a new file in DevelopmentSrcBrokenGameClasses called BrokenPlayerController.uc.

Write the following code in BrokenPlayerController.uc:

class BrokenPlayerController extends UTPlayerController;
defaultproperties
{
}

Now we're going to change BrokenActor a bit. We'll borrow some code from the AwesomeEnemy class to turn it into a kind of pet that will follow us around. Open BrokenActor.uc and type the following code into it:

class BrokenActor extends Actor
placeable;
var Pawn Master;
var float MovementSpeed;
var float StopDistance;
simulated function PostBeginPlay()
{
foreach DynamicActors(class'Pawn', Master)
break;
}
auto state Following
{
simulated function Tick(float DeltaTime)
{
local vector NewLocation;
if(Master != none && VSize(Location - Master.Location) > StopDistance)
{
NewLocation = Location;
NewLocation += normal(Master.Location - Location) * MovementSpeed * DeltaTime;
SetLocation(NewLocation);
}
}
}
defaultproperties
{
MovementSpeed=256.0
StopDistance=128.0
bBlockActors=true
bCollideActors=true
Begin Object Class=DynamicLightEnvironmentComponent Name=MyLightEnvironment
bEnabled=true
End Object
Components.Add(MyLightEnvironment)
Begin Object Class=StaticMeshComponent Name=PetMesh
StaticMesh=StaticMesh'UN_SimpleMeshes.TexPropCube_Dup'
Materials(0)=Material'EditorMaterials.WidgetMaterial_Y'
LightEnvironment=MyLightEnvironment
Scale3D=(X=0.125,Y=0.125,Z=0.25)
End Object
Components.Add(PetMesh)
Begin Object Class=CylinderComponent Name=CollisionCylinder
CollisionRadius=32.0
CollisionHeight=64.0
BlockNonZeroExtent=true
BlockZeroExtent=true
BlockActors=true
CollideActors=true
End Object
CollisionComponent=CollisionCylinder
Components.Add(CollisionCylinder)
}

Compile the code.

Before we test the code, let's open BrokenMap in the editor and make sure a BrokenActor is still placed somewhere near the player start. Once that's done save the map and close the editor.

For the final step, we have to change our batch file to use our BrokenGame so our BrokenPlayerController will be used. Change Broken Map.bat to this:

C:UDKUDK-AwesomeGameBinariesWin32UDK.exe BrokenMap?GoalScore=0?TimeLimit=0?Game=BrokenGame.BrokenGame -log

Save and close the batch file.

Run the game with the changed batch file.

We'll start with BrokenActor. Even though we see it in the map when we run the game, we shouldn't make any assumptions about what's going on. We'll add a log in PostBeginPlay:

simulated function PostBeginPlay()
{
`log("BrokenActor PostBeginPlay!");
foreach DynamicActors(class'Pawn', Master)
break;
}

We'll also add one in BrokenGame:

function PostBeginPlay()
{
`log("BrokenGame PostBeginPlay!");
}

And finally one in BrokenPlayerController:

simulated function PostBeginPlay()
{
`log("BrokenPlayerController PostBeginPlay!");
}

Compile the code and run the game.

Exit and take a look at the log. We'll see that all three actors are logging their PostBeginPlay functions:

[0005.44] ScriptLog: BrokenActor PostBeginPlay!
[0005.44] ScriptLog: BrokenGame PostBeginPlay!
[0005.44] Log: Bringing up level for play took: 0.032277
[0005.44] ScriptLog: BrokenPlayerController PostBeginPlay!

Now that we know our actors are indeed being used, we need to debug further. We know the movement code for our BrokenActor takes place in its Following state's Tick function, so let's add some logs there:

simulated function Tick(float DeltaTime)
{
local vector NewLocation;
`log("BrokenActor Tick!");
if(Master != none && VSize(Location - Master.Location) > StopDistance)
{
`log("BrokenActor Calculating new location!");
NewLocation = Location;
NewLocation += normal(Master.Location - Location) * MovementSpeed * DeltaTime;
SetLocation(NewLocation);
}
}

Let's compile the code and see what happens when we run the game.

Exit the game and take a look at the log:

[0005.88] ScriptLog: BrokenActor Tick!
[0005.92] ScriptLog: BrokenActor Tick!
[0005.94] ScriptLog: BrokenActor Tick!
[0005.95] ScriptLog: BrokenActor Tick!

The code doesn't seem to be getting into our if statement. Let's see if we can figure out why. Let's log the conditions to see which one is failing. We'll start with Master:

simulated function Tick(float DeltaTime)
{
local vector NewLocation;
`log(Master);
if(Master != none && VSize(Location - Master.Location) > StopDistance)
{
`log("BrokenActor Calculating new location!");
NewLocation = Location;
NewLocation += normal(Master.Location - Location) * MovementSpeed * DeltaTime;
SetLocation(NewLocation);
}
}

Compile the code and run the game.

Exit and take a look at the log:

[0005.68] ScriptLog: None
[0005.73] ScriptLog: None
[0005.75] ScriptLog: None

Well that would explain it. Master is never getting set. Let's see why. If we take a look a bit earlier in the log we'll see our PostBeginPlays:

[0005.35] ScriptLog: BrokenActor PostBeginPlay!
[0005.35] ScriptLog: BrokenGame PostBeginPlay!
[0005.36] Log: Bringing up level for play took: 0.035747
[0005.36] ScriptLog: BrokenPlayerController PostBeginPlay!

It looks like the BrokenActor is being initialized first, so we're not going to be able to get our Master there. Let's try checking it in Tick and assigning it if it doesn't exist. First we'll rename PostBeginPlay to GetMaster:

function GetMaster()
{
`log("BrokenActor GetMaster!");
foreach DynamicActors(class'Pawn', Master)
break;
}

Now we'll add the function call in Tick:

simulated function Tick(float DeltaTime)
{
local vector NewLocation;
if(Master == none)
GetMaster();
if(Master != none && VSize(Master.Location - Location) > StopDistance)
{
`log("BrokenActor Calculating new location!");
NewLocation = Location;
NewLocation += normal(Master.Location - Location) * MovementSpeed * DeltaTime;
SetLocation(NewLocation);
}
}

Now let's compile the code and check if it works.

Run the game and we'll see that the BrokenActor is now following us around! And if we check the log we'll see we're finally getting into the if statement:

[0007.66] ScriptLog: BrokenActor Calculating new location!
[0007.67] ScriptLog: BrokenActor Calculating new location!
[0007.69] ScriptLog: BrokenActor Calculating new location!

Close the game and remove all of the log lines from our classes.

Double-click on the batch file to run BrokenMap.

Hit the tilde key ( ~ ) to bring up the console.

Type profilegame start into the console and hit Enter. We'll see this message on screen:

PROFILING WITH AI LOGGING ON!

As well as this message in the log:

[0009.46] Log: GameplayProfiler STARTING capture.

Run around for a little bit to give the profiler time to collect information. Around ten seconds is good.

When you're ready, hit tilde (~) to bring up the console again, and type profilegame stop and hit Enter. The message on screen will go away and we'll see this message in the log:

[0036.62] Log: GameplayProfiler STOPPING capture.

Exit the game.

If we look in the UDKGame folder, we'll see a new folder has appeared called Profiling. If we look in that folder, we'll see a file with the time that we ran the profiler in its file name: UDK-2011.09.22-14.46.15.gprof

To open this file, go into the UDK-AwesomeGameBinaries folder and run GameplayProfiler.exe. We'll see the program start up looking like this:

Press Open File, and navigate to the UDKGameProfiling folder and select the .gprof file:

The top panel of the profiler shows us the frame by frame performance of our game. If there are any spikes you know that those are the areas to focus on. Clicking anywhere on this graph will set the profiler to that frame. If your graph extends out that far, click somewhere near 200 so we can take a look at the performance a little bit into the game.

The bottom-left panel of the profiler will show us the time taken for scripts to run, broken down by actor. If we expand our BrokenActor we can see the performance of it:

For our BrokenActor, calculating the dynamic lighting on it is taking the most time, followed by our Tick function with the movement calculations. Overall not a lot of time. What would we see if we really screwed things up?

Close the profiler for now and open BrokenActor in ConTEXT.

What if we rewrote our Tick function to run the search for Master every time?

simulated function Tick(float DeltaTime)
{
local vector NewLocation;
foreach AllActors(class'Pawn', Master)
break;
if(Master != none && VSize(Location - Master.Location) > StopDistance)
{
NewLocation = Location;
NewLocation += normal(Master.Location - Location) * MovementSpeed * DeltaTime;
SetLocation(NewLocation);
}
}

If we compiled that code and ran the game, then recorded with the profiler for a few seconds, we might see something like this when we took a look at the .gprof file:

We can see that our Script Time has increased. It might seem like a small increase, but with enough BrokenActors on the map a small increase like this could really impact performance.

Open BrokenActor.uc in ConTEXT.

We'll use PostBeginPlay for this. Let's write it like this:

function PostBeginPlay()
{
local int i;
local float StopWatch, Size;
local vector A, B;
Clock(StopWatch);
for(i=0; i<1000; i++)
{
A = VRand() * 1000;
B = VRand() * 1000;
Size = VSize(A - B);
}
UnClock(StopWatch);
`log("Time taken to execute:" @ StopWatch);
}

What we're doing here is running a loop 1000 times. Each time we take two vectors, A and B, and randomize them. Then we calculate the distance between them with VSize. We use a float called StopWatch in the Clock and UnClock functions, then log the value so we can see how long it took to run the loop.

Compile the code. We'll get a warning about Size, but we'll ignore it for this test.

Run the game, then exit and take a look at the log:

[0005.32] ScriptLog: Time taken to execute: 0.6553