objects when our player game object collides with them.

To do this we need to detect our collisions

between the player game object and

the PickUp game objects.

We will need to have these collisions

trigger a new behaviour and we will need to

test these collisions to make sure we are

picking up the correct objects.

The PickUp objects, the player's sphere,

the ground plane and the walls all have

colliders that inform us about collisions.

If we didn't test our collisions to find out

which objects we have collided with

we could collect the wrong objects.

We could collect the floor, or the walls.

As a matter of face if we didn't test our collisions

on the very first frame of the game we would

come in contact with the ground plane

and we would collect the ground plane

and then we would fall in to the void of the scene space

and the game would essentially be over.

First, we don't need our player to remain inactive.

so let's tick the Active checkbox and

bring back our player.

Next let's select the PlayerController script

and open it for editing.

Just a note, we could edit this

script regardless of whether the game

object is active or not.

Now that we have the script open,

what code are we going to write?

We could write collider

and then search the documentation using the

hot key combination.

But there is a different way that we could do this as well.

Let's return to Unity and look at the details

of our player game object.

What we are interested in here is the

sphere collider component.

In the header of each component on the left

is the component's turndown arrow,

the icon, the Enable checkbox

if it's available, and the type of the component.

On the right is the context sensitive gear gizmo

and an icon of a little book with a question mark.

Now this is what we need.

This is the quick link to the component reference.

If we select this icon we are taken

not to the scripting reference but to the

component reference.

We would read this document to find out more

about how to use this component in the context

of the editor.

We, however, want to find out how to

script to this component's class.

To do this we simply switch to scripting

and we are taken to the scripting reference

for the sphere collider.

We want to detect and test our collisions.

For this project we are going to use

OnTriggerEnter.

Just imagine if we were, say, a daring plumber

and we jumped up to collect a perfect arch of coins

and bounced off the very first one as we

collected it and fell back to the ground.

Not very elegant.

This code will give us the ability to detect

the contact between our player game object

and our PickUp game objects

without actually creating a physical collision.

The code example however is not exactly

what we're looking for.

But that's okay, we can change that.

First, let's copy the code,

and then let's return to our scripting application.

Now that we're back in scripting let's paste the code.

As we have copied this code from a webpage

let's correct the indents.

In this case I'm going to make sure the

indents are tabs and that all of the tabs are

correctly aligned.

Next, let's look at this code.

We are using the function OnTriggerEnter.

OnTriggerEnter will be called by Unity

when our player game object first touches

a trigger collider.

We are given as an argument

a reference to the trigger collider that we have touched.

This is the collider called Other.

This reference gives us a way to get a

hold of the colliders that we touch.

With this code, when we touch another trigger

collider we will destroy the game object

that the trigger collider is attached to

through the reference other.gameObject.

By destroying that game object, the game object,

all of it's components and all of it's

children and their components are removed

from the scene.

For the sake of example in this assignment

we won't destroy the other game object

we will deactivate it.

Just like we deactivated the player object

when we were creating our PickUp objects.

First, let's remove the Destroy(other.gameobject)

code from the function.

But let's paste it down below our script

as a palette to work with.

How will we deactivate our PickUp objects?

Well what clues do we have?

We can address the other collider's game

object through other.gameObject.

We can see this here in the sample code.

And we want to test the other game object

and if it's a PickUp object we want to deactivate

that game object.

So let's look up GameObject

with our hot key combination and see what we can find.

Now we have the page on GameObject.

There are two important items here that we want.

They are tag,

tag allows us to identify the game object

by comparing the tag value to a string.

And SetActive.

This is how we activate or deactivate a game object through code.

The last item we need to know about is

Compare Tag.

Compare Tag allows us to efficiently

compare the tag of any game object to a sting value.

Let's open up these three items, each in their own tab.

Tag allows us to identify a game object by a tag value.

We must declare our tags in the Tags and Layers Panel before using them.

It is possible to test a tag against a string value directly

with code like

if gameObject.tag is the same as some string value.

But there is a more efficient built-in way to do this,

and that is CompareTag

With CompareTag we can efficiently

compare the tag of any game object with a string value.

Let's copy the sample code and

paste it in to our working palette.

Now GameObject.SetActive.

This is how we activate or deactivate a game object.

This is the code equivalent of clicking

the Active check box next to the

Name field in the Inspector.

In our case, just like the code snippet,

we will call GameObject.SetActive (false)

to deactivate our PickUp game objects.

Let's copy this code and returning to our script editor

paste it in to our palette as well.

I feel we have enough pieces to write our code

so let's write if (other.gameObject.CompareTag

with the string value of PickUp

and we will have to define this tag in Unity later.

other.gameObject.SetActive (false);

Now this code will be called every time

we touch a trigger collider.

We are given a reference to the collider we touch,

we test it's tag,

and if the tag is the same as the string value

PickUp we will take the other game object

and we will call SetActive (false),

which will deactivate that game object.

Now we don't need this code we've been saving anymore

and keeping it will only confuse the compiler

so we can delete it.

Let's save this script and return to Unity

and check for errors.

The first thing we need to do it set up the tag value

for the PickUp objects.

Select the prefab asset for the PickUp object.

When we look at the tag list

we don't see any tag called PickUp

so we need to add one.

Select Add Tag.

This brings up the Tags and Layers Panel.

Here we can customise tags and layers.

Note that this list is empty.

To create a new custom tag select the + button

to add a new row to the tags list.

In the new empty element, in our case tag 0,

type PickUp, and this is case sensitive

and needs to be exactly the same string

that we have in our script.

If in doubt we can copy and paste

this string to get the exact value.

When we look back at the prefab asset

note that the asset is still untagged.

By selecting Add Tag we changed our focus

from the prefab asset to the Tag Manager

and in the Tag Manager we created our tag.

Now we need to apply that tag

to the prefab asset.

Select the Tag drop down again

and see how we now have PickUp in the list.

Select this tag from the list and the asset

is now tagged PickUp.

And with the power of prefabs

all of the instances are now tagged PickUp as well.

Now let's test our game.

Save the scene and enter play mode.

Hmm, okay, our tag is set to PickUp

but we are still bouncing off the PickUp cubes

just like we are bouncing off the walls.

So let's exit play mode.

Before we discuss why we are bouncing off

the PickUp cubes rather than picking them up

we need to have a brief discussion about

Unity's physics system.

I'm going to enter play mode for this discussion.

Let's look at one of our cubes and our player.

As an aside we can select two or

more game objects at the same time

and inspect them all.

We do this by holding down the command key

on the mac or the control key on the PC,

and selecting the game objects.

When we select multiple game objects

note how the inspector changes to show

the common components and property

values of the selected game objects.

The inspector also allows for multi-object editing.

Using multi-object editing I'm going to

disable the mesh renderer on both the

player's sphere and the selected cube with a single click.

This leaves us with the two green outlines

of the collider volumes for these two objects.

How do collisions work in Unity's physics engine?

The physics engine does not allow two collider

volumes to overlap.

When the physics engine detects that any two

or more colliders will overlap that frame

the physics engine will look at the objects and

analyse their speed and rotation and shape

and calculate a collision.

One of the major factors in this calculation

is whether the colliders are static

or dynamic.

Static colliders are usually non-moving

parts of your scene, like the walls, the floor,

or the fountain in the courtyard.

Dynamic colliders are things that move

like the player's sphere or a car.

When calculating a collision the static geometry

will not be affected by the collision.

But the dynamic objects will be.

In our case the player's sphere is dynamic,

or moving geometry, and it is bouncing

off the static geometry of the cubes.

Just as it bounces off the static geometry