Before we move on to the next bit, let's take a step back.

We covered a lot in the last video, most of which wasn't anything new conceptually.

We just put a lot of stuff together that we've learnt in the past few courses

and videos.

We started by creating a simple structure, Point.

We use Point to represent a coordinate point.

And it contains two simple stored properties X and

Y that allow us to place it on a hypothetical map.

Point also has a single method surrounding points that given a range

returns an array containing all the possible points surrounding it.

Point is an object that then form the basis for two new types.

The first one was a class that represented an enemy in our game.

The enemy needs to occupy a space on the map.

And we model this by giving it a stored property of type Point

since we can use custom types as building blocks for other objects.

An enemy also has a life which is a variable stored property and

can be changed.

We don't change this property directly, instead we added a method to our class,

Decrease Health, that reduces the health of the enemy by some factor.

When we want to affect the enemy's life, we simply call the decrease Health method.

This is a common pattern that you will soon learn, where we try to use methods to

interact with our objects instead of manipulating the properties directly.

The second class we created was a Tower.

Like enemy, towers also occupy a position on the map.

So we give it an instance of Point as a stored property.

Here's where things get interesting.

Towers can fire at enemies, so

we created an instance method that takes an enemy as a parameter.

It checks whether the enemy is in range of the tower, and

if it is, it calls the instance method,

Decrease Health, on that instance of enemy until it is vanquished.

As I've mentioned so far, all these functions we wrote, and

the properties are objects contained, are instance methods and properties.

So to put any of this to use, we need to create an instance,

which is what we do at the bottom.

Once an instance is created the values we pass in

through our initializer methods are substituted where we use them.

For example, since the fire method takes an enemy as a parameter,

we can pass in several different enemies and different points on the map.

And see how our game works.

So why don't you give this a try to see if you understand what's going on so far.

Create an instance of enemy and place it far away from the tower.

Then call the fire method on that tower and pass in this new enemy as an argument.

What happens?

What we just wrote while not complex code

can be hard to understand at first because there's simply a lot going on.

We've never created objects before.

Much less objects that interacted with each other.

Re-watch watch this video, if you have to.

Because getting this mental model in place of how objects interact with

one another through stored properties and instance methods is very important

because in the next few videos, we're going to build on top of it.