[MUSIC]

All right, let's look at some code.

Let's do a code check of particle systems and

see how it is that we implement particle systems in our overall structure.

We're going to start with our idea that what we're looking for

is the ability to find our particle system using a resource bundle,

finding our path through a resource bundle.

Unarchiving it, giving it a position, and then executing it.

And then thinking about how it is that we want the execution to happen.

All right, so let's go to our code.

Here's our GameScene.

This is our, the test that we've been working with with all the balls

bouncing around and the puppet guy.

We know we have this blob here, that's where we left off last time,

and we have a bunch of particle systems.

So let's take a look at the ones we've got here.

We've got a fire particle system,

and that I think is the default one, maybe with a few tweaks that I made.

That's fire and then we've got smoke and there's smoke, that works on top of it.

Now I want to introduce those to our game.

Go back to our game, we have the body,

no changes to the making of the body, the dude, we also

have all of the different sprites that we're making, no change to the sprites.

When we first create our view we're putting a boundary around the scene,

we're adding a vortex node, we're using the texture based animation here.

We're adding 20 different sprites and then we're adding and making our body.

Then on our touches we're going to change what we're doing when we touch.

What I want to do when we touch the first time

is I would like to add a particle filter to our environment.

So I'm going to take out this code here that previously was being used to create

an action that moved the guy and go ahead and keep this state incrementation.

And the first thing that I want to do, actually,

is I want to light the guy's head on fire because that's, I guess, how I am.

So, let's take that, and let's add this up here and go through it line by line.

So we're going to go ahead and find the burst path.

And we're going to need to define it.

So this is going to be an NSString.

And what we're looking for is we're looking for

the path with resource name particlefire.sks and that'll give us

just a string which will give us the identity of our particle system.

And then we will create our particle system by unarchiving it from that string,

what it becomes is an SK emitter node, that's the basic class for

a particle system.

So our first emitter in this case is, we'll call it our fire emitter.

Let's do that, make it clear.

Our fire emitter and then we'll make it our fire path up here.

So we need to look for fire path and our firePath, create a fireEmitter.

All right, and then we need to give it a position.

So our fireEmitter position is going to be, actually you know what,

we're going to make it be 0, 0 or 0, 30.

Because we're going to make it a child of the head of the man and

because we're going to be using the coordinate space of the head

if we made it's positions zero, zero when we attach it to the head it's going to

be a fire in the middle of the head but hopefully behind the head.

And actually what I want to do is I want to lift it up a little bit so

it looks like it's hairs on fire.

So I'm going to make it zero and 30, up a little bit.

And then I am going to relieve it's target just as the object that it's with,

it's head, then we're going to add it to the man.

The man of course is the same as his head, the man pointer is the head pointer.

We're going to add this child then we're going to keep everything else

commented out.

All right, and not the firePath, but the fireEmitter and the fireEmitter.

Okay. So we create the path then we create

an emitter, it's a pointer to an SKEmitterNode.

We give the emitter a position and then we're going to, let's get rid of this for

now, and then we're going to attach it to the child.

And let's leave everything else the same, because I just want to show you what

that's going to do in our environment, okay?

We're creating a particle system, we're attaching it to the man's head.

All right, so now let me see if I can

get it running Let's see if we can get our, there we go.

Okay, that's Keynote.

And then we'll run it.

No, no, no, no, no, no.

That's running that on the phone.

Hope I stopped it in time.

Okay, run it on the iPad.

Build succeeded.

All right, here we go.

All right. There's our guy being

bounced around by all the elements.

And then when I touch the screen, we should see his head catch on fire.

So here we go. I'm going to touch now.

All right. So you can see the particle system

is on top of his head.

And it looks okay.

Except that the fire is kind of moving around with him,

this might not be totally obvious but let me add the smoke and

you can see the problem with this not having a target node.

Okay so his head's on fire good job.

Stop it and

now what I want to do is I want to do a similar thing if we hit the screen again.

If we touch the screen again.

I'm going to take out the code here that would rotate the head before.

And now I'm going to add code that's going to add the smoke.

So we're going to do the same thing.

We're going to find a path for the smoke.

And then we're going to create a new SK emitter node, which is going to be a smoke

emitter, and that's going to rely on the smoke path to find it.

We are also going to make its position be (0, 30).

Actually, let's make it just a touch ahead, a touch up, so

it's over the fire itself.

And then,

we're not going to give it a target node, because we still want to show the same

problem that we have without having the target node, so that's a smoke emitter.

That's a smoke emitter.

And we will also add it.

So the first touch is the guy's head's going to catch on fire.

It should continue to play.

The second touch will start to have smoke come out.

All right, let's see that happen.

Okay, here we go.

First touch, head catches on fire.

Second touch, smoke starts to come out.

Now you can see that the smoke is moving around with the guy.

And that's actually a little bit weird, because the smoke should be in

the atmosphere, not moving around with the guy.

I also see the smoke is a little too high.

So let's stop it and let's change the target node for those things.

So let's go back to the fire and after we set the position of the fire,

let's say that the fire emitters target node

is going to be equal to the scene, so in this case self.

And we'll do the same thing, I want to lower the fire a little bit,

let's put it down to 40, actually let's do 35.

And then I want to make the smoke emitters target node be equal to self as well.

And I do this so that you can see the effect of target node.

Let's go ahead an run it.

Wait for it to come up.

There's a guy running around.

Okay now I'm going to hit the screen once, the fire is going to come on.

And you can see the fire is associated with the environment now,

rather than being associated with the man.

And so as the man moves around, the particles that have already been emitted,

remain relative to the background and scene.

You can see this even more so when I add smoke to it.

I just touched it for smoke.

So now you see the smoke comes out, and if we can get some particles to lift him up

in the air, you can see that the smoke remains wherever it was lifted.

So now you've got a man running around with a burning head.

That's a success I'd say.

Man running around with a burning head.

Okay, that was the code check.

That's what I wanted to demonstrate.

What we've seen here is we've seen that you can use particle systems to do

efficient animations.

There's some tricks to them.

For example, setting the target node.

You can have multiple particle systems running it at the same time and

in this example,

we had particle systems that didn't have a maximum number of nodes and so they would

continue to emit indefinitely until you destroyed the node or stopped it.

Okay.

So, thank you for your attention.

[MUSIC]

Particle System Code Check

Games, Sensors and Media

Meet the Instructors