When creating a game, there are some things

that are very close to the real world.

You have gravity, objects colliding with each other,

or maybe just coming in contact with each other.

That's why the best gaming frameworks have a physics engine

to help you mimic the physics of the real world.

Let's take a look at how we can set up our physics world.

The existence of a physics world allows us to start adding physics bodies.

A physics body gives us a mass and shape to our nodes.

This allows them to interact with each other

and be affected by forces such as gravity.

The larger the node, the more mass it will have.

We will be adding physics bodies to both our enemies and projectiles.

The physics body will be invisible to the user,

but we can define it to surround the node.

That way, if one node collides with another, we can be notified.

We also need a physics body to represent the ground so that

we can be notified when an enemy comes in contact with it.

This will mean the player loses a life and the enemy has done his job.

Armed with this knowledge, let's go define our physics world.

[BLANK_AUDIO]

So, now that we understand a bit about physics engines and

gaming frameworks, let's go over to our gameplay scene and nvinitwithsize method.

Right after we call this add space dog

method we'll refer to our self dot physics world.

Now, if I option click on the physics world, you'll

notice that the property belongs to a class called SK

physics world, and it says every scene automatically creates a

physics world object to simulate physics on node in the scene.

And it says you can use this property

to access scenes global physics properties, such as gravity.

So, let's go ahead and set up gravity.

So, we'll say physics world dot gravity, and gravity is a CG

vector, so we can use the function CG vector make to create a vector.

And a vector basically takes in delta x and delta y.

It's the change in x and the change in y.

So, there's not gonna be any change in

x, because gravity for us goes vertically downwards.

We're going to mimic Earth's gravity.

So, Earth's gravity is minus 9.8 meters per second squared.

I understand that Space Cat is on the moon but we are going to use Earth's gravity.

So, let me run our game

and you'll notice that it really didn't change our game.

That's because we need to set up physics

on individual nodes and we haven't done that yet.

So, before I do anything with the space dogs,

what we need is a ground node, so that when

the dogs hit the ground we can detect collision and

we can do all kinds of physics with the ground.

So, let's right click in our project navigator and

we'll select new file, and we'll create a ground node.

[BLANK_AUDIO]

Now, with the ground note, we need to create a method that takes in the size.

So, let's say, instance type, ground with size, and it'll be a CGSize.

Let's copy this method declaration and we'll go over to our implementation.

It says here we'll be at THGroundnode ground equals self.

So, we've already defined spikeit nodes with

images and we've also defined them with colors.

So, for testing purpose, we're going to give it a color.

So, we'll say sprite node with color colon, sk color.

Green color, and then size colon size.

So, we need to give our ground node a name so we'll give it a name.

Next, we need to define a physics body.

We'll say ground dot physics body and that will be S K physics body.

Now, SKPhysicsBody has several different methods, so

let's look at the documentation for SKPhysicsBody.

You can see, you can create

volume-based physics bodies,

so bodyWithCircle, bodyWithRectangle, bodyWithOtherBodies.

And then you can give it different pats too if you wanted to.

So, we'll just define a simple physics body, so we'll say bodyWithRectangleOfSize

and then we just pass it the size.

What we are missing is the position

so we'll say ground.position is equal to CGPointMake.

And this will be size dot width divided by two comma size dot height divided by two.

And now we simply return ground.

So, let's run our game.

Oops, I am missing an asterisk there.

All right.

So, now, let's go over back our game play scene

and we need to add our ground node to our scene.

So, I'll do import TH ground node

and then back in our init method, I'll declare a new ground node,

TH ground node, ground with size.

We'll say CGSizeMake and for the width, we'll give it the width of the frame,

so we say self.frame.width and for the height, we'll give it 22.

Then, we'll do self.addChildground.

So, let's run our game,

and as you noticed that the ground

appeared and then it quickly just disappeared.

So, let's stop our game and I'm going to change the physics world gravity, instead

of negative 9.8, I'll change it to a

positive and then, let's run our game again.

And you see that the ground actually floats upwards because

now we're declaring the physics to be a positive delta y.

We're gonna make this -9.8.

So, as you can see how physics has an

effect on knowns once the physics body has been defined.

As for the ground let's go over back to the implementation.

What we can do with the ground

is we can say ground.physicsBody.affectedByGravity

equals NO.

So, this way it's going to prevent the ground from

being affected by gravity, and prevent it from moving about.

So, now you can see that the ground stays in position.