We'll need a blank map for our experiments, so open AwesomeTestMap in the editor and delete all of the Kismet, AwesomeEnemySpawners, the look target, and the weapon spawner. All that should be left is the ground, the player start, and the lights.

Save the map and close the editor.

Open AwesomeActor.uc in ConTEXT.

Components are found under Object in the class tree. The one we're most concerned with for this is ActorComponents, which is the one that will be used most when working with UnrealScript. We'll start by adding a SpriteComponent to a new class we'll create, AwesomeComponentActor. SpriteComponents are most commonly used to give the Actor a physical representation in the editor. First let's create a new file called AwesomeComponentActor.uc in Development/Src/AwesomeGame/Classes and write the following code in it:

class AwesomeComponentActor extends Actor;
defaultproperties
{
}

Let's add a SpriteComponent to the default properties and also make this class placeable:

class AwesomeComponentActor extends Actor
placeable;
defaultproperties
{
Begin Object Class=SpriteComponent Name=MySprite
Sprite=Texture2D'EditorResources.S_Keypoint'
End Object
Components.Add(MySprite)
}

Anything can be used as the Name of the Component, just make sure the name is the same in the Components.Add() line.

Compile the code and open up AwesomeTestMap in the editor.

Select AwesomeComponentActor in the Actor tab of the content browser and place one in the map. We'll see the sprite on it:

Save and close the map. If you deleted the batch file to run the game or don't have one, then create a new file called Awesome Test Map.bat and write the following in it:

C:UDKUDK-AwesomeGameBinariesWin32UDK.exe AwesomeTestMap?GoalScore=0?TimeLimit=0?Game=AwesomeGame.AwesomeGame -log

Run the game and we'll also see the sprite in game.

Good so far, but we usually don't see the sprites of Actor classes in game. If we take a look at SpriteComponent's parent class, PrimitiveComponent, then we can see a few properties we may find useful:

var(Rendering) const bool HiddenGame;
var(Rendering) const bool HiddenEditor;
/** If this is True, this component won't be visible when the view actor is the component's owner, directly or indirectly. */
var(Rendering) const bool bOwnerNoSee;
/** If this is True, this component will only be visible when the view actor is the component's owner, directly or indirectly. */
var(Rendering) const bool bOnlyOwnerSee;
/** If true, bHidden on the Owner of this component will be ignored. */
var(Rendering) const bool bIgnoreOwnerHidden;

These options control when the Component is visible. For this Actor, we want it to be visible in the editor, but not in game, so let's add that to the Component's properties:

defaultproperties
{
Begin Object Class=SpriteComponent Name=MySprite
Sprite=Texture2D'EditorResources.S_Keypoint'
HiddenGame=true
End Object
Components.Add(MySprite)
}

Now when we compile the code, we can see the Component in the editor, but not in game.

Sprites are nice, but let's see if we can find something more useful. We'll add a SkeletalMeshComponent to our AwesomeComponentActor. Start by deleting SpriteComponent.

Now let's add a SkeletalMeshComponent to the default properties:

defaultproperties
{
Begin Object Class=SkeletalMeshComponent Name=AwesomeMesh
SkeletalMesh=SkeletalMesh 'CH_IronGuard_Male.Mesh.SK_CH_IronGuard_MaleA'
End Object
Components.Add(AwesomeMesh)
}

Compile the code and open AwesomeTestMap in the editor. We can see the skeletal mesh, but it's all dark!

In order for our Component to be able to receive light, we also need to add a DynamicLightEnvironmentComponent. Any subclass of PrimitiveComponent can have a light environment assigned to its LightEnvironment variable, but they're mainly only used for StaticMeshComponents and SkeletalMeshComponents. Sprites and other components don't really need lighting calculations.

Let's add a DynamicLightEnvironmentComponent to our AwesomeComponentActor:

Begin Object Class=DynamicLightEnvironmentComponent Name=AwesomeLightEnvironment
End Object
Components.Add(AwesomeLightEnvironment)

As we're not changing any of the variables in the light environment declaring one is as simple as those three lines. However, if for example, we didn't want our mesh to cast shadows, we could write it like this if we wanted:

Begin Object Class=DynamicLightEnvironmentComponent Name=AwesomeLightEnvironment
bCastShadows=false
End Object
Components.Add(AwesomeLightEnvironment)

Now that we have the light environment, we can assign it in our SkeletalMeshComponent:

