[MUSIC]

Hi there.

My name is Passan and

welcome to the course on object oriented programming in swift.

This course requires a basic understanding of the swift programming language.

So before you begin,

make sure that you have completed all the prerequisites associated with this course.

So far, we've worked with many of swift's built in data types.

We've worked with strings, numbers in the form of ints, doubles, and

floats, collections such as arrays and dictionaries, and

logic in the form of boolean true and false.

These types have served us well and enabled us to write plenty of code.

But there comes a time when the built in types don't model data well enough for us.

For example, when I think of my fellow teacher Ben,

I don't think of Ben as a constant called name with a string value Ben,

an integer variable for his age and so on.

These individual types allows us to create data points to model

different aspects of Ben but individually they don't make much sense.

Ben's name and age are a part of who Ben is, not a random data point.

Luckily for us, swift allows us to create complex and custom data types.

Fair warning though,

we're about to make a cognitive leap here in programming concepts.

So it's important that you pay both close attention and practice a lot.

You may even have to watch these videos more than once.

Let's build an example from the ground up, so

we understand what a custom data type looks like.

Let's imagine we're building a game that's always interesting, right?

Imagine a simple 2D tower defense game.

If you haven't played one of those, think of it this way.

We have a map which for

our sake will be a simple 2D map that we view from above like a chess board.

The map is split up into a system of x and y coordinates.

On this map we can place towers in random positions.

These towers can fire on enemies if they get too close.

This is all really complex, so let's start super simple.

We're not going to build a game, mind you.

So sorry if I got you excited.

We're going to take a stab at how we can model data and create custom types.

Let's think about how this game works.

Towers are placed at certain points and can fire at a number of other points.

Enemies can also exist at certain points on the map.

The common denominator amongst all of this is the point.

We need to figure out a way to store the location or

coordinate information where either a tower or an enemy is.

Without this information, we can't really proceed and model anything else.

Since this is a simple 2D game, we can use X and

Y coordinates like a graph on a piece of paper to specify positions.

The bottom left of the map is the starting position and has X and Y values of 0.

Moving to the left horizontally, increases X values,

moving up vertically along the Y axis increases Y values.

So that this point two spaces up and to do the right has an X value of 2 and

a Y value of 2 or a coordinate 2,2.

Let's try and store this information using the knowledge we currently have.

Now I have a new playground here, so go ahead and create one and

call it Object Oriented Swift.

We could declare two constants x1 and y1 to store a coordinate.

So we'll say, let x1 = 0 and let y1 = 0.

These two values together represent a single coordinate point.

And this works, but we need these two data points to be related to one another

because by themselves, they only paint half the picture.

In the course on functions, we learned about a construct called tuples

that we could use to return multiple values from functions.

We can use a tuple here as well to combine these numbers

into one single compound value.

So I can say, let coordinate1 and

then I'll give you the type explicitly and this type is going to be a tuple and

we'll say, it's going to be an integer and an integer.

And remember we can also give tuples labels or say this is x and this is y.

And now to this, we can assign 0,0 as our coordinate.

Say here I'm specifying that type of the constant as a tuple with 2 Ints.

I can then assign names to these values, so

that we can refer to them easily like so.

So we can say coordinate1.x and we'll gain 0, all right?

This seems to work, but

we're going to be dealing with lots of different coordinates all over our map,

locations where the enemies are and where the towers are placed and so on.

We could store different values like this in an array but

that's also inconvenient because there is no meaningful way to understand what point

is associated with a particular enemy.

We could also do this with a dictionary where let's say, an enemy is the key and

then we have values for points and things on that but that still is cumbersome.

So, to do this,

we're going to create a custom type using a construct known as a structure.

A structure, or struct, is a flexible data type

that allows you to group together related values and model them as a unit.

We'll see what this means in just a second.

I should warn you, we're about to learn a large number of new terms here.

So either refer to the Swift book, which I've linked to in the teacher's notes,

to get more clarity on the meanings.

Or you should write down these definitions that come up so

that you can become more intimately familiar with them.

Let's dive right in.

We're going to create a struct to model a point on our map.

So as always, remember, new topics means new syntax, and

here we start with the struct keyword.

We then give our struct a name, and

this name is the name of our custom data type, so I'm going to call it Point.

Earlier, you learned that when naming functions or

variables, you need to use the camel case convention.

That's the first letter is lowercase and

the first letter of subsequent words are uppercase.

Now, this is more specifically called lower camel case because of that

first letter being lowercase.

When naming structs or any other custom data type for

that matter, we use upper camel case which means that, it's just like

lower camel case except that the first letter is also upper case and

then the first letter of subsequent words are uppercase as well.

For this reason the name Point starts with an upper case P.

We then start the body of the struct with a set of curly braces.

Inside the body, we're going to add two lines of code to begin with.

So say let x, and we'll give it a type Int.

Let y, and we'll also give it a type Int.

Now before I explain, what this is to you?

This looks like we're simply declaring two constants and

explicitly giving them a type and that's basically it.

A struct can define constants or variables which we call properties to store values.

So, remember these are called properties.

More specifically, they're called stored properties and what we've done here is,

create two stored properties.

Keep that term in mind.

So the first stored property here is a constant,

has the name x, and the type Int.

You'll notice that unlike anything we've done before,

we're not assigning any value to it and that's okay.

The second line creates a second stored property,

also a constant named y this time, and also of type Int.

Now outside of the struct below it, let's add another line of code.

So we'll say, let p1 = and then we type Point and then an open parentheses.

And you'll see that x code autocompletes to give us something like this.

So this looks like a function that takes an argument for x and y.

So let's give it one, we'll say 0 and 0.

Despite being seemingly simple, there's a lot going on on this one line of code.

But let's take a break here and

in the next video prepare to have your mind blown.