We've only got one function standing between us and a finished Tableau class

and that's the remove cards function, but it won't be left standing for long.

Let's start by declaring our remove cards function right after our add cards

function.

Fun, remove cards, then for the parameter let's add an integer

named tapped index to represent which card was tapped.

And then add our brackets.

Now, we just need to remove the cards from our cards list from

the tappedIndex to the end.

To do that, we're going to use a for loop.

And Kotlin for loops are a little bit different than in Java.

For starters, in Kotlin all for loops take the form of some variable

followed by the in keyword and then the thing you'd like to loop over.

So if we wanted to loop over all the cards in our cards list, we would just type for

card in cards and then add our brackets.

Notice that I didn't use a var or vow to declare the card variable and

a for loop it's always going to be immutable.

So we can leave that part off.

So that's nice but we don't really want to loop through our entire card's list.

We just want to loop from the tappedIndex to the end.

So instead of looping with a card let's loop with an index like we're used to.

And let's use i and instead of having the cards list as the thing we'd like to loop

over, let's just use a range from the tappedIndex to the end.

A range is just a set of numbers like the numbers between one and seven.

If we wanted to print the numbers one through seven,

we could use a range like this one.

The two dots represent that this range

will include all the integers between one and seven.

But these dots only work if the range is increasing.

If we want to go from seven down to one we would need to write 7 downTo 1.

Now that we've got that covered,

let's loop over a range from the tappedIndex to the lastIndex.

Let's delete 7 downTo 1 and instead write tappedIndex to

cards.lastIndex.

And now we're successfully looping from the tappedIndex to the lastIndex.

So to remove those cards let's jump and set our four loop and

remove the card index i.

cards.removeAt and pass in i.

Finally, now that we've handled removing the cards,

we just need to make sure that the last card in our pile is face up,

provided that there is a last card in our pile.

Below our for

loop let's first make sure there's at least one card in our cards list.

If cards.size is greater than

zero and if there are let's set the last card to face up,

cards.last.faceUp equals true.

All right, we're all finished with our tableau class.

All that's left is to jump over to our game model class and

create a property for our tableau piles.

Let's add a line below our foundation piles and then type val tableau piles

and let's set it equal to a new array of size seven.

And then let's populate our array with seven instances of an empty tableau pile.

Remember, we'll be creating the tableau piles at the start of every game.

So for now we're just populating them with something so we don't get an error.

To populate our seven tableau piles,

let's use a lambda expression like we did in our debt class.

Let's start with the brackets, and then inside let's create a new tableau pile.

And since each tableau pile needs to be created with a list of cards,

let's add mutable list of as our parameter to initialize it with an empty list.

Next let's flip back to our Tableau pile class and inside the init

block let's copy in this if card.size greater than zero section.

To make sure we don't try to access a last card that doesn't exist.

After all, we did just call the constructor with an empty list.

So at this point, it's guaranteed to happen.

For one final step, I think it looks a little bit cleaner

if we just have an empty list be the default value for our cards list.

So inside our constructor let's add equals mutable list of and

now that we've got a default value.

Let's jump back to our game model and

now we can get rid of this unnecessary parameter.

We've come so far since the beginning of this course.

We've learned tons about Kotlin and we just finished up our Tableau object

which was the last object we needed to start modeling our game of solitaire.

But before we can move on, I feel like we've been doing a lot of coding and

we haven't been able to check if any of that works.

So let's take a minute and write some tests for a tableau pile.