According to the rules of the game, towers can't be placed directly on the path.

We need a way to know if a map location is on the path.

Let's add another method to the Path class that will return true,

if the map location passed in, is on the path.

So we'll say public bool IsOnPath and

it will take a MapLocation as a parameter.

And this method, will loop through all of the locations in the path array.

So we'll say, foreach(var pathLocation in _path,

And if the location passed in equals one of the path locations,

We'll return true immediately.

Otherwise, if we get through all of the locations on the path and

we get down here to the end of the four H loop we'll return false.

Because we didn't find a matching location in the path array.

To test this, let's create a map location that is on the path.

For now, we'll just do this in the Game.cs file.

So here we have our path.

Under here, let's create a new MapLocation.

And we'll have it be right at the beginning of the path, so

right here at 0, 2.

Just copy that down there.

Now we can say if(path.IsOnPath and

pass in that location we just created.

Then on the console will print,

location + " is on the path".

And just so we don't continue down into our program we'll return right here.

Let's go ahead and compile and run this.

Hm.

We didn't see our message.

We should have seen this message printed to the console.

And we shouldn't have seen any of this stuff because we would have returned.

We must have a bug in the IsOnPath method.

Let's take a second look.

On the surface it looks correct, doesn't it?

There's something very subtle happening here.

This double equals sign checks to see if two variables refer to the same object.

This is different than two locations on the map being the same.

Let's go back to Game.cs to see the MapLocation objects that should have

caused the IsOnPath method to return true.

Here's the MapLocation that's in the path array, and

here's the MapLocation that we're checking against.

They may look the same, but these are actually two very different objects.

See, here we created a new MapLocation and put it in this array, and

down here we created a completely different MapLocation.

They just so happen to refer to the same location on the map.

It's like they're identical twins.

They aren't the same person, but they look identical.

The equality operator by default,

only checks to see if they are the exact same object.

Or in the case of twins, the exact same person.

On the computer, these two objects sit in different locations in memory.

The equality operator actually just calls the static, system.object.ReferenceEqual

method to determine if two variables refer to the same location in memory.

In which case, they are the same object.

If two variables refer to the same object in memory,

we can say that they have reference equality.

That's all that double equals equality operator checks for.