[MUSIC]

Let's play the game for a moment and try shooting arrows at the scoreboard.

So I'll hit the Play button and start the game.

And let's shoot a few arrows at the scoreboard.

[MUSIC]

And when you're done, stop the game.

The arrows just bounce off the scoreboard.

And don't stick like you might expect.

There's also no sound and

nothing interesting happens when the scoreboard is hit.

Let's use the interface, iTargetable,

that we've created to make the scoreboard react to being hit by arrows in some way.

In the hierarchy, select the scoreboard game object.

Then in the inspector, add a new script called scoreboard hits.

This will be the script that implements the interface iTargetable so

that we can make the scoreboard react in some way.

Move the script from the Assets folder into the Scripts folder.

And then open the scoreboard hit's script for editing.

Before we begin, let's take a moment to think about

what this script is going to do and then how we'll do it.

When the arrows hit the scoreboard, we want them to stick to it and

then the scoreboard should react in some way.

Let's say that for the first two arrow hits

the scoreboard just plays a wood impact sound just like the targets, but

every third time the scoreboard gets hit we'll spawn the wooden plank

particle system and play the wood debris sound to indicate that perhaps

the scoreboard is being damaged in some way by us firing so many arrows at it.

So, how should we do all of that?

Well, let's go back to the script.

First, we know that we're going to need two audio clips.

One for the impact sounds and one for

the destruction sound when there is wooden planks flying everywhere.

So let's make those variables first.

At the top of this class we'll create a serialized field.

And this will be a private audio clip called impact sound,

and then same thing another serialized field which will be a private

audio clip called destruction sound.

Then we'll need a place to put the game object that spawns the wooden planks.

So let's create another variable for that.

This will be a serialized field and it's a private game object,

and we'll call this destruction particles.

Then every third time an arrow hits the scoreboard

we want to spawn those destruction particles and play the destruction sound.

So how will we know how many times the scoreboard has been hit?

For that we'll need to create an integer that will count upwards by one

every time the scoreboard is hit.

This doesn't need to be exposed to the inspector because

it's just keeping track internally.

So we'll type private and

arrowHits and by default that will be set to zero.

Great.

There's one more piece of functionality here.

How can we get the arrows to stick to the scoreboard?

Well let's go back to the arrow collision class for a moment.

It says here that, when an arrow enters into a collision,

if the other game object that it's colliding with has the interface

iTargetable, then the arrow should stop moving.

And it should be parented to the target game objects so that it's stuck.

So that means, all we have to do to make the arrows stick to the scoreboard,

is simply implement the iTargetable interface on the scoreboard Hit's class.

Because it's attached as a script component to the scoreboard game object,

which already has a collider attached as well for the arrow to hit.

So let's go back to the scoreboardhits class and

implement the interface I targetable.

Remember when we implement an interface we type a comma

after the derived class name followed by the name of the interface.

To finish this interface implementation,

we need to type the method target reaction.

In fact, let's save this script now and return to unity to see what happens.

If we open the console window, it says scoreboard hit's does not

implement the interface member iTargetable.Targetreaction.

So what that means is that we didn't finish implementing the interface and

we broke the contract on functionality.

We need to fulfill that contract by writing the target reaction method.

So let's jump back to our script and do that now.

Down towards the bottom.

We'll type public void TargetReaction.

For now, let's simply write this method with nothing inside the curly braces.

Remember, this method needs to be public because

the AeroCollision class needs to have access to the method so

that it can call it when an arrow hits a targetable script.

We're going to remove the start and update methods for

now, because we won't need them.

And then save the script, return to unity, save the scene and then, play the game.

Now when an arrow shoots the scoreboard It will stick to the scoreboard.

They don't do much else other than automatically destroy themselves after

a certain period of time, but simply by implementing that interface we were

able to get some basic functionality without doing much else.

[MUSIC]

Now stop the game.

We did part of what we wanted to accomplish.

But what about all of those other variables for sounds and particles?

That's what we'll work on next.