Start up the editor, then open AwesomeTestMap.

We'll start with some simple Kismet at first, so let's open up the Kismet window by pressing the green K button in the top toolbar:

The Kismet window will open. Let's see what's going on here:

Let's start with something simple. We can create the Kismet version of the Hello World program pretty easily, so let's do that. Right-click in the main workspace and select New Event | Player | Player Spawned. You should see the event show up where you clicked:

The pink spikes at the bottom of this event let us get variable references from that event if we need them. In this case, we have the option to get the PlayerController in the form of the Instigator, and the PlayerStart in the form of the Spawn Point variable. We could use these if, for example, we only wanted certain things to happen to a specific player, or any player that spawns at a particular spawn point.

The black node labeled Out is used to connect to other Kismet actions, and these connections define the flow of this Kismet sequence. To see this, let's add an action to our sequence. Right-click off to the right of the Player Spawned event and select New Action | Misc | Log:

The Log action works the same as the log command that we've been using in UnrealScript, which makes Log actions a convenient tool for debugging Kismet sequences. These also have the option of displaying the log on the screen, which makes them even more helpful. If we click on the Log action and take a look at the SeqAct_Log section of the Properties in the lower-left window, we can see the following:

For anything to show up, we need to tell it what to log. Let's open up the Sequence Object section and type Player has spawned! into the Obj Comment property:

Before we test, we need to link the Event to the Action, so let's do that now. Click and hold on the black Out node of the Player Spawned event, then drag the line over to the In node of the Log action. When you release the mouse, the connection should be made:

Save the map, but we can keep the editor open for this. Let's fire up the game with our batch file and see what happens. We'll notice the log show up on the screen right as the game starts:

Exit the game and take a look at the log. We can see it show up there as well:

[0005.71] Log: Kismet: Player has spawned!

We should still have the editor open, if not, open it and open our AwesomeTestMap. Delete the Kismet from the last experiment by clicking on each action and event and hitting Delete on the keyboard.

Delete all of the AwesomeWeaponUpgrade actors, we'll be placing them in the map through Kismet.

The first thing we'll need is the trigger. Open up the Content Browser and select the Actor Classes tab. Make sure Show Categories is unchecked, and select Actor | Trigger (Not the subclasses, just Trigger). In the level, right-click somewhere near the start player and hit Add Trigger Here.

The trigger we've added won't be visible in game by default, so let's fix that real quick. Double-click on the trigger to open its properties, and under Display, uncheck Hidden. Close the trigger's properties.

We don't want the upgrade weapon to spawn in the same place as the trigger, so we need to add an actor that we'll use in Kismet to set the spawn location. I like to use TargetPoints for this, although any placeable actor will work. Select Actor | Keypoint | TargetPoint, and right-click near the trigger and hit Place TargetPoint Here. Use the blue arrow of the movement widget to raise it up off of the ground a bit.

OK, we're ready for some Kismet. We know from the Player Spawned event that UnrealScript triggers Events. That one was triggered by the GameInfo class, but actors placed in the level can also trigger Events in reaction to things happening in the game. In this case, the Trigger actor can fire an Event whenever it is touched.

To use Kismet events this way, we need to select the Trigger in the level by clicking on it. Now open the Kismet window and right-click in the main workspace. This time instead of going under New Event, below this we should see an option for New Event Using Trigger_0. If not, make sure the Trigger is selected in the level. Under New Event Using Trigger_0, select Touch:

By default this Trigger event is only set up to fire once. To get it to work an infinite number of times, we need to change one property. Select the Event, and in the Properties panel open up the Sequence Event section. Set Max Trigger Count to 0. This will let this event fire an unlimited number of times.

Now we have the Trigger's event set up, so we need the Action that's going to spawn the AwesomeWeaponUpgrade. For this, right-click to the right of the Trigger event and select New Action | Actor | Actor Factory:

Right now, we're only concerned about two of the nodes, the Spawn Actor input and the Spawn Point property. Let's take care of the Spawn Point property first.

Select the TargetPoint in the level, and in the Kismet window, right-click under the Actor Factory action and hit New Object Var Using TargetPoint_0. We'll see a circle show up with the TargetPoint inside it:

In Kismet, variables are represented as circles and act the same way they do in UnrealScript. We can change their value or read their value to do what we need to do. In this case, we're going to use the target point's location as the spawn point for our weapon upgrades.

Click and hold on the Spawn Point node on the Actor Factory action, and drag the line to the TargetPoint variable. When you let go, the connection should be made.

Now click and hold on the Touched output of the Trigger event, and drag the line over to the Spawn Actor input on the Actor Factory action.

One last thing we need to do: tell the Actor Factory what to spawn. Select the action in the main workspace, and in the Properties panel open up the SeqAct_ActorFactory section. In the Factory property, there should be a blue arrow pointing down. Click it, and in the pop-up list select ActorFactoryActor at the top. Once that's selected, a new property should show up under Factory called Actor Class. Set Actor Class to AwesomeWeaponUpgrade.