Begin Object Class=SkeletalMeshComponent Name=AwesomeMesh
SkeletalMesh=SkeletalMesh 'CH_IronGuard_Male.Mesh.SK_CH_IronGuard_MaleA'
LightEnvironment=AwesomeLightEnvironment
End Object
Components.Add(AwesomeMesh)

Our AwesomeComponentActor class should look like the following code snippet:

class AwesomeComponentActor extends Actor
placeable;
defaultproperties
{
Begin Object Class=SpriteComponent Name=MySprite
Sprite=Texture2D'EditorResources.S_Keypoint'
HiddenGame=true
End Object
Components.Add(MySprite)
Begin Object Class=DynamicLightEnvironmentComponent Name=AwesomeLightEnvironment
End Object
Components.Add(AwesomeLightEnvironment)
Begin Object Class=SkeletalMeshComponent Name=AwesomeMesh
SkeletalMesh=SkeletalMesh 'CH_IronGuard_Male.Mesh.SK_CH_IronGuard_MaleA'
LightEnvironment=AwesomeLightEnvironment
End Object
Components.Add(AwesomeMesh)
}

Compile the code and open AwesomeTestMap in the editor. Now we can see him!

Create a new file in Development/Src/AwesomeGame/Classes called AwesomeInfo.uc.

Open AwesomeInfo.uc in ConTEXT and write the following code in it:

class AwesomeInfo extends Info
placeable;
defaultproperties
{
Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_Keypoint'
HiddenGame=true
End Object
Components.Add(Sprite)
}

Compile the code and we'll get the following error:

