Godot Tutorial -- Changing Scenes and Managing Global Data Video Lecture | Godot Game: Learn and Master - Game Development

hi this is Mike again from scratch and
welcome back to our ongoing Godot
tutorial series today we're going to be
taking a look at two things scene
management and global variables the
first one scene management we're
specifically going to talk about how you
transition from scenes to scenes and
Godot you could basically think of a
scene as a basic building block of a
game it could be it's kind of badly
named in a way because a scene is
actually more like a game unit it could
be a title screen the game itself or it
could even be an obstruction it could be
the player himself and all the code that
goes with controlling the player it
could be an NPC etc so all these things
are basically organized in the scenes
and then brought together today we're
going to look at how you actually
transition between the scenes so very
simple concept we're gonna do something
along the lines of a short title screen
and then switch over to a game scene in
order to do this rush you're going to be
looking at something called auto load
auto load is a way of pre loading a
script that's globally available a
single instance of it is globally
available in Godot parlance it's called
a singleton a singleton is a data
structure that guarantees that only one
copy is ever running and that's
essentially what the auto load function
provides so we're gonna take a look at
all of that let me go ahead and just
start off a new project ah oops got to
create it a sec like so and open and
create okay so in order to get this
started we're actually going to need a
couple of scene we're going to need two
scenes here this will show you how to
switch between them obviously you
already know how to create scenes but
what we want is a title screen followed
by some kind of a game it's going to be
very simple in this way it's just going
to actually display some text in our
example but it will show you how data
can be passed between them specifically
by storing it in your singleton or by
making it a global so first we need to
create a scene well we've got one up and
running what we want to do is just a
simple tech title screen I guess we need
to have title
all right that would make the font kind
of big we shall call this oops file new
800 600 so we want okay my awesome game
there we go
very fancy that was very dumb all right
let's undo that we'll just say that
there there is our basic thing let's go
ahead and make this brush loop give it
some boundaries so you can actually see
what we've got here
we just want a simple image to use as a
title screen my mousing skills are not
great today all right there we go
I'll go ahead and save that I'll just
toss it on my desktop for now there we
go all right so now we've got a title
screen let's go back into Godot and we
shall add a node and what we want to add
is something called a texture frame this
is just for holding a texture pretty
much we want to make it same size as our
screen which is 800 by 600 by default
straight out like that and 800 and 669
hundred six hundred there all right now
we just got to apply texture to this guy
just right up here there's a new image
texture
somebody's clear that oh I'll import it
file import 2d texture that's from our
desktop
you
and given the location there alright so
we now have it imported let's just go
ahead and load it there so there's our
title screen that's basically all we're
going to do we're going to come back to
this guy in a minute but that's it so
now what we want to do is just go ahead
and save the scene out I'm just gonna go
ahead and call it save scene as and
we'll call it title underscore scene SCN
okay so there we go we got our very
basic first scene all loaded now we just
need to have another one so basically
where the game itself is going to happen
very simple concepts so now that you
come here now you've created your scenes
go ahead and create another one wait I'm
in here let me make sure that I've
actually saved this scene pretty sure I
did
okay scene is definitely saved now go
ahead and create the new one say yes to
the scary message and in this case we're
just going to do a very simple display
we're going to have a panel I so inside
the panel we are going to have a pair of
labels
you
like so and
route here another one so we're just
going to use these to display data
that's it so you can see them both
there's one there's the other and that's
basically it for our second scene here
so let's just go ahead and save that guy
out and this one we are going to go
ahead and call game so we focus here
game SCN okay so there we go we have two
very very very simple scenes we're going
to now have to transition between them
so the first thing we got to do is go
back to our previous scene let me just
show you something with a good dough
here you're going to switch between
scenes a lot and this can get kind of
annoying you could do a quick open you
can do a normal open or you can open the
previous since it was the previous one
we worked on let's go ahead and do that
so boom our previous scene is opened
sometime in the future I hope they add
some kind of a project mode so you can
have multiple scenes all being added at
the same time because there's actually a
lot of overlap between scenes and this
can get somewhat annoying or confusing
so anyways now that we've got our we've
got our title screen what we need to do
now is add some code that allows us to
switch between scenes and this makes us
now we need to add a script unattached
we don't want the script to be part of
the scene we want the script to load
automatically when our game starts so we
got to create a script from scratch and
this isn't something we've done yet let
the matter go over here to the resources
and click new and what you want is a GD
script like that it's just an unattached
script like so R we've got it and we're
going to go ahead and save it so click
the little disk icon up here and we will
call this low bolt it's not a res what
are you doing here
now that's where
we'll call this global GD okay so
basically we're just making a script
named global the extension is very
important though so make sure you get
that correct and click Save
so now it is part of the resources of
our project you can go down to your
fastest and you'll see all the various
so there's the one scene we're working
on and the other scene were working on
so they're all there
but these resources are specific to the
scene itself so we now have this global
attached now let's go ahead and autoload
it that's just a matter of go up to your
scene
projects I'm going to come in here
anyways because we got to set our start
up scene so we will set our start off
scene to our title screen and next need
to go look at this tab at the top here
called Auto load that is what causes a
scene to be attached automatically when
your game starts here your scene is very
um your script is attached as a note
your scene has to inherit from node to
be auto loaded so that's very important
we're going to use the extends node in
our script in a few seconds to make sure
that it's added this will then add it to
the root of your tree the tree being a
very important thing basically the
hierarchy that your game consists of
this will auto load the script which
again has to be a node and attach it to
the root of your games tree and how it
attaches it the name is set here I shall
call this one Global's and over here you
said the script to add that's it
so you the name of the note the name
that the node will be added as is set
over here under node name and then path
is the scripts path itself and I just
click Add and you'll see it's added here
important to note this name value here
is case-sensitive
so make sure that you match the case
later on okay so now that script this
script itself is going to be auto loaded
each time we start our game so now let's
go ahead and create our script some of
this will make sense later on but first
thing I said is we had to extend from
node so let's do that are so now our
script inherits from node and grab a
value called current scene and set it to
no all right give me one sec my mic
seems to be snapping
sorry about that hopefully that's better
so anyways the current scene is going to
be a reference to whatever scene is
currently active as you can see my null
by default no scenes are active but when
the game loads up that shall change
alright so now let's also go ahead and
make global the available value so we're
gonna have a lot of times in games
you're gonna have to pass around data
the whole whole game now the players
name their status their hit points their
facing enemies in the world are
basically all kinds of stuff that is
data structures that are global in scope
to your game this is how you can do that
this is one way of doing that we're also
going to see another one which is
actually to set a global because this
value this this value player dot name
will be in this Global's dot node and
only there so if you want to scope a
variable to a specific area do it this
way otherwise do it as a global we'll
see both of these so what we're doing
here is we're scoping a variable into
this Global's node named player name
we're gonna do an assessor function to
get it you don't necessarily have to do
that but it's like it's how I like to
throw so let's go ahead do that right
away and that's just a matter of func
get player name variables and simply
just return player name if you're from a
Java background this is old hat to you
alright so next up we want to go ahead
and set the ready function so this is
the code that will be called when the
script is done loading and we want to
set the current scene its value two and
then we're going to get our tree get the
root of the tree get child at the
position of and then we're going to do
the same thing get tree and then get
root
and we're going to get the total number
of count so basically what we want is to
set the currency into the last scene of
the route this will make sense when we
when we transition scenes later on now
you will recall when we set up in
project settings there will be this one
loaded by default so when we first run
our code that is the value that's going
to be set to currency in case you're
wondering next up I'm going to do a
simple global just so you can see how
they work we're going to set a value now
and then we can access it later on and
it's very very simple and Godot you just
go global set and it's basically a key
value pair so you set and you give it a
name so say max underscore power
underscore level like so add a value
like so okay so that's it that's the
code is going to be called when our code
runs and all we're really doing is
taking a reference to the current scene
and setting a global value named max
power level now we need to create a
function that we're going to call we're
going to want to call from our title
screen when someone clicks on the title
screen they're going to change the seam
and this is the function that enables us
to change the scene this function is
available everywhere under the Global's
dot node anybody will be able to access
it I'll show you how to do that in a
second but let's go ahead and create a
sauce func set scene like so oh I got a
get parameter sorry you pass in pass in
the path the scene and I'll be do is
let's first off we nuke the current
scene so Q underscore free that will
clean up the scene from existence and
then it's kind of like delete if you're
in and C++ parlance now that we've
gotten rid of it let's create a new one
resource loader so we use our loader and
load a new scene in basically again
scene is passed in as a file path so all
we're doing here is basically saying
scene equals load scene this real oral
slaughter
actually was superfluous you do not need
it you could just done load and seen
that that line of code is functionally
equivalent let's put that back I like to
read this one a little bit better and
now that it's loaded let's create one
that is done via current scene equals s
dot instance we're going to instantiate
a version of it basically this is a C++
equivalent of newing so once we have our
scene loaded let's create one of the
scenes and that's what the dot instance
call does finally we add it so we gotta
get our tree and get the root and then
add underscore child and we will add in
our current c so all right
so this function all it really does is
your pass in a path to the files name of
the scene so game dot scene or title
underscore scene dot scene okay that's a
little gratuitous but anyways you pass
in that path we get rid of the current
scene we then load the scene that we
pass in the path to we create an
instance of it and then we add it as the
current scene there and we add the
currency into the root of our tree
basically making it active so that's how
you switch between scenes and like I
said this this global Gd code will be
added as a node automatically when your
game loads up and so this will be
available to anywhere in your code so
with that in mind let's go back to our
title screen and make a call to it it's
like I said when we do a left click
we're going to change the scenes so
let's look at how we do that first we
need to attach
script to hear go ahead and create that
one's just fine get rid of the junk
so and all we are going to do there are
no input events available for the
texture frame class if you want you
could use a different one that actually
has like an on-click or whatever and
instead we're going to do is a set
process equals true and we're going to
pull for input so in already we say yes
we handle process and then of course
we've got to implement process so
process it gets passed in Delta like so
and all we're going to do is check to
see if the mouse button is pressed if it
is then we're going to call set scene so
first is input dot is mouse button
pressed and then we want button under
square left so is the left mouse button
pressed and if it is then now we have to
call our set scene classes so as I told
you the Global's name the global budget
II file is going to be attached as a
node called Global's off of the root and
now we got to go ahead and get a
reference to that you could cache this
if you want your code to be a little bit
cleaner or if you're going to call it a
lot but it's a matter of doing get
underscore node and then your path in a
path the node path to where the node is
located
now this forward slash the starting
slash is required and again this is case
sensitive so we want the root and it's
named Global's like so now once again
that Dame right there is being set right
here so the value you passed in here is
the name that the node gets attached at
so that's why that's important and it is
case sensitive so this will now give us
a reference to our global this guy
let me sure that guy saved now slip on
back so now that we've got a reference
we have access to our set seen function
and give it the path the path is off of
our resource root and we call game dot C
okay so once again in the ready we say
yes we have processing and then on our
process call which is called the tre
we check to see if the left mouse button
is pressed and if it is get a reference
to our Global's call the method on it
and path in paths in the new path for
the new scene to load so essentially we
are now loading this scene and anybody
anywhere in any code can make use of
this guy
it is very global this is how you access
it okay so now that we've got and once
again you could have held this so
basically you could have gone you know
makes more sense up here like so and
then my Global's dot if that's cleaner
to you very much an option this does get
a little ugly over time so that is an
option available to you but that's this
so that is a way of loading code upfront
and this is how you actually access it
when you need it
so now let's go over to so I think I can
save this guy I think that's all we need
to do let's head on over to our other
scene so let me illustrate that you
can't use previous because we previous
so previous isn't circular so it only
goes back to the last one it doesn't go
I don't know how to describe that so if
I open a opens B and then B goes back to
a going back from a does not go back to
B it is not a circular process so
unfortunately there have to use open and
we can just go ahead and open our game
dot scene or you can do a quick open
which I don't really understand why
that's that much quicker but do the same
thing so we're back in our other guide
now remember this guy has a pair of
labels attached label 1 and label 2 I
mean just give her that space like so
okay and now we want to attach a script
oops I don't want to touch it to the
label I want to attach it to the panel
alright so in this guy we are going to
now set our values based off of those
labels based off of those values we've
stored in our global script now even
though he wouldn't be different scenes
as you saw earlier we were in the one
scene and well we were had that one
scene opened we created the
global g-d if you look here in the
resources it's not there that can be a
bit annoying but don't worry if you come
down here to file system you can quite
simply open it up and you can edit it
like a global available script like this
it doesn't reside in the script it looks
like it does but what the minute you've
opened it up here then you'll see it's
popped up into your resources there so
the global script can be edited and
accessed from whatever scene you've got
open you can only have one scene open at
a time but they can share scripts no
problem at all so just something to be
aware of there so now we've got our new
script here and if you really want you
can actually open up the other one
completely out so that was game title
scene so you can actually edit them
between them doesn't really matter but
you can only have one open and open
essentially is to give you access to it
here in the 2dn and the inspector view
so if you want to make editing to those
things to the the composition of it
you're going to have to open different
scenes but for the most part you don't
need to really switch between scenes as
much if you know exactly where you need
to edit okay so let's go back to our
script and game's script so let's get
rid of the junk all we are going to do
here is in the function call for ready
we're going to get first I'm going to
show you how to access that get player
name function this is pretty predictable
actually because it is exact same way
you call the other function what am i
doing all right var name equals get note
and then once again off the root and
it's called Global's like so and then
get player name like so so we'll get the
name from there and now let's display it
in label one leave oh sorry label and
set underscore text to stir
you
so and now let me show you how to access
that global variable we used earlier
that is a matter of git
and you get it by the key/value you
entered earlier on and let's go ahead
and set
you
like so okay and let's see if I've done
everything right so let's head on back
to our preview a scene sure everything
saved and run and boom identify or not
found global my bad I do this to both of
them
globals no I did it in the one sorry I
mistake there I set it to Global's
it sort of should have been Global's I
did Global - typo now you're on it so
there you go
as our scheme started up and then at
this point in time in the background
that scene switch the set scene function
was created the player name value was
set and we set the global named PAC max
power level so now we do a left click
and boom we just switch to our game
scene and this quite literally is how
you would transition between scenes in
your game you do you know obviously some
transition effects fades blurs etc but
this is the way that you break a game up
into logical pieces to break it down so
it's manageable quite a bit covered in a
very short period of time there I hope
that all made sense again there's a
text-based version of this if you need
to actually literally cut and paste the
code this is code used by almost
everybody it's a directly based off an
example they provide this is how scenes
are supposed to be switched between so
hopefully this helped you mentally think
about how to break a game down into
discrete manageable pieces very
important process but really quite
simple
on top that you do have the Global's and
globally available value so the auto
loaded scripts are things that will load
at startup and they are available from
everywhere they are attached as a node
by the name you provide and anything can
go ahead and get them now the nice thing
about doing this though it's sort of
like using a namespace in another
language in order to access that
variable value so you went ahead did
something stupid you made a globally
available value called I which you
should never do but we all do it and
then somewhere else you did the same
thing you can get a name collision out
of that by scoping values in like this
you can have multiple and they will
resolve correctly so that's the nice
thing about making your variables this
way now you don't want to make things
overly global the more global variables
you have the more places your code can
break across the line now some things
just by nature are global but because
something is easy to make it global
doesn't mean that you should only make
things global that are actually
global Global's are easily abused and
incredibly easily abused and you can
really quickly create spaghetti code but
what I mean by that is if I go ahead and
I change this value it's also another
reason why you use an Assessor value as
opposed to directly accessing a variable
it makes you a little bit immune to
changes down the road you can you can
change the interface or you can change
the implementation but the interface
change stays the same to your code but
what you'll notice here is we've
actually made a call direct call right
it's wrong same right here to that
Global's call and then right that I were
to go here that so if we went ahead and
rename this guy or changed it or
whatever we just broke two different
scripts and that's why you don't want to
have these too many dependencies you
want to try and keep it as clean as
possible so if it makes sense to keep
your variables local keep them local if
it makes sense to use a pubsub model so
in other words things subscribe to
events and receive events as your way of
communicating it's generally a better
approach than using Global's excessive
excessively so again the other option
was your Global's get and Global's that
set and this is really just a gigantic
globally available name value pair data
structure it provides the same basic
functionality as making global like this
sort of like this it's basically the
same functionality but like I said
there's no it's Messier because there's
there's no scoping and literally things
are quite global and it's probably even
more prone to breakage the a or magic
number syndrome you can do a lot of very
bad things by abusing this stuff at the
other time don't overly fret about this
stuff because some things are global and
they make sense to be global the players
name the player comes in they sign in
you're going to want that all over the
place it doesn't make sense to pass it
around or change it around when
literally it's a single piece of data
that is unchanging across the entire
scope your game make the damn thing a
global it makes sense so really that's
about it you switch between scenes you
brakes your game up into individual
scenes you can store values using
Global's I'll also look at some
somewhere down the road I look at other
ways of communicating between game
objects that wizard are a little bit
cleaner probably a couple things a
little bit more making a lot easier to
change your code or maintain your code
as you go but this is two ways of having
globally available data and this is also
again this little function right here
it's very critical this is an easy way
of transitioning between scenes so you
can break your game up into different
chunks I hope that was useful thank you
for listening and see you later bye