All content in this course uses:

Enemies, Part 2: Dynamic Observers

You’ve created one enemy John Lemon has to avoid, but that doesn’t seem like much of a challenge. It’s time to create another enemy that will increase the challenge for the player.

Write a custom script so Ghosts can patrol the haunted house

When you’ve finished the tutorial, your game will be full of enemies — and almost complete!
 

In the previous tutorial, you created a Gargoyle enemy for the haunted house. Now you’re going to enhance the challenge of your level by creating dynamic (moving) enemies. This time, you’ll create a Ghost to roam the halls of the house searching for JohnLemon.

The first step is to use the Ghost model is to create a Prefab — you should be quite familiar with this process now.

Drag the Ghost model from the Project window into the Hierarchy window to create an instance of the model.


Drag the Ghost GameObject from the Hierarchy window into the 

 folder in the Project window. When the Create Prefab dialogue box appears, select 

Set Up the Ghost Prefab

The next step is to animate your new enemy. The Ghost will also have a simple Animation Controller, as it will be playing a single animation on loop.

To animate the Ghost:


animation from the Project window into the Animator window.

The Ghost’s simple Animation Controller is completed, but it still needs to be assigned to the Animator component.


Drag the Ghost Animator Controller from the Project window onto the 

property of the Ghost’s Animator Component in the Inspector.


Animate the Ghost

Just like JohnLemon and the Gargoyles (although perhaps a little counterintuitively!), Ghosts need a physical presence in the Scene.  This means that they will need a Collider.

To add the Collider:

Check sure that Unity Editor is still in Prefab Mode. If not, you can use the shortcut you learned when you created the Gargoyle Prefab.


Let’s adjust the settings so the Collider fits the Ghost model better: 

Add a Collider to the Ghost

The Ghost will also need a Rigidbody, because it is moving. You need to be careful with the settings for this: a collision with JohnLemon shouldn’t cause any movement in the Ghost.

You could avoid movement by enabling all of the Constraints for position and rotation, but an easier approach is to set the Rigidbody as 

In the Inspector, find the Rigidbody component and 

A kinematic Rigidbody cannot be affected by external forces such as collisions, but it can still collide with other GameObjects. The paddle in the game Breakout is a perfect example of a kinematic Rigidbody: the ball bounces off the paddle, but the paddle is not affected by the bounce.

Add a Rigidbody Component to the Ghost GameObject

The Ghost Prefab now has all the basics, but it currently won’t move or spot JohnLemon. You’ve already created a PointOfView GameObject for the Gargoyle Prefab which controls this — let’s create a Prefab of that, rather than repeat all the work!

To make the Ghost an Observer:

First, save your changes to the Ghost Prefab. 

 GameObject that you created as a child of Gargoyle.

You’re going to turn this GameObject into a Prefab, so that both the Gargoyle and Ghost Prefabs can reference it.


Drag the PointOfView GameObject from the Hierarchy window into the 

You should see that the PointOfView GameObject in the Hierarchy is now represented by a blue cube instead of a grey one, and the name is blue instead of grey. This is because it’s now a Prefab instance!
 

 and select the Ghost Prefab. Click the Open Prefab button.


Now the Ghost also has PointOfView, and can use all of its functionality! There are a couple of adjustments to make so that PointOfView works properly for this enemy though. The Gargoyle is taller than the Ghost and looks down, while the Ghost will need to look straight forward.


In the Inspector, find the Transform component. 


Now your Ghost is set up as an Observer. You can also change the PointOfView Prefab to update both enemies in your game, if you ever need to do this.

Make the Ghost an Observer

Now you’re ready to set up the Ghost so it can move around your game environment.

You’re going to use two components to do this:

A Nav Mesh Agent, which will allow the Ghost to find paths around the Nav Mesh you baked in the 

A script which tells the Nav Mesh Agent where the Ghost should go

Let’s start by creating a Nav Mesh Agent:

You will mostly be able to use default settings for this component, but there are a few that you need to adjust.


In the Scene view, you should see a cylinder representation of the Nav Mesh Agent around the Ghost.
 

 This is a little big. In the Inspector, change the 

property of the Nav Mesh Agent component to 

. 

The agent’s height is also quite a bit taller than the Ghost, but since the environment does not have a ceiling this won’t matter. 


. The default speed of 3.5 meters per second is pretty fast for a ghost, and will make your game a little too difficult.


 property of the Nav Mesh Agent component to 

. You don’t need too much precision in how close to the waypoints the Ghosts get, so can increase the distance the Nav Mesh Agent is able to be from its destination and still consider itself arrived.
 

The Nav Mesh Agent is now set up, but it won’t do anything by itself. It needs to have its destination set, and to do this you need to write a script.