For debug purposes, while we're in the Actor Factory action's properties, under the Sequence Object section let's check Output Obj Comment To Screen, and set ObjComment to Upgrade Spawned!

That's it! Our Kismet sequence should now look like this:

Save the map and start up the game. We can see that the Kismet is working fine, whenever we run over the trigger, a weapon upgrade spawns! Remember that to pick the upgrade up, we have to hold a weapon.

Open AwesomeTestMap and delete the TargetPoint that we're using as the upgrade spawn location. Since it's referenced by Kismet, the editor will ask you if you're sure. Click on Continue. Now if we open our Kismet editor, we'll see that the variable that held our TargetPoint now has ??? written on it. This lets us know that the variable doesn't have an actor associated with it. If this were UnrealScript, it would be the same as a variable being none. Don't delete this Kismet variable, we'll use it in a second.

Go into the Actor Classes tab of the Content Browser and select Actor | Trigger, and add one where the TargetPoint used to be.

With the new Trigger selected, go into the Kismet editor and right-click on the ??? variable. Press Assign Trigger_1 To Object Variable(s) and the trigger should now show up in the variable.

Now for the Boolean. Right-click underneath the current sequence and hit New Variable | Bool. It will show up as a red circle with False written inside it. We'll use this to indicate whether or not a weapon upgrade has been spawned.

Right-click on either end of the connection between the Trigger event and the Actor Factory action and hit Break All Links. The link should be broken. Now move the Trigger event away from the Actor Factory action so we can add more actions in between them. To move it, select it, then hold Ctrl, then click and drag it.

If we were writing this as code, this part might look like:

if(!bUpgradeSpawned)
{
bUpgradeSpawned = true;
SpawnUpgrade();
}

The SpawnUpgrade() function would be the Actor Factory action, so that leaves us with two lines of code. Each one can be represented by a Kismet action, so there are two that we need to add. Let's do the bool comparison first.

Right-click between the Trigger event and the Actor Factory action and hit New Condition | Comparison | Compare Bool. This will show up as a blue box.

The variable we want to check needs to be hooked up to the Bool node at the bottom of this action, so click on the Bool node and drag the line to our Bool variable.

Now connect the Touched node of our Trigger event to the In node of the Compare Bool action.

That takes care if the if statement in our hypothetical code, so let's do the second line where we set the bool to True. Right-click next to the Compare Bool action and hit New Action | Set Variable | Bool.

For this new Action to work, we need to connect it to our Bool variable. Connect the Target node at the bottom of the Bool action to the Bool variable.

With the new action selected, open up the SeqAct_SetBool section of its properties and check Default Value so that it will set the bool to True.

Now connect the False node of the Compare Bool action to the In node of the Bool action, and the Out node of the Bool action to the Spawn Actor node of the Actor Factory action. Our Kismet sequence should look like this:

Almost there. Now we need to set that Bool back to False when the upgrade is picked up. Since we're spawning it on a Trigger, we can simply use its Touch event as a quick way to do this.

Select Trigger_1 in the editor, and go back into the Kismet window. Right-click below the first triggered event and hit New Event Using Trigger_1 | Touch.

In the new Touch event's properties set Max Trigger Count to 0.

Next to the Touch event, right-click and add a New Action | Set Variable | Bool. We don't need to change its properties, so next let's connect everything.

Connect the Touched node of the new Trigger event to the In node of the new Bool action.

Connect the Target node of the new Bool action to the Bool variable.

That's it! The sequence should now look like this:

Save the map and run the game. Now when we run over the first trigger, it will only spawn one upgrade until we pick it up!

Make sure the editor is closed.

Open AwesomeGame.uc in ConTEXT. At the bottom of our PostBeginPlay function, let's take out the timer that activates the spawners. The function should now look like this:

simulated function PostBeginPlay()
{
local AwesomeEnemySpawner ES;
super.PostBeginPlay();
GoalScore = 1;
foreach DynamicActors(class'AwesomeEnemySpawner', ES)
EnemySpawners[EnemySpawners.length] = ES;
}

Now we're ready to create the Kismet action that will handle the spawning. In our DevelopmentSrcAwesomeGameClasses folder, create a new file called AwesomeSeqAct_SpawnerActivation.uc.

Write the following code in this new file:

class AwesomeSeqAct_SpawnerActivation extends SequenceAction;
defaultproperties
{
ObjName="Spawner Activation"
ObjCategory="Awesome Game"
}

This will do for a moment; let's take a look. Compile the code, then open up the editor. Open the Kismet editor. When we right-click in the main workspace and look under New Action, we can see our new category, Awesome Game, and underneath it is our Spawner Activation action. Place one and let's see what it looks like:

