All right.

So our next ticket in order of priority is this, as a guesser I should

know how many remaining tries I have left so I am encouraged to be cautious.

So basically this implies that we're going to need to allow multiple guesses through

some sort of loop until they run out of tries.

Now in order to do that we'll have to set a limit.

That limit seems like something we want to make publicly available and

it's related to all games and it shouldn't change.

We know how to do that.

Let's make a constant.

Let's sketch out the remaining tries logic real quick.

So a standard hangman game allows you to miss seven times.

So let's look at a game in progress.

So a t and an h were a hit and z and w were incorrect guesses.

So therefore if we count how many misses they've made and subtract that

from the total amount of tries, we should know how many tries remain.

Here there are seven misses allowed and there have been two bad guess so

seven minus two is five.

So there are five tries remaining and if we guess why it appends the misses and

now there are three misses and 7- 3 = 4.

So there is four guesses left.

All right let's do this.

Okay so let's move our remaining tries take it into in progress.

All right, so let's go and set our guess limit.

This is definitely public and we want it to be true of all games.

So let's expose it off of the class.

So we'll make that static.

And we definitely don't want to change, right.

I don't want anybody cheating.

So that's final.

It's an integer and because it's a constant,

let's make the name all capitals.

So we'll do max under misses.

So like we said seven is the standard number of tries.

Now let's write some code that exposes how many tries are left.

I'm gonna start Jshell up down here.

So again that code was max misses allowed minus how many misses they have made.

But, how do we count the amount of misses?

So, because it is a string

we can use a new method that you might not have seen before.

So we'll say string.example = 'hello'.

You want .example.

So now if we do example.link, we'll see that there were 5.

So that will work because we'll know how many misses are there because our string

will be that long.

Cool.

So in the game object let's go ahead and make a new computed property right.

So we want to be public because we want people to use it.

And it's going to return a number and

let's call it getRemainingTtries and this lines up with the user story.

And so what do we wanna do?

We wanna return here,

we wanna return that max misses that we just made, that's how many were there,

minus the misses and because it's a string we'll just use that length property there.

Cool.

Okay so now that we have it, let's make our display progress get upgraded.

Let's put it in there.

So let's say you have %d.

And now %d is where you wanna show numbers in a string formatter.

I put some more in the teacher's notes about this.

But, you want %D, and D stands for decimal there.

So, you have %D tries left to solve and

then here we go and then %S will still stay there.

So, if there's two string formatters, the first will say game.getRemainingTries and

we'll call that into a comma.

There we go.

So now it will push that remaining tries count that we have in there.

So now let's build a loop that will just keep asking

while there are remaining attempts.

Now the specific story doesn't talk about what to do with a win.

So let's not handle that case yet.

Let's let the next person who picks up the next story deal with that.

Now this is a good development practice.

Limit your scope to the story that you're working on.

This way you don't have to run into other developers who might pick up the next

ticket and implement things differently than you might have.

Let's see what does that code look like.

Let's go ahead and let's get rid of this testing code that we're doing here before.

I gonna get rid of story aim and story in the variable.

So we have these two things and we wanna loop.

So what can we say, we said while we've got remaining tries,

so while game.getRemainingTries is greater than zero.

Right.

As long as there is more than zero tries left you can still keep playing.

So we'll go ahead and

move these in here.

Here we go, that should do it.

Let's bring this up, let's hit CTRL D, and let's see if it's here.

It's not, okay.

So, we'll say clear & javaC

Hangman.java & java hangman.

Okay here we go.

Awesome so it says we have seven tries left to solve which is right.

And let's see, let's guess T.

Cool so it didn't go down because we didn't miss but let's miss.

And then let's miss again.

And let's miss again, and see they're going down and it's right, so

now if we guess it should stay at four, it's that.

I just can't get this one.

What is it?

It's a Q, it's probably a Q.

You always guess Q, right?

So, uh-oh, oop there you go.

So it ran out.

So the loop finish when we're done.

I think we can go ahead and consider this one done-zo.

Hey, it's starting to look like a game and we're so close, only two stories left.

A good lesson that we learned here is that by only completing the task as required by

the story we had a good stopping point.

In case project scope or requirements for our NVP changed.

We're still on target, but

we could in fact bring in more people if we hit a time crunch.

Breaking down stories in the sane technical tasks takes a certain amount of

effort and finesse.

But it almost always pays off in the end.

Speaking of a stopping point, you've done an awful lot in this stage and

I think we should wrap this one up.

We've got an app-ish looking app and you deserve to take a break.

Give yourself a huge pat on the back.

You're mastering using Java objects and picking up some more core Java skills.

You're doing great.

Way to stick with it.

I've thrown a lot of information at you and you're processing it.

I am super impressed.

Of course though, you don't need me to tell you all that, because you've been

proving it yourself by rocking these exercises I keep throwing at you.

Like this final one for this stage.