"Android Lists and Adapters (2015)" was retired on July 11, 2018. You are now viewing the recommended replacement.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Well done!
You have completed Unity Basics!
You have completed Unity Basics!
Preview
Now that we know when the player hits a pipe, let’s reload the game so that they can start over.
Unity 6 Documentation
Resources
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
We're now detecting
0:01
collisions on our player
and singling out collisions with pipes.
0:02
Now we need to end the run for the player
so that they can't keep playing forever.
0:06
For now, I'm
going to simply reload the scene
0:10
so that they immediately start over.
0:12
It's going to feel a bit abrupt,
but in the next stage
0:14
we're going to polish up our game
and we'll implement a nice simple menu
0:17
for the player to restart
when they're ready.
0:21
Now we could add this scene
reloading logic
0:23
directly in our OnCollisionEnter2D
method in the Player script.
0:26
But I was thinking ahead a bit,
0:30
and I think it's time to create
an overall game manager script.
0:31
These are pretty common in games
and handle overall game logic
0:35
that doesn't need to be, or shouldn't be,
attached to a specific game object,
0:39
similar to our pipes manager.
0:43
This can eventually
handle our score as well.
0:45
So let's create a new
0:48
empty game object and name
it game manager.
0:49
I'm going to reset the transform
0:56
and move it up top before.
0:57
Let's go into our scripts
folder and create a new script
1:01
also named GameManager.
1:03
Finally, let's attach this script
1:15
to our new object
and open it up in our IDE.
1:17
Alright,
whenever we need to write code that works
1:21
with our scenes in Unity,
we need to use a specific namespace.
1:23
I'm going to go right beneath
our UnityEngine using directive and write
1:28
using UnityEngine.SceneManagement
and put in our semicolon.
1:31
This gives us access to a variety of tools
for working with our scenes.
1:37
To handle our scene reload, let's create
a custom method beneath Update.
1:42
private, void,
and let's name it ReloadScene.
1:46
In here, let's start typing SceneManager, dot,
1:54
and the method we want is LoadScene.
1:59
If we hover over it,
we see it states that it loads
2:05
the scene by its name
or index in the build settings.
2:08
You're probably wondering
what in the world build settings are.
2:12
Let's comment this out,
save the file, and head back to Unity.
2:16
If we go to File,
we'll see an option for Build Profiles.
2:21
Let's select that.
2:24
This is where we configure
most things for our game
2:26
when we create a build of it
that we can play on our machines.
2:28
You can see here is where we can change
the platform that we want to build it for.
2:32
I'm running Unity on Windows,
so it has this selected by default.
2:36
This is where you'll see the modules
installed to this version of Unity
2:40
that we did way back at the beginning.
2:43
So if you go install, say, the iOS module
2:45
and reopen this project,
it should be available in this list.
2:48
At the top of this list is Scene List.
2:51
Click on that.
2:53
Here we have what would be
a list of scenes that we've created
2:55
in our game that we want to include
in our final build.
2:58
We have SampleScene,
which Unity has added in automatically.
3:01
This is the scene created for us
when we created this project.
3:05
It's also the one we've been working
in, as you can see at the top of
3:08
the hierarchy here too.
3:11
Over on the right is our scene's index.
3:14
This one is 0,
because it's a zedo-based index.
3:16
Now, what I'm about to do isn't necessary,
just for demonstration.
3:20
I'm going to close this, go to the Scenes
folder in our project window,
3:24
and rename this to, say, GameScene.
3:27
Going back to the scene list,
3:34
you can see it's been updated,
as well as the top of the hierarchy.
3:35
Okay, let's close this out
and go back to our script.
3:39
So since we know that our game
will only have this one scene, we could
3:43
safely put zero in here as an argument
and this will work perfectly.
3:47
But what if we had
multiple scenes in our game?
3:51
I'd to show you a convenient way
of getting the current scene's
3:53
index in our code
so that this ReloadScene
3:56
method would work no matter what
level or menu the player would be on.
3:59
This is super useful in bigger games.
4:03
Let's save it to a new variable
to keep things readable.
4:06
So above this line, let's create an integer
variable and name it currentIndex.
4:09
We'll set it equal to SceneManager,
and what we want is GetActiveScene.
4:13
We'll see it's throwing an error.
4:25
If we hover over it, it says it
cannot convert type Scene to int.
4:27
This is because we're saying our variable
here is an integer,
4:31
but this GetActiveScene
method returns a scene object.
4:34
Lucky for us, there's a property we can
get off of a scene object to help us out.
4:38
After the parentheses,
we'll type .buildIndex.
4:42
This returns the index of the scene
in the build settings.
4:47
Perfect!
4:50
Now we just plug this into our LoadScene
method.
4:51
So to break this down,
we're creating an integer variable.
4:54
We're calling the GetActiveScene
method off of the SceneManager class,
4:58
which comes from the SceneManagement
namespace.
5:02
I know, right?
5:06
Then, we're getting the buildIndex value
of that active scene, which is an integer.
5:08
Then, we're telling Unity to load a scene
5:13
and providing it the index of the scene
that we want to load.
5:15
In our case, that is the scene
the player is currently playing.
5:19
Okay, now we need to call this method
5:23
at the right moment,
so let's head back into our player script.
5:25
In order to call a method from
another script, we need a reference to it,
5:29
just we need reference
5:33
to other game objects or components
in order to interact with them.
5:34
So up at the top, let's create a variable.
5:38
This will be a private
5:42
of type GameManager, since
that's what we named that class,
5:44
and let's name
it gameManager in camel case.
5:47
Down in Start, let's assign it a value.
5:53
We could have serialized this field
and drag and dropped our game manager
5:55
object into the slot,
5:59
but I wanted to show you
how to reference components
6:01
that are not attached to the same game
object in code.
6:03
To do this, we type gameManager equals,
6:06
then start typing Find.
6:10
We can see we have two options here
FindAnyObjectByType
6:12
or FindFirstObjectByType. They'll both work
for us in this case as there's
6:16
only one game manager in our scene.
So let just use find first.
6:20
Just like GetComponent above,
we need to provide a type
6:25
within some angle brackets
so that it knows what to look for.
6:28
So here we'll write in GameManager again.
6:31
So now,
6:37
down in our OnCollisionEnter,
we can replace our log
6:37
with a call to
gameManager.ReloadScene.
6:40
But, uh-oh, we're getting an error here.
6:48
Let's see what it says.
6:50
GameManager.ReloadScene is inaccessible
due to its protection level.
6:52
Ahh... so here is our first occurrence
where we need to actually make
6:57
something public, not private,
7:01
because we're trying to access it from
outside of the script it's written in.
7:03
So let's go back to our GameManager
script,
7:07
and let's change
this method from private to public,
7:10
and save.
7:14
Now our error is gone in
the Player script!
7:17
Also, if I delete this method call
and start typing it again, you'll see
7:20
since it's public, it actually shows up
in our IntelliSense options.
7:24
Awesome!
7:28
Let's save and test this out.
7:29
I'm going to change my game window
7:31
to play maximized,
but you don't need to follow me here.
7:35
There we go.
7:46
Anytime we come into contact with a pipe,
the game is reloaded.
7:47
Let's take a moment to reflect on
everything we've done so far.
7:51
We've created game objects
7:55
and manipulated them during runtime
with our own custom code.
7:56
We've detected collisions
and reacted to them.
8:00
We even created a loop
where the player restarts when they lose.
8:03
If you think about it, technically,
you've created a game.
8:07
Congratulations, game dev.
8:11
You should be pretty proud of yourself.
8:13
Now, it doesn't look the best,
and there's a few other small things
8:15
we can add to really make this
a more enjoyable experience to the player.
8:18
So in the next stage,
we're gonna polish our game.
8:22
I'll see you there.
8:25
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up