We have the objects we need to create a story for the app.

But we don't want to create the story in our View Controller

every time we initialize a new page of the app, because, for

starters, that's not the View Controller's job.

Let's create a simple wrapper struct that lets us construct a story.

We'll then use this wrapper object to initialize the View Controller.

Because we're giving the View Controller data to work with

rather than creating the data inside the view controller,

we're abstracting the data from the presentation.

The View Controller doesn't care where the data comes from.

It just needs to come in a certain format.

So we can do this in-page, or you can create a new file, and

I'll just do this in-page.

At the bottom, we're going to call our new struct Adventure.

This struct will have a single static computed property that returns the story

we're going to use in the app.

Because a story is many pages linked together, all this computed

property needs to return is the top level page that contains all the linked pages.

This kind of structure where object contains a reference to the next instance

of the object is called a linked list.

In a linked list, an element or node in the list

contains some sort of value it is storing, along with a reference to the next node.

A linked list offers similar functionality as an array, and

depending on your use case, can have certain advantages.

In an array, every element is sequentially stored in a data structure.

If you are constantly removing or adding elements to the array, and

your array is really large, this is a computationally expensive operation.

When an arbitrary element is removed, every single element in the array

after that element has to be shifted one position to maintain the array.

With a linked list, however, because every node simply contains a reference to each

node, inserting one in any position simply means rearranging the node connections.

There's a lot more to linked lists than this, though.

The example we're looking at here is called a singly linked list.

Because each element links to one other element, it is a single linked list.

Now, in a doubly linked list, each element references the next,

as well as a previous element.

Our data structure, although it looks kinda like a linked list,

is not really one.

If we had only one choice, then, yes, we start to resemble a singly linked list.

But our data structure is more like a tree.

Each page connects to two pages,

which can connect to two more pages until the end of time.

So what's the point of all this?

There are many ways to represent data in code.

We use objects to encapsulate data, but, so far,

we've mostly stored this data in arrays or dictionaries.

The page class is the first structure that we've created

that allows us to store many levels of data outside of an array or dictionary.

We're not going to spend much time on data structures here.

That is an entirely new topic altogether.

But we will talk about them as they come up.

In the meantime,

I've put a few links together that you should definitely check out.

Even though you are here to learn iOS development, knowing about the larger

world of computer science and software engineering is quite important.

Okay, so back to our property.

Since page contains a tree of pages forming a story, all we need to return

is the top of the tree, a single page instance that links everything else.

So in Adventure,

we'll create a static property named story that returns the top level page.

Inside the body, let's construct our story using pages, so

you can finally see how neatly our data model comes together.

Let's start with the very top level of our story, the introduction.

We'll say, let returnTrip, we'll create our first page,

= Page, and we'll initialize it with the story.

That is the returnTrip segment of ARINA.

We have an error here.

What is this?

Says Expected pattern, we'll ignore this for now.

Now, because this is the top level of the page, this is the very first page, and

it's going to link to every other page, we can go ahead return this one.

So we'll say return returnTrip, and now we, basically,

have our Page that we want to return.

Let's see if we can get rid of this error.

Okay, there we go.

Now that we have our main page, let's connect the rest of the story together.

So this is the very first page, and every page has two choices.

So next we want to add two choices for the user to continue down.

So we'll say returnTrip.addChoiceWith.

We'll use the method that takes the story.

And for the title we'll say, "Stop and

Investigate" and the story segment is touchDown.

So to returnTrip here,

we're going to use the addChoiceWith method that takes a title and a story.

And we pass in an appropriate title and

the next part of the story based on the choice that we want to link to.

Remember that the story we pass in creates another page,

and our method returns this page.

So we can assign this page to another constant.

So here we can say, let touchDown,

because that's the segment of the story we're connecting to, = returnTrip.

Okay, now we have two pages.

So far, our story looks like this.

Let's add another choice to returnTrip, since each page can contain two choices.

So here we'll say, let homeward, because remember,

adding a choice returns that new page.

And we'll add this again to returnTrip, and the title

here is "Continue home to Earth" and the story is homeward.

Okay, now our tree looks like this.

Since each time we added a choice, we returned and assigned

the new page to a constant, we can now add choices to those new pages as well.

So let's add two more choices to the page containing the touchDown story.

So let's say, let rover = touchdown.addChoiceWith,

"Explore the Rover" and the story is .rover.

We'll also add one more,

let crate = touchdown.addChoiceWith,

"Open the Crate" and the story is crate.

Now our growing tree looks like this.

In this way, we can add the rest of the story in, which I'm going to copy/paste.

And, again,

you can grab the rest of the code from the link in the teacher's notes section.

Again, since the top level page returnTrip now contains the entire story,

since we're linking all these pages together,

we can simply return returnTrip at the end, and now we have our full story.

Before we conclude our model-building activities, I wanna point something out.

When we learned about value types, reference types, and

some of their semantics, we learned that creating a struct that contains reference

types can lead to some weird behavior.

But then I went right ahead and

created a struct called Adventure that returns a page that links to other pages.

And these are reference types.

And this case,

it's okay, because we're creating a static read-only computed property.

We can't mess with the underlying reference types over here and

mutate the data inside of the Adventure struct.

Now, we can do that once we retrieve the instance of page it returns, but

that is a different issue altogether.

Okay, onto the next video.