Set up a Nav Mesh Agent Component

The Ghosts in your game are going to move by patrolling in a loop through a collection of waypoints, so it makes sense to we’ll call this script WaypointPatrol. Don’t forget to save your changes as you go.

To create the new script:

Right-click on the Scripts folder and select 

In the Hierarchy, select the Ghost GameObject.


Drag the newly created WaypointPatrol script from the Project window into the Inspector window to add it as a to Ghost as a component. 


Double click on the WaypointPatrol script to open it for editing.

Create a New WaypointPatrol Script

Before you start editing the script, let’s think briefly about what it needs to do. It should set the destination of the Nav Mesh Agent both when the Scene is first loaded and whenever the Ghost has reached its destination. In order to know when it has reached its destination, you’ll need to check every frame.  


Let’s start editing your new script:


You’re going to need both Start and Update methods in this script, so it doesn’t make sense to remove them as you’ve done before. Instead, just remove the 

 above the Start and Update methods.  

The script should now look like this: 

You’re going to need to tell the Nav Mesh Agent what destination it should have, so you’ll need a reference to it. In order to do any scripting with the Nav Mesh Agent, you need to include its namespace. 

At the top of the script with the other using directives, add the following code: 

Including the AI namespace will give you access to the 

Above the Start method, add the following:

This public reference to the component will enable you to assign the Nav Mesh Agent reference in the Inspector window.


Next, you need to set the waypoints that the Ghost should patrol. A Nav Mesh Agent’s destination is a Vector3 — a position in world space.  But if you made the waypoints Vector3s, you will have to manually set all the positions and hope that the numbers you use are accurate.

Instead, it makes sense to have a collection of empty GameObjects and use their positions as the waypoints. These GameObjects can be moved around the scene much more easily, making any changes you want to make much more simple. Rather than having references to a collection of GameObjects though, you can just have references to their Transform components. You could simply have several public Transform variables and then set each one separately in the Inspector window, but this doesn’t allow much flexibility in how many waypoints each Ghost can have.

Instead, you can use something called an 

.  An array is a basic collection of variables that exist together.  They are defined using square brackets.

Add the following line just below the navMeshAgent variable declaration

This line of code is declaring a public variable called 

Next, add a line to your Start method to set the initial destination of the Nav Mesh Agent:

Set the Destination of the Nav Mesh Agent

Let’s explore this to understand a little more about how arrays work:

Your lline of code is calling the SetDestination method of your Nav Mesh Agent Component.  It takes a Vector3 as a parameter, and so you are using the position property of the first waypoint Transform in the array.  

The individual things that make up an array are called 

. Individual elements in an array are accessed using their index in square brackets. Think of the index as the number of elements you need to skip over from the start of the array to get to the element you want. You don’t need to skip over any elements to access the first element, so its index is 

How Do Arrays Work?

Your Ghost needs to move on to the next waypoint when it reaches the last one it had set as its destination. The easiest way to track which waypoint is next is by storing the current index of the waypoint array.  

Below the waypoints array declaration, add the following code: 

Next, let’s move on to the Update method so you can use this index. 

In the Update method you need to perform a check — you want to know if the Nav Mesh Agent has arrived at its destination. An easy way to check this is to see whether the remaining distance to the destination is less than the stopping distance you set in the Inspector window earlier.  

Add the following if statement to the Update method: 

Now you need to update the current index, and then use it to set the Nav Mesh Agent’s destination. To do this you will use a new operator called the 

 which is represented by the percentage character: 

.  

Add the following code within the if statement:

The remainder operator takes whatever is to its left and divides it by whatever is to its right, then returns the remainder. For example, 3 % 4 would return 3 (because 4 goes into 3 zero times with 3 left over).  5 % 4 would return 1 (because 4 goes into 5 once with 1 left over). 

Your code is saying, “Add one to the current index, but if that increment puts the index equal to the number of elements in the waypoints array then instead set it to zero.”  It would be set to zero in this circumstance, because the remainder when dividing any number by itself is zero. 

Now that you have incremented the index (and looped it back to zero when necessary), you need to use it.  Add the following below the index incrementation:

This is exactly what you did in the Start method, except instead of using zero as the index, you’re using whatever waypoint the Ghost is currently up to as the index.
 

That’s it! Your completed script should look like this:
 

Save the script and return to Unity Editor. 

Add Additional Destinations

You should be able to see in the Inspector window that you need to assign the Nav Mesh Agent reference and some Transforms for the waypoints. The Nav Mesh Agent reference will be the same for every instance of the Prefab, so you can assign that now. However, the waypoints will be different for every Ghost and so should not be part of the Prefab — not only that, but the waypoints will be part of the Scene so cannot be referenced by the Ghost Prefab.  


 component in the Inspector window down to the Nav Mesh Agent field on the Waypoint Patrol script. This will assign the Nav Mesh Agent reference. 