Nice! What's that Target variable node though? Kismet actions use this node to call functions on the object or objects connected to the node. For example, connecting an object variable to the Target node of a SeqAct_Destroy would destroy that actor when the SeqAct_Destroy action is activated. We don't need this node for this action though, since we'll be calling a function in our AwesomeGame class and we can't make a Kismet variable for it. To get rid of it, we'll add a line to our default properties:

defaultproperties
{
ObjName="Spawner Activation"
ObjCategory="Awesome Game"
VariableLinks.Empty
}

This will clear out the variable nodes at the bottom of our action, in this case just the Target node.

Now for the heart of our Kismet action. When a Kismet action is activated, an event called, oddly enough, Activated is called. Let's add it to our custom action:

event Activated()
{
}

For this event, there isn't any code in our parent class, so we don't need to worry about calling the super. We only need two more lines of code to finish this part of the experiment:

event Activated()
{
if(AwesomeGame(GetWorldInfo().Game) != none)
AwesomeGame(GetWorldInfo().Game).ActivateSpawners();
}

In other classes, we've simply used WorldInfo.Game, but since Kismet classes aren't subclasses of Actor we need to use the special GetWorldInfo() function. We cast our AwesomeGame class, then call ActivateSpawners on it.

We're done! Well that was easy. Our class should look like this now:

class AwesomeSeqAct_SpawnerActivation extends SequenceAction;
event Activated()
{
if(AwesomeGame(GetWorldInfo().Game) != none)
AwesomeGame(GetWorldInfo().Game).ActivateSpawners();
}
defaultproperties
{
ObjName="Spawner Activation"
ObjCategory="Awesome Game"
VariableLinks.Empty
}

As far as our custom classes go, this one's tiny.

Compile the code and open up AwesomeTestMap in the editor. If the previous Spawner Activation action is still there, delete it. Keep the weapon upgrade Kismet though, we'll use that later.

Now, since we've broken the default behavior of our game to move the spawner activation into Kismet, let's set it up so our game works again. Open the Kismet editor, right-click in the main workspace and add a New Event | Player | Player Spawned event. Next to it, add our New Action | Awesome Game | Spawner Activation action. Connect the Out node of the Player Spawned event to the In node of our Spawner Activation action.

We had a five seconds delay earlier, so let's put that back in. Right-click on the Out node of the Player Spawned event, and click Set Activate Delay. Set it to 5 and click on OK.

As a bonus, let's select our Spawner Activation action and check Output Obj Comment To Screen in its properties, and set the Obj Comment to Enemies Incoming!

Our Kismet sequence should now look like the following:

Save the map and run the game. After five seconds, the message should pop up on the screen, and then enemies should start spawning and heading toward you. Awesome!

To do this, we'll create a new file in our DevelopmentSrcAwesomeGameClasses folder called AwesomeSeqAct_GetWeaponLevel.uc.

Write the following code in the new file:

class AwesomeSeqAct_GetWeaponLevel extends SequenceAction;
event Activated()
{
}
defaultproperties
{
ObjName="Get Weapon Level"
ObjCategory="Awesome Game"
VariableLinks.Empty
}

Now we'll need an UnrealScript variable to store the weapon level as well as a node that we can use in Kismet for it. First let's add the variable:

var int WeaponLevel;

Now let's add the variable link node. If we look in SequenceOp in UnCodeX, we can see that VariableLinks is an array of the SeqVarLink struct. Inside that struct are a lot of variables, but we're only concerned about a few of them. Let's use them to define a new variable link in our default properties:

VariableLinks(0)=(ExpectedType=class'SeqVar_Int',LinkDesc="Weapon Level",PropertyName=WeaponLevel,bWriteable=true)

Here we're setting the ExpectedType to use an Int variable, giving it a description, and then setting the PropertyName to the name of our UnrealScript variable we added in the last step. Finally we set it to bWriteable so this action can change the linked Kismet variable (otherwise, it would only be able to read it, which isn't what we need).

Now we need to get the player's weapon level and set our WeaponLevel variable to it in our Activated event.

event Activated()
{
local PlayerController PC;
PC = GetWorldInfo().GetALocalPlayerController();
if(PC != none && PC.Pawn != none && AwesomeWeapon(PC.Pawn.Weapon) != none)
WeaponLevel = AwesomeWeapon(PC.Pawn.Weapon).CurrentWeaponLevel;
}

We're doing a lot of checking here to get all the way down to the AwesomeWeapon, we need to make sure it actually exists before trying to access the CurrentWeaponLevel variable.

That does it for the UnrealScript side of things. Here's what the class should look like now:

