Here it comes, the last story to complete our minimum viable product.

If you thought it felt good to move the stories to the Done column,

wait until you see what it feels like to move the last one.

So here it is.

As a guesser, I should be able to know when the game is won or lost so

that I can acknowledge completion with celebration or tears.

All right, we can definitely do this.

So we should provide a method that returns whether or

not the game [SOUND] was completed successfully.

So how do we do that?

Well, one way to do it is just to check and see if there's any blanks left.

We should just start with this approach.

[SOUND] If there is a blank, the game has not been won.

And then we should have the prompter display the final outcome,

spreading the good or bad news to our users.

Here we go.

All right, let's move our final ticket over to the In Progress column.

We need to let people know if they won or not.

So, let's go to Game really quick,

let's stop our program from running, and let's get in here.

Let's say, we need to let the game know if it's won or not.

So let's just go ahead and let's put it here.

Let's say, public and its true and false, right?

So boolean and isWon, and remember is, is the,

like the getter, it's a computed getter, right?

So, we're gonna say isWon, where normally if it was not boolean,

it would have been get for the stringer and integer or something.

But it's is because that's the format of the reason.

And we're going to calculate our value, so let's just use that

existing method like we talked about, so as I getCurrentProgress.

Now, I could store this in a variable,

but I know that this is going to return a string.

And so that string has a method on it that allows us to see if a character exists.

What was that called again, indexOf.

So, what I can do is I can do a .indexOf, right?

So it's method chaining.

And we wanna see if there is in fact, any of those dashes in there.

It's probably a good place to make a constant,

if we wanted to make this a little bit better.

And then we want to check and see if it was, in fact, not found.

So we're gonna say, is it not found?

If that's not found, they won.

That's the logic theory.

Cool.

So this returns a string.

And then that string is checked to see if it's dashes.

And then we see, if there are any dashes in there.

Then they have, in fact, not won, cuz their stuff left to guess.

Okay, so let's go use it.

In our main program here, in Hangman.java.

We want the game to stop looping once it's been won.

Now this logic might be a little challenging here, but

let's think it through.

So currently the loop goes as long as there are remaining tries.

So we wanna add another condition, and it really is this.

As long as the game hasn't been won.

Okay, so while there are remaining tries,

and we just wrote that game is won, but

what we want is not won.

It's so hard to not do a bar impersonation here, not.

Sorry, so that's what we want.

Where both of these are true, keep going, right?

So we wanna keep going where both of these are true.

When this is checked, it will keep going and each one of these will go.

So when it's all done, we wanna display the outcome, right?

So, we would do something like this, right?

So it's a prompter.displayOutcome.

Now, we haven't written that method yet, but I bet you could.

Why don't you go ahead and pause me?

What we're gonna do before you pause, let's get the instructions.

What we're gonna do here is we're gonna try to show if they've won,

we're gonna say, congratulations.

And if they failed, we're gonna say, sorry, here's what the answer was.

So why don't you go write that method?

And notice, it doesn't return anything.

Okay, go ahead, pause me and come back when you're ready.

Cool, this is how I did it.

So, under displayProgress here, I added a new method.

And of course, it doesn't return anything.

So that's a void.

Display outcome.

All right, so if the game was won, we wanna say, congratulations.

So let's say, if game is won.

I'm gonna close my if and I'm gonna say, else and

then that's where we're gonna put this, add here.

So here we go.

So, we want to say system.out.printf.

Congratulations, you won with, let's go ahead and

say how many tries they had remaining.

With %d tries remaining.

Again, we'll extra feature there.

Wasn't asked for.

Maybe we shouldn't do that.

We'll see what they think of the demo.

All right, so you won with that many tries remaining,

and we're going to say, game.getRemainingTries.

Otherwise, we're

going to .out.printf,

Bummer, the word was %s.

And I'm gonna make a sad face there, we'll say, %n.

Okay, and then we need to get access to the answer, don't we?

Prompter doesn't have access to the answer.

So I'm gonna write a getAnswer method over here, sounds a little tricky wasn't it?

So over here in Game, I'm gonna make a getter for getAnswer, right?

So our answer is still private but we can add a getter,

want to add a getter up here at the top.

So we'll say our public,

we want this to be public.

And it's a string and we wanna say,

getAnswer, and it doesn't expect anything, and we are going to return the answer.

Cool, let's see how I did.

I'm sure you did great, clear && javac

Hangman.java && java Hangman.

Let's test it, T-R-E-H-O-U-S.

We did it with seven tries remaining, awesome.

Okay, let's try to fail really quick.

A-B-C-D-E-F-G-I.

Bummer, the word history was treehouse, sad face.

My gosh, we did it, the sprint is over.

[APPLAUSE] >> Wohoo, we just did it.

We got a working Hangman MVP.

And what a great job of separating the prompting from the game logic.

Now, we could do a web-based version of this, or use it in an Android app, or

play it on a WiFi enabled refrigerator, you get the point.

The other great thing about this game class that we created is that

the implementation details are hidden.

We absolutely could make this game more efficient as long as we kept up our end

of the deal, and we kept the interface, or the exposed methods and functionality.

If we kept those the same, every single one of the users of this class,

the console, the website, the Android app, the refrigerator, they'd all benefit.

Also, because you did a great job of naming your methods, almost any English

speaker could pick up that class and know exactly what it's expected to do without

ever seeing the methods code, just like that radio example we talked about.

Great job harnessing the power of objects.

One more thing I told you that I'd show you was how to pass an arguments to

the command line.

I mean after all, if you're gonna play this game,

you probably want to eventually use a different word than treehouse, right?

First though, an exercise.