[0004.20] Log: R:UDKUDK-AwesomeGameDevelopmentSrc AwesomeGameClassesAwesomeInfo.uc(6) : Error, BEGIN OBJECT: The component name Sprite is already used (if you want to override the component, don't specify a class): Begin Object Class=SpriteComponent Name=Sprite

This error is telling us that the name Sprite is already being used by a Component, and if we take a look at AwesomeInfo's superclass,(Info), we can see it in the default properties there:

Begin Object Class=SpriteComponent Name=Sprite
Sprite=Texture2D'EditorResources.S_Actor'
HiddenGame=TRUE
AlwaysLoadOnClient=FALSE
AlwaysLoadOnServer=FALSE
End Object
Components.Add(Sprite)

If we didn't want to override this Component, then we would need to choose a different name for our own. However, if we did want to override this Component and change some variables, then we would just need to remove the Class= part of our Component:

Begin Object Name=MySprite
Sprite=Texture2D'EditorResources.S_Keypoint'
HiddenGame=true
End Object
Components.Add(MySprite)

Compiling that code works, and now we would be able to change the properties of that Component inherited from our parent class.

First, we're going to put a StaticMeshComponent in the class, similar to what we did with our AwesomeEnemy class. Let's rewrite our AwesomeInfo class to look like the following code snippet:

class AwesomeInfo extends Info
placeable;
defaultproperties
{
Begin Object Class=StaticMeshComponent Name=MyMesh
StaticMesh=StaticMesh'UN_SimpleMeshes.TexPropCube_Dup'
Materials(0)=Material'EditorMaterials.WidgetMaterial_Y'
Scale3D=(X=0.25,Y=0.25,Z=0.25)
End Object
Components.Add(MyMesh)
bHidden=false
}

As we're using an emissive material, we don't need to set a light environment for the StaticMeshComponent. The Info class has bHidden set to True, we need to change it so we can see the AwesomeInfo in game.

Compile the code, and open AwesomeTestMap in the editor.

If the AwesomeActor is still there, delete it.

Select AwesomeInfo in the Actor tab of the Content Browser (under Actor | Info) and place one in the map near the player start. In its properties, make sure Display | Hidden is unchecked.

Save the map and close the editor.

Run the game, and we'll see the AwesomeInfo Actor in the game. Exit the game.

Now that the AwesomeInfo Actor is there, we need a way to interact with it. We can do this by declaring a variable of the Component's class. Add this line to the top of AwesomeInfo under the class declaration:

var StaticMeshComponent MyMeshComponent;

Next, we'll add a line at the end of our Component declaration in the default properties:

defaultproperties
{
Begin Object Class=StaticMeshComponent Name=MyMesh
StaticMesh=StaticMesh'UN_SimpleMeshes.TexPropCube_Dup'
Materials(0)=Material'EditorMaterials.WidgetMaterial_Y'
Scale3D=(X=0.25,Y=0.25,Z=0.25)
End Object
Components.Add(MyMesh)
MyMeshComponent=MyMesh
bHidden=false
}

Setting the variable such that it lets us interact with the component through script. If we wanted to make the StaticMeshComponent changeable in the editor, then we could add the parentheses to the variable declaration like the following code:

var() StaticMeshComponent MyMeshComponent;

Now that we have the variable, let's see if we can use it. We'll use some Kismet to toggle the material that's on it. First, let's declare two variables in our class for the materials. Add the following line to the top, under the class declaration line:

var Material GreenMat, RedMat;

Now let's define their default properties:

GreenMat=Material'EditorMaterials.WidgetMaterial_Y'
RedMat=Material'EditorMaterials.WidgetMaterial_X'

Now for the function that will interact with the Component. We'll use the OnToggle function so we can use the Toggle Kismet action on our AwesomeInfo Actor:

simulated function OnToggle(SeqAct_Toggle Action)
{
if(Action.InputLinks[2].bHasImpulse)
{
if(MyMeshComponent.GetMaterial(0) == GreenMat)
MyMeshComponent.SetMaterial(0, RedMat);
else
MyMeshComponent.SetMaterial(0, GreenMat);
}
}

In this function, we check if the material on the Component is GreenMat, if it is set it to RedMat. If it's not, then we know it's RedMat, so set it to GreenMat.

Compile the code.

Open AwesomeTestMap in the editor.

Click on the AwesomeInfo Actor to select it, and then open the Kismet editor.

Right-click and select New Object Var Using AwesomeInfo_0.

Right-click above the object variable and select New Action | Toggle | Toggle.

Connect the Target variable link to the AwesomeInfo_0 object variable.

Close the Kismet editor and select Trigger in the Actor tab of the Content Browser.

Add a Trigger near the AwesomeInfo Actor.

Double-click to open the Trigger's properties, and uncheck Display | Hidden.

With the Trigger still selected, open the Kismet editor.

Right-click to the left of the other two parts of the sequence and hit New Event Using Trigger_0 | Touch.

With the Trigger event selected, set its Sequence Event | Max Trigger Count to 0.

Connect the Touched output of the Trigger event to the Toggle input of the Toggle action. The Kismet sequence should look like the following screenshot:

Save the map and close the editor.

Run the game, and every time you run over the trigger the AwesomeInfo Actor will toggle its material.

Open AwesomeTestMap in the editor.

Select all of the lights, and in their properties set Light | Light Component | Brightness to 0.3.

Rebuild the map by clicking on the Build All button in the top toolbar.

Save the map and close the editor.

Open AwesomePawn.uc in ConTEXT.

We'll need a variable to store our light component, so let's add it:

var SpotLightComponent Flashlight;

Now let's add the Component to the default properties:

Begin Object Class=SpotLightComponent Name=MyFlashlight
bEnabled=true
Radius=1024.000000
Brightness=1.90000
End Object
Components.Add(MyFlashlight)
Flashlight=MyFlashlight

Compile the code and run the game. We have a flashlight!

Now to toggle it. We can use an already existing function for this, Use(). It's in PlayerController, so we'll have to override it in our AwesomePlayerController class. If it's already there, then change it to the following code snippet. If not, then write the following code in AwesomePlayerController:

exec function Use()
{
if(AwesomePawn(Pawn) != none)
AwesomePawn(Pawn).Flashlight.SetEnabled (!AwesomePawn(Pawn).Flashlight.bEnabled);
}

Compile the code and run the game. Now when you click on Use (default key is E), the flashlight will toggle!

Grab AwesomeDLL.dll from the files included with the book and place the .dll in the UDK-AwesomeGameBinariesWin32UserCode folder.

Now for the UnrealScript side of things. We're going to use our AwesomeInfo.uc Actor for this, so let's write it as follows:

class AwesomeInfo extends Info
placeable
DLLBind(AwesomeDLL);
dllimport final function DLLFunction(string s);
simulated function PostBeginPlay()
{
local string s;
s = "Hi DLL!";
DLLFunction(s);
}
defaultproperties
{
}

We use DLLBind as a class keyword with the name of the DLL in parentheses. The DLL function must be declared as dllimport final, and we're passing it a string called s (the name of the variable is arbitrary).

In PostBeginPlay, we create a local string, assign it a value, and then call our DLLFunction with it.

Compile the code. If the compiler gives you any warnings about the DLL, make sure it is in the right location and the name is the same as in UnrealScript. Furthermore, make sure you're compiling with the Win32 version of UDK.exe.

We still have the AwesomeInfo Actor placed in AwesomeTestMap, but open the editor to make sure it's there. You may get a warning about a missing component (we've removed them from the default properties), if so just click on OK and save and close the editor.

Run the game. We should see a message box pop up as the game starts!