All right.

It's time for extra credit once again.

So, this time, as the description says, what we want you to do is we want you to

fade out the projectile once it reaches 75% of the distance traveled.

So, let me show this to you again.

There, it just faded out in.

Because without the fade out effect, the projectile just stays

the way it is throughout the distance that it's traveling.

And I mean, it's a subtler effect, but it kind of gives you the effect

that it's going away and it's traveling a

distance and it's moving away from the user.

So, I'll be right here, take a crack at it.

Just to show you how you can implement it, I'm

going to open up the documentation and look at SKAction.

I'm gonna give you a few hints here.

So firstly, you might want to use a couple of the things.

So, there's a wait action.

So, you have a Wait For Duration action, and then you have

another action called Fadeout, so that's how you can fade it out.

And then, you can group actions by using a sequence, so what you can

do is you can define an array of several different actions and then create

yet another action that says, hey, this is a sequence of actions that I

want you to execute in a linear fashion, and then just run that action.

So, those are your hints, you know, use a sequence of

actions then define these several different actions and make this happen.

I'll be right here waiting.

So, go ahead and pause or stop this video, and take a crack at it, and

when you come back, I will give you the solution on how to make this happen.

All right.

Welcome back.

I hope you took the time to actually try to see if you can make this happen.

So firstly, I have to say that I had to decrease the

projectile speed so that I could demonstrate the fade out feature to you.

I'm going to go back and set that to 400.

And then going over to our projectile node implementation file.

So, here at line 65 after we run the action to

move the projectile, what I did was I created two more variables.

One is waitToFade and waitToFade basically takes time and

multiplies that by 0.75 which is 75% of the time.

And then the fadeTime is basically, time minus waitToFade.

Then, I declare three actions, the first action is wait

for duration and I pass it the wait to fade.

The next action is the fade out with duration and this the fade time I give it.

So, this is the amount of time it will be fading the projectile.

And finally, I just give it the action to remove from parent.

Now, generally the scene manages this for us, but it's always

good practice to remove notes that are no longer being used.

So that's why I just added that for good

measure, because if you increase the complexity of your game,

then it kind of becomes hard for the scene to

track which notes are being used and not being used.

So, it's always good to follow best practices to remove notes, even though

those nodes will eventually be removed by

the scene, especially if they're off screen.

And then finally I create an action called SKAction sequence, and

I give it my array of actions and I run that action.

So, that's pretty much it you know, you

should create variables to wait for durations and

fade out and then remove from parent, and then you just run the sequence of actions.

Now, I'm sure your wheels are turning and you can

think of multiple different, little techniques that you can do.

So, I hope this inspires you to

create some creative little actions with projectiles or

with a cat or with, you know, any other objects that we're going to add.

So, now in our next stage, we'll take this a step further, and we'll

start adding our space dogs, our enemies and see how we can interact with that.