OK, so to get that game playable again, so that when we press this play button, the game actually starts. Let's go back into our app initialize script. And we need to create a new method. And this will, it's going to be encouraging actually, but this method will Curtin is going to do everything that needs to happen when I gave me to stop, so we don't actually need update so we can get rid of update. And we can run ienumerator. Stop game.

Cool. So this one actually, you see we've got an error already, because our numerators need to return something. And what we can normally do is we could like get it to wait for a few seconds and stuff but we don't want to wait every single time we play the game. We want to only when we press play after we die, we want to maybe wait for a second. When we press play when we first started playing the game. We don't want it to actually like wait for a second we just want to stop playing the game, if that makes sense.

So what we need to do is we need to have a, we can have a local variable. Now we haven't done this yet, inside of this project. So if you're a little bit confused by it, that's fine. I think this is the only instance that will actually use this. But we're going to do is inside of here we can pass some arguments that need to be cold when start game is called. And the argument is we that we're just going to make the variable that we that you're going to need to put in for the argument, we're just going to make it a float.

And we're just going to call this white time. No, semicolon there. And then we can just say, yield, return, not on new. wait for seconds. And normally, we would just put a number in here, but instead of putting a number in, we can just actually put in wait time Which is this float here? Now why is this important?

Why have we done it like this? Well, it means that when we actually call this carotene, we can call it in such a way where we can actually designate how long it needs to wait for whether that's zero seconds, or whether that's one second, or 10 seconds, or whatever. And we'll be using this method for two different purposes for purposes when we end on the game over screen, and we want to start again, or for purposes when we just start the game. So the other things that we want to do inside of start game, change all of these, so we'll copy all these, paste them in there. And we only want the in game UI to be on so the other two will be false obviously, so make these false and make this true. Cool.

We probably want this yield statement underneath all of these instructions here. And then underneath white underneath is yield. We just want to set the players motion back to Whatever it originally was. So we can just grab this copy of this line of code, dump it in here. And we can say rigidbody dot constraints, dot none. So now it's turned off all the constraints.

And the only constraint we do actually want on is the y. So we can go back, dump that in there again, and say, freeze position. Why? Cool. So let's turn them all off, and then turn the why freezing back on. Fantastic.

So you may be thinking, great, we've got this long wall, not really long. But we've got this big method here that kind of explained that it does everything that you know you'd expect it to do. But how do we actually call this method from inside the game when we actually press the play button? So if we press play now, you'll see that nothing happens? Well, we actually need to create a method that the play button can use. So how do we do that?

If we need to create a new method called public, and it's important to say public so we can access it with inside Inspector void play button. Cool. So later on, we'll add some more functional add some if statements inside the play button to do the wait time functionality. But for now all we need to do is write start coding or parentheses start game, which is the name of the couraging. open parentheses again, and now it's asking you can see here it's asking for our wait time. And we're just going to say 0.0 F, which is 0.0 seconds.

And then we're just going to close it off with a semicolon. Awesome. So let's test this out. So if we go over to our game, we can go inside of the in menu UI, we can turn it on just because we're working on it. And we can go to our play button, and you'll see here has a method called on click where we can actually press the Add to list. We can choose the scene manager, drag it into that selection there.

Then we can actually access functions that are on that script. So if we go click on this no functions, we can go down to App initialize, which is one of the scripts that's on the scene manager object. And we can go to play button. So that what that will mean is when we press the when we click this button, whether it's a touchscreen, or we're clicking on it with our mouse, it'll run the play button method on the app initialize script. And when we go over to our app, initialize script and we see Play Button play button, it calls the start game curtain. And the start game co routine, changes our menus waits for however long it needs to wait, which at the moment is note no matter of time, and then puts the rigid body constraints back to in game functionality.

So that should be pretty easy to understand. I hope everyone's following along. But if we press play now and see what happens, we press play. Awesome, so the game starts. And that works great. Let me start that again.

Press play. Once again, I can press play As the game starts playing, and everyone is happy. Awesome. So in the next episode, we'll start dealing with pause menus and things like that and continue on with this menu functionality.