Before we add physics to our Space Dog, let's go

ahead and make our physics configuration a bit more modular.

Which means, that I just want to put all this physics set up in its own method.

We'll say, setupPhysicsBody.

And let's copy all the lines related to the physics set up in it's own method.

So

instead of ground, it will be self, because this is

an instance method, which is indicated by this minus sign here.

And then the body of rectangle with size.

This would simply be self.frame.size.

And now here, we would simply call ground setupPhysicsBody.

[BLANK_AUDIO]

So, similarly for spaceDog node, we'll go ahead and create a method.

We'll say setupPhysicsBody, and then physicsBody.,

is equal to SKPhysicsBody bodyWithRectangleOfSize

and then we'll give it self.frame.size.

So, let's try this for now, going to the previous method,

which is spaceDogOfType, in that we will call our physicsBody setup method.

So, we'll say spaceDog setupPhysicsBody.

All right, so, let's run our game.

And if you'll notice that the two dogs fell towards the moon and

they took the ground with them, that's crazy, the ground shouldn't have moved.

So, what we are missing with the ground

is, let's go over to the ground implementation.

There's a property called dynamic which means that

the ground should not be affected by the physics.

If I option click on dynamic, I'll say that a Boolean value

that indicates whether the physics body is moved by the physics simulation.

We do not want it to be moved.

So that's why we have to set it to no.

It also goes on to say, if the value is known,

then the physics body ignores all forces and impulses applied to it.

And that's exactly what we want.

So, let's run our game once again.

And now you'll notice that both the Space Dogs, they just fall to the ground.

So, that's all well and good.

But, the Space Dogs have space suits, which

means that they're moving at a constant speed.

They're not just hurtling towards the ground.

So, let's go over to our spaceDog implementation and in the

setupPhysicsBody, we'll also set our affectedByGravity property to no.

We'll say like, well, how will they move towards the ground?

Well, what we're going to do is, we're going to define a velocity.

Because after all, the space dogs in their space suits are

moving at a certain velocity towards the surface of the moon.

At least, that's what we want the user to get the feel of.

So, what we'll do is we'll say, self.physicsBody.velocity is equal to.

And remember, CG vector from our gravity?

Well, once again we can define the delta x and delta y.

The delta x will be zero, and the delta y has to be a little faster.

So I'm going to set it at minus 50.

And now let's run our game.

And you'll see that it's moving at a pretty decent pace.

And we can shoot it too.

So, now that we've added physics to our ground, to

our enemies, the only thing that's missing is our projectile.

So, let's go ahead and create a method inside our projectile node.

We'll say, setupPhysicsBody

self.physicsBody is equal to SKPhysicsBody,

bodyWithRectangleOfSize, self.frame.size.

You should be able to recite this in your sleep now.

Self.physicsBody.affectedByGravity is equal to NO.

We just wanna give our projectile a physics body.

We don't want it to be affected by gravity.

And once again, in our projectile position method, we'll call the setupPhysicsBody.

All right, let's run our game.

So, now you'll notice if you keep consistently hitting our

enemy with our projectile, it has some weird effects to it.

It actually moves it and this is due to collision in our physics engine.

When two nodes collide, it impacts the velocity of the two nodes.

So our projectile's velocity is not effected

as much because it's small, but our enemies,

our space dogs, are effected a bit more because their, their mass is much larger.

So, in the next video, we'll find out what collisions are and

what contacts are and how we can define collisions and contact masks.