class AwesomeSeqAct_GetWeaponLevel extends SequenceAction;
var int WeaponLevel;
event Activated()
{
local PlayerController PC;
PC = GetWorldInfo().GetALocalPlayerController();
if(PC != none && PC.Pawn != none && AwesomeWeapon(PC.Pawn.Weapon) != none)
WeaponLevel = AwesomeWeapon(PC.Pawn.Weapon).CurrentWeaponLevel;
}
defaultproperties
{
ObjName="Get Weapon Level"
ObjCategory="Awesome Game"
VariableLinks.Empty
VariableLinks(0)=(ExpectedType=class'SeqVar_Int',LinkDesc="Weapon Level",PropertyName=WeaponLevel,bWriteable=true)
}

Compile the code, then open up AwesomeTestMap in the editor. Time to add our new Action.

Open the Kismet editor. Our big mess of Kismet from our weapon upgrade experiments should still be there. Right-click on the Spawn Actor input of the Actor Factory action and hit Break Link | Compare Bool. We're going to put our custom action in between.

Move the Actor Factory action off to the right, then right-click in between it and the rest of this sequence and hit New Action | Awesome Game | Get Weapon Level:

To the right of that, right-click and hit New Condition | Comparison | Compare Int.

We're going to need an Int Kismet variable, so let's add it. Right-click below the actions we've just added and hit New Variable | Int | Int. We don't need to change the value, that will be done by our Get Weapon Level action.

Connect the Int variable to the Weapon Level node of our Get Weapon Level action, and to the A node of the Compare Int action.

Select the Compare Int action, and in its properties open the SeqCond_CompareInt section and change Value B to 5. If we're less than this, we still want to spawn upgrades.

Now for the connection between actions. Connect the Out node of the Bool action to the In node of our Get Weapon Level action.

Now connect the Out node of our Get Weapon Level action to the In node of the Compare Int action.

Finally, connect the A < B output node of the Compare Int to the Spawn Actor input of the Actor Factory action.

Our Kismet sequence should now look something like the following (I'm breaking it into two parts so it's clearer):

That section should connect to this:

We're done with the Kismet, unless you want to temporarily break the link to the Spawner Activation action to make it easier to test without being attackedanother advantage to moving that to Kismet!

Save the level and run the game. Now when the player's weapon reaches level 5, the upgrades stop spawning when the player runs over the trigger. It's working perfectly!

Open AwesomeWeaponUpgrade.uc in ConTEXT.

The first thing we need to do is give ourselves access to the static mesh so we can change its size and color. Let's add a variable to reference it:

var StaticMeshComponent MyMesh;

Now let's change the static mesh part of the default properties to add a line:

Begin Object Class=StaticMeshComponent Name=PickupMesh
StaticMesh=StaticMesh'UN_SimpleMeshes.TexPropCube_Dup'
Materials(0)=Material'EditorMaterials.WidgetMaterial_Y'
LightEnvironment=MyLightEnvironment
Scale3D=(X=0.125,Y=0.125,Z=0.125)
End Object
Components.Add(PickupMesh)
MyMesh=PickupMesh

Now some setup for the color change. Add a new material variable at the top:

var Material BigMaterial;

And set its default property to the blue material:

BigMaterial=Material'EditorMaterials.WidgetMaterial_Z'

Now we're ready for the handler function. These have a specific naming convention, and it explains the underscore used in the action name. For example, if we had a Kismet action called SeqAct_Whatever, the handler function for it would be called OnWhatever. The Kismet action itself is passed into the function as its only parameter. So for the Kismet action SeqAct_Toggle, the handler function for it would be written like this:

function OnToggle(SeqAct_Toggle Action)
{
}

Now for the code inside the OnToggle function:

function OnToggle(SeqAct_Toggle Action)
{
MyMesh.SetScale(2.0);
MyMesh.SetMaterial(0, BigMaterial);
}

Compile the code, then open up the editor.

Away from all of our other experiments, place a few AwesomeWeaponUpgrade actors near a new Trigger. In the Trigger properties, change Display | Hidden to false (uncheck it).

Now for the Kismet. Hold Ctrl and click on the AwesomeWeaponUpgrade actors to select all of them. In the Kismet editor, right-click and hit New Object Vars Using AwesomeWeaponUpgrade_0... This will create multiple Kismet variables, one for each AwesomeWeaponUpgrade actor selected.