Save the Ghost Prefab, and return to the Scene.


Let’s check that your Ghost’s Observer script has the references it needs. In the Hierarchy, expand the Ghost GameObject and select the 

Drag the JohnLemon GameObject from the Hierarchy window onto the 

field of the Observer script to assign its Transform. 




Next, click the circle select button and assign the GameEnding field. Since there is only one GameEnding Component in the Scene, there will only be one option for you to select.

Your enemies are now pretty close to complete! You just need to add more Ghosts and assign their waypoints, then add a couple more static Gargoyles.
 

Assign the Nav Mesh Agent Reference to the Ghost Prefab

Now you’re ready to add enemies to your Scene! First, create four duplicate Ghosts and populate the level with moving enemies:

In the Hierarchy window, collapse and then select the 

GameObject. Duplicate the GameObject by pressing Ctrl + D (Windows) or CMD + D (macOS) until you have four copies of Ghost.


The first Ghost should be moving back and forward near the room JohnLemon starts in. In the Inspector, set the position of the Ghost named 

The second Ghost is going to be moving back and forth down a long corridor, so that JohnLemon has to duck into side rooms to get past. Set the position of the Ghost named 

The third Ghost will be circling the table in one of the dining rooms. Set the position of the Ghost named 

The final Ghost will be moving around in the bedroom near the exit, so JohnLemon gets caught if he goes the wrong way. Set the position of the Ghost named 

Now you have your Ghosts positioned, you need to make and position their waypoints.
 

Place Ghosts in your Scene

The waypoints just need to be empty GameObjects, since you’re only using their Transform components and all GameObjects have a Transform. To be as efficient as possible, you’re going to create all the waypoints, and then position and assign them.

To set up and assign the waypoints:


In the Hierarchy window, click on the Create button and select 

Rename the newly created empty GameObject to “

Duplicate the Waypoint GameObject nine times to create ten waypoints in total — Waypoint through to Waypoint (9).


GameObject from the Hierarchy window onto the name of the Waypoints field to add it to the array. 


 GameObject onto the name of the Waypoints field to add it to the array as well.


Your first Ghost has two waypoints in its array, but you need to position them. The Ghost will be moving back and forward through the starting room.

The second Ghost is going to be moving up and down the corridor with side rooms. Select the 

The third Ghost is going to be circling the table in the dining room, and will need more waypoints.

The final Ghost is in the bottom right bedroom. Select the 

That’s it — your ghosts are finished! 

Create and Position the Ghost Waypoints

Next, place three Gargoyles in your level:


 GameObject twice, to make three Gargoyles in total.


You’ve already positioned the first Gargoyle. The second one should go at the bottom of the long corridor, so JohnLemon can’t go too far down.

The third Gargoyle should go in the corner of the corridor next to the dining room, so JohnLemon gets caught if he goes the wrong way.  Since it’ll be the same corner as the first Gargoyle you won’t need to change the rotation, but you still need to adjust the position.

Now your level is populated with a range of enemies to make JohnLemon’s escape more challenging.

Place Gargoyles in your Scene

There’s one final thing for you to do before you’re completely finished with enemies and their waypoints: tidy them up. The Hierarchy window is currently looking a bit cluttered:
 

The best solution is to create some empty GameObjects that can act as parents to the enemies and waypoints. This will enable you to expand or collapse them as required, keeping the Hierarchy window nice and tidy.

To tidy the Hierarchy:

In the Hierarchy window, create an empty GameObject.  Rename it to “

. This will act as a parent to all the Ghost and Gargoyle GameObjects.


Hold the Ctrl key (Windows) or CMD key (macOS) and in the Hierarchy window click on each of the Ghosts and Gargoyles.  When they are all selected, drag them onto the 

Now you can expand and collapse the enemies whenever you want to. Next, you need to do the same for the waypoints.


In the Hierarchy window, create an empty GameObject. Rename it to “

. This will act as a parent to all the Waypoint GameObjects.


Hold the Ctrl key (Windows) or CMD key (macOS) and in the Hierarchy window click on each of the Waypoints.  When they are all selected, drag them onto the 

 That’s it, you’ve tidied up your enemies!

Save the Scene and enter Play Mode to give it a test. When you’re finished, make sure to exit Play Mode.
 

Clean Up the Hierarchy

In this tutorial, we finished creating enemies for your game. It’s almost complete! It’s a bit quiet though — there’s some buzzing coming from the lights, but it’d be nice to have more sound to enhance the atmosphere. In the next tutorial, you’ll be adding more audio to your game.

Unity Version 2020.3