Back in the level, select the Trigger near the AwesomeWeaponUpgrade actors. In the Kismet editor, right-click to the left of the new object variables and hit New Event Using Trigger_2 | Touch (the number may be different for you, it doesn't matter).

Now right-click above the object vars and hit New Action | Toggle | Toggle.

Connect the Touched output of the Trigger event to the Turn On input of the Toggle action.

Connect the Targets variable link of the Toggle action to each of the AwesomeWeaponUpgrade object variables.

The Kismet sequence should now look like the following:

Save the level and run the game. When we hit the trigger the AwesomeWeaponUpgrade actors should get bigger and turn blue. It's working!

We only need to change our OnToggle function to make this work, using the InputLinks array:

function OnToggle(SeqAct_Toggle Action)
{
if(Action.InputLinks[0].bHasImpulse)
{
MyMesh.SetScale(2.0);
MyMesh.SetMaterial(0, BigMaterial);
}
else if(Action.InputLinks[1].bHasImpulse)
{
MyMesh.SetScale(MyMesh.default.Scale);
MyMesh.SetMaterial(0, MyMesh.default.Materials[0]);
}
}

That's easy enough, but where do we get the numbers from for the InputLinks array index? If we look at the SeqAct_Toggle class, we can see the answer:

InputLinks(0)=(LinkDesc="Turn On")
InputLinks(1)=(LinkDesc="Turn Off")
InputLinks(2)=(LinkDesc="Toggle")

Compile the code with our new OnToggle function, then open the editor.

Time for the Kismet. Add another Trigger near the first one that we added for this experiment, and uncheck its Hidden property so we can see it.

Select the Trigger, then add a Touch event for it in the Kismet editor.

Hook the Touched output of this new event to the Turn Off input of the Toggle action.

In both of the Touched events, make sure their Max Trigger Count properties are set to 0.

The Kismet sequence should now look like the following:

Save the map and run the game. Now running back and forth between the two triggers will cause the AwesomeWeaponUpgrade actors to switch between large blue and green and normal size.

We use a variable called bHasImpulse to activate an output link. Let's check the player's weapon level and set it to True for the output we want to activate:

event Activated()
{
local PlayerController PC;
PC = GetWorldInfo().GetALocalPlayerController();
if(PC != none && PC.Pawn != none && AwesomeWeapon(PC.Pawn.Weapon) != none && AwesomeWeapon(PC.Pawn.Weapon).CurrentWeaponLevel == class'AwesomeWeapon'.const.MAX_LEVEL)
OutputLinks[0].bHasImpulse = true;
else
OutputLinks[1].bHasImpulse = true;
}

If the weapon is at max level, activate the True output, otherwise activate the False output. Note that we're setting the bool to true both times, don't let the names of the outputs confuse you.

Now let's compile the code and open our map in the editor.

In the Kismet editor, delete the Get Weapon Level, Compare Int, and the Int variable. We're going to add our new condition here instead. Right-click where the deleted actions were and hit New Condition | Awesome Game | Is Weapon Max Level.

Connect the output of the Bool action from our old Kismet to the In node of our condition. Now connect the False output of our condition to the Spawn Actor input of the Actor Factory action.

Right-click above the Actor Factory action and hit New Action | Misc | Log.

Give the Log action an Obj Comment of Weapon At Max Level! The Log action has its own Output To Screen property, so we don't need to worry about checking Output Obj Comment To Screen unless we want two messages to show up. And I'm not just saying that because I forgot about that while I was writing this.

Connect the True output of our Is Weapon Max Level condition to the input of the Log action.

Save the map, then run the game. Pick up the weapon, then run over the trigger and collect the upgrades a few times until the weapon reaches level 5. Now run over the trigger again and we should see our log message. After that the Boolean checks before our condition prevent it from activating again, so we don't get any more messages or pickups.

Open AwesomeTestMap in the editor.

We'll be starting fresh with our Kismet, so open the Kismet editor and delete all of it.

In the level, delete all of the Trigger actors and AwesomeWeaponUpgrades but leave the weapon spawner, enemy spawners, and player start.

Create a new file in our DevelopmentSrcAwesomeGameClasses folder called AwesomeSeqEvent_WaveComplete.uc.

The code for this one is going to be really simple:

class AwesomeSeqEvent_WaveComplete extends SequenceEvent;
defaultproperties
{
ObjName="Wave Complete"
ObjCategory="Awesome Game"
VariableLinks.Empty
bPlayerOnly=false
}

Yep, that's it. We don't have an instigator so we don't need to have any variable links. The bPlayersOnly variable lets classes other than PlayerControllers trigger the event.

The event is created, so now we need to trigger it. Open up AwesomeGame in ConTEXT and add a line to our EnemyKilled function:

function EnemyKilled()
{
local int i;
if(bSpawnBoss)
return;
EnemiesLeft--;
if(EnemiesLeft <= 0)
{
for(i=0; i<EnemySpawners.length; i++)
EnemySpawners[i].MakeEnemyRunAway();
ClearTimer('ActivateSpawners'),
bSpawnBoss = true;
ActivateSpawners();
TriggerGlobalEventClass(class'AwesomeSeqEvent_WaveComplete', self);
}
}

Calling this function will make the game find all of the Wave Complete actions in Kismet and trigger them.

Now we need to add the Kismet to our level, so open it up in the editor.

First we need the enemies to spawn, so add a New Event | Player | Player Spawned and hook its output to the input of a New Action | AwesomeGame | Spawner Activation. You can add a delay if you want (right-click on either node of the connection and hit Set Activate Delay).

Below that, right-click and add a New Event | Awesome Game | Wave Complete. Connect the output to a New Action | Misc | Log.

In the Log's properties, give it an Obj Comment of Wave Complete!

Save the map and run the game.

Create a new file in DevelopmentSrcAwesomeGameClasses called AwesomeSeqAct_SpawnBoss.uc.

Let's write the following code in it:

class AwesomeSeqAct_SpawnBoss extends SequenceAction;
event Activated()
{
if(AwesomeGame(GetWorldInfo().Game) != none)
AwesomeGame(GetWorldInfo().Game).SpawnBoss();
}
defaultproperties
{
ObjName="Spawn Boss"
ObjCategory="Awesome Game"
VariableLinks.Empty
}

The SpawnBoss function doesn't exist in AwesomeGame yet, so let's create it. Open up AwesomeGame.uc and add this function:

function SpawnBoss()
{
bSpawnBoss = true;
ActivateSpawners();
}

Now to keep the game from automatically spawning the boss, let's delete those two lines from EnemyKilled so it looks like this:

function EnemyKilled()
{
local int i;
if(bSpawnBoss)
return;
EnemiesLeft--;
if(EnemiesLeft <= 0)
{
for(i=0; i<EnemySpawners.length; i++)
EnemySpawners[i].MakeEnemyRunAway();
ClearTimer('ActivateSpawners'),
TriggerGlobalEventClass(class'AwesomeSeqEvent_WaveComplete', self);
}
}

Ok, we're done code side, so compile the code and open our map in the editor.

Now let's give the player a weapon upgrade and a bit of time before the boss spawns. Open up the Kismet editor and add a New Action | Actor | Actor Factory. Connect the Wave Complete! log's output to the Spawn Actor input of the Actor Factory.

In the Actor Factory's properties, select ActorFactoryActor from the list that pops up when you click the blue arrow for the Factory property.

In the Actor Class property that shows up, select AwesomeWeaponUpgrade.

Now we need a place for it to spawn. To keep it easy we'll use the player start, so select it in the level and go back to the Kismet editor.

Right-click under the Actor Factory action and hit New Object Var Using PlayerStart_0. Hook the Spawn Point variable link under the Actor Factory action to it.

Ok that's done! Now to spawn the boss. Right-click above the Actor Factory action and hit New Action | Awesome Game | Spawn Boss.

Instead of hooking it to the output of the Actor Factory, hook the output of the Log action to the input of Spawn Boss. We want the boss to spawn even if something goes wrong with the Actor Factory and the Finished output never activates.

Now to give us some delay, right-click the input of the Spawn Boss action and hit Set Activate Delay, and give it a delay of 5.

Finally, add another New Action | Misc | Log and hook it to the output of Spawn Boss. Give the new Log action an Obj Comment of Boss Incoming!

Our Kismet sequence should now look like the following:

Save the map and run the game. Now when we defeat the enemies, a weapon upgrade spawns at the player start, and five seconds later the boss spawns and the log message shows. Nice!

Let's start with the Kismet action. We'll need to add an int that the level designer can change to set the size of the wave, and then pass that on to the AwesomeGame. Open up AwesomeSeqAct_SpawnerActivation in ConTEXT.

Let's add an editable int variable to the top of the class:

var() int WaveSize;

Then give it a default property:

WaveSize=10

To give some added flexibility, let's hook it up to a variable link so we can set it that way as well if we wanted to. Add this line to the default properties:

VariableLinks(0)=(ExpectedType=class'SeqVar_Int',LinkDesc="Wave Size",PropertyName=WaveSize)

Note that this variable link is optional, we don't have to hook an Int Kismet variable to it, the action will still work fine with the editable property.

Now to pass this along to the game. Let's call a new function that we'll create in AwesomeGame. Change the Spawner Activation's Activated function to this:

event Activated()
{
if(AwesomeGame(GetWorldInfo().Game) != none)
AwesomeGame(GetWorldInfo().Game).StartWave(WaveSize);
}

The AwesomeSeqAct_SpawnerActivation class should look like the following:

class AwesomeSeqAct_SpawnerActivation extends SequenceAction;
var() int WaveSize;
event Activated()
{
if(AwesomeGame(GetWorldInfo().Game) != none)
AwesomeGame(GetWorldInfo().Game).StartWave(WaveSize);
}
defaultproperties
{
WaveSize=10
ObjName="Spawner Activation"
ObjCategory="Awesome Game"
VariableLinks.Empty
VariableLinks(0)=(ExpectedType=class'SeqVar_Int',LinkDesc="Wave Size",PropertyName=WaveSize)
}

The VariableLinks.Empty line might be confusing, but we're using it to clear out the Targets link that was there before adding our own.

We're done with the Kismet action, so let's open up AwesomeGame and create the StartWave function that we're calling from Kismet:

function StartWave(int WaveSize)
{
local AwesomeEnemy AE;
foreach DynamicActors(class'AwesomeEnemy', AE)
AE.Destroy();
EnemiesLeft = WaveSize;
bSpawnBoss = false;
ActivateSpawners();
}

This might seem a bit more complicated than we were expecting, but we need to make sure that any fleeing enemy left behind from a previous wave is properly destroyed before we start a new one. We also need to set bSpawnBoss to false to make sure we spawn normal minions for the wave.

That's it for the UnrealScript side! Compile the code and open AwesomeTestMap in the editor.

We'll notice in the Kismet editor that our Wave Size variable link shows up on our Spawner Activation action now, and if we look at its properties we can change it there too.

Now let's change our level's Kismet so we have two waves and then a boss. First set our Spawner Activation's Wave Size to 5. Also right-click on its input and set the activation delay to 5.

Hook an Enemies Incoming! log action to the output of our Spawner Activation.

Open up our Wave Complete event's properties and set Max Trigger Count to 0. We want it to be able to trigger more than once this time.

Now right-click on the input of our Spawn Boss action and hit Break All Links. We're going to put some stuff in between.

Add a New Action | Misc | Gate. We use Gates to control the flow of Kismet. If the Gate is closed the output won't activate until we send a signal to its Open input.

In the Gate's properties, set Auto Close Count to 1. This way the Gate will close after it has been activated once.

Hook the output of the Wave Complete log action to the In input of the Gate. Right-click on the gate's In input and set the activation delay to one second. This will become important in a bit.

Hook the output of the Gate up to the input of our Spawner Activation. Now when the first wave is complete, a second wave will start after another five seconds. The Gate will close to prevent any more waves from spawning.

Add another New Action | Misc | Gate. In its properties, set SeqAct_Gate | Open to unchecked. This will close it.

Hook the output of the first Gate to the Open input of this new one. Now when the second wave spawns, it will open the Gate so the next Wave Complete call can pass through it. The one-second delay we added earlier is to prevent both signals from hitting it at the same time and activating the output before we want it to.

Hook the output of the Wave Complete log action to the In input of the new Gate.

Hook the output of the new Gate to the input of the Spawn Boss action.

The Kismet sequences should now look like the following. Here is the first wave:

The line coming from the bottom is from the second wave and boss Kismet here:

That's it! Save the map and run the game.

Open AwesomeTestMap in the editor.

Place an AwesomeWeaponUpgrade in the level near the weapon.

With the AwesomeWeaponUpgrade selected, open the Kismet editor.

Right-click above the Player Spawned event and hit New Event Using AwesomeWeaponUpgrade_0 | Touch.

Hook the Touched output of the event to the input of the Spawner Activation action.

Delete the Player Spawned event.

Save the map and run the game.

Create a new file in DevelopmentSrcAwesomeGameClasses called AwesomeSeqEvent_PickedUp.uc.

Write the following code in the new file:

class AwesomeSeqEvent_PickedUp extends SequenceEvent;
defaultproperties
{
ObjName="Picked Up"
ObjCategory="Awesome Game"
bPlayerOnly=false
}

Simple enough. Now we need to add this to the SupportedEvents of our AwesomeWeaponUpgrade class's default properties. In AwesomeWeaponUpgrade add this to the defaults:

SupportedEvents.Add(class'AwesomeSeqEvent_PickedUp')

Now we can use it in the editor, but we need to trigger it. Let's rewrite our Touch function to add a new line. Change AwesomeWeaponUpgrade's Touch function to look like the following:

event Touch(Actor Other, PrimitiveComponent OtherComp, vector HitLocation, vector HitNormal)
{
if(Pawn(Other) != none && AwesomeWeapon(Pawn(Other).Weapon) != none)
{
AwesomeWeapon(Pawn(Other).Weapon).UpgradeWeapon();
TriggerEventClass(class'AwesomeSeqEvent_PickedUp', self);
Destroy();
}
}

The function TriggerEventClass is defined in Actor, and triggers all of the events that are linked to this Actor. Those events are automatically added to that actor's GeneratedEvents array when we create them in the Kismet editor.

Compile the code and open up the editor.

In the Kismet editor, delete the Touch event we were using before.

Select the AwesomeWeaponUpgrade in the level, then right-click in the Kismet editor and hit New Event Using AwesomeWeaponUpgrade_0 | Picked Up.

Hook the output of this event to the input of the Spawner Activation action. That takes care of the functionality, but let's see if we can spice it up a bit with instructions for the player.

Right-click above this sequence and hit New Event | Player | Player Spawned.

Next to it, add a New Action | Misc | Log. Give it an Obj Comment of Pick up the weapon.

Connect the Player Spawned event to the Log.

Now select the weapon spawner in the level, and right-click in the Kismet Editor and hit New Event Using UTWeaponPickupFactory_0 | Pickup Status Change. This is a SupportedEvent added to weapon factories to let us know when it changes.

Next to that, add another Log action with an Obj Comment of Now pick up the weapon upgrade.

Connect the Pickup Status Change event's Taken output to this new Log action.

Now add a new Log next to the Picked Up event for the AwesomeWeaponUpgrade, and give it an Obj Comment of Prepare yourself!

Hook up the Picked Up event to the Log.

This is what the Kismet sequence should look like now:

Save the map and run the game. Now we have a small tutorial for the game before the enemies start spawning. Nice!

First we need to create the timer. Let's do this in AwesomeGame. We'll start with the int variable at the top:

var int NextWaveTimer;

Now let's change the StartWave function:

function StartWave(int WaveSize, int WaveTimer)
{
local AwesomeEnemy AE;
foreach DynamicActors(class'AwesomeEnemy', AE)
AE.Destroy();
EnemiesLeft = WaveSize;
NextWaveTime = WaveTimer;
Broadcast(self, NextWaveTime);
SetTimer(1, true, 'WaveCountdown'),
}

We've added a new parameter to take the desired countdown time, then set it to our new variable and called a repeating timer for WaveCountdown, which we'll write next. We also broadcast the time left, similar to how the Log action shows its Obj Comment on screen.

Now we'll write the WaveCountdown function:

function WaveCountdown()
{
NextWaveTime--;
if(NextWaveTime <= 0)
{
ClearTimer('WaveCountdown'),
bSpawnBoss = false;
ActivateSpawners();
}
else
Broadcast(self, NextWaveTime);
}

In this function, if the time has reached 0, we'll clear the repeating timer and start the spawning. If not, we'll broadcast the time left.

Now let's give NextWaveTime a default property.

NextWaveTime=5

This will get overridden the first time the wave is called, but it's good to have a default for it.

Before we get to the Spawner Activation action, let's fix a small bug we've been getting with our HUD. We don't want the number of enemies left to display until the wave starts, so let's change the DrawHUD function of AwesomeHUD. Find this line:

if(!AwesomeGame(WorldInfo.Game).bSpawnBoss)

And change it to this:

if(!AwesomeGame(WorldInfo.Game).bSpawnBoss && AwesomeGame(WorldInfo.Game).NextWaveTime == 0)

Now the number of enemies will only show once the wave has spawned. To get the number to stop showing after the wave has ended, let's add a line to our EnemiesKilled function in AwesomeGame:

function EnemyKilled()
{
local int i;
if(bSpawnBoss)
return;
EnemiesLeft--;
if(EnemiesLeft <= 0)
{
for(i=0; i<EnemySpawners.length; i++)
EnemySpawners[i].MakeEnemyRunAway();
ClearTimer('ActivateSpawners'),
TriggerGlobalEventClass(class'AwesomeSeqEvent_WaveComplete', self);
NextWaveTime = -1;
}
}

Since we're checking if NextWaveTime is equal to zero in the HUD, setting it to -1 here will make sure it doesn't display after the wave is over, while still letting us set it to an appropriate number whenever we call the next wave.

Now for the Spawner Activation action. First we need to change the class we're extending from:

class AwesomeSeqAct_SpawnerActivation extends SeqAct_Latent;

Now we need to add the wave time variable here:

var() int WaveSize, WaveTimer;

And give it a default property:

WaveTimer=5

We'll also add a variable link for it:

VariableLinks(1)=(ExpectedType=class'SeqVar_Int',LinkDesc="Wave Timer",PropertyName=WaveTimer)

Now let's change our outputs and make sure they don't automatically activate:

OutputLinks(0)=(LinkDesc="Out")
OutputLinks(1)=(LinkDesc="Finished")
bAutoActivateOutputLinks=false

We want the Out output to activate immediately, so let's change our Activated function:

event Activated()
{
if(AwesomeGame(GetWorldInfo().Game) != none)
AwesomeGame(GetWorldInfo().Game).StartWave(WaveSize, WaveTimer);
OutputLinks[0].bHasImpulse = true;
}

And now for the Update function. This is what keeps the Kismet action going until we're ready to deactivate it. Returning true from this function tells the game that we're not done, that we want to keep calling Update on this action until we return false. Here, we'll check the time in the AwesomeGame and keep updating until it reaches 0:

event bool Update(float DT)
{
if(AwesomeGame(GetWorldInfo().Game) != none && AwesomeGame(GetWorldInfo().Game).NextWaveTime > 0)
return true;
OutputLinks[1].bHasImpulse = true;
return false;
}

That's it for the UnrealScript, so compile the code and open the editor.

We're going to delete the old Spawner Activation action, but before we do, right-click on its input link and hit Copy Connections. That will make the next step easier.

Delete the Spawner Activation action and add a new one. Right-click on its input link and hit Paste Connections. This saves us a bit of time.

Connect the Finished output link to the Enemies Incoming in the Log action.

Delete the Prepare yourself! in the Log action. The countdown timer will replace that.

Save the map and run the game. Now we have a nice countdown before the enemy spawn, and the number of enemies doesn't show on the HUD until the wave starts. Nice!