Godot Tutorial -- Game Lifecycle and Dealing with Input Video Lecture | Godot Game: Learn and Master - Game Development

hi this is Mike again from scratch
welcome back to our ongoing Godot game
engine tutorial series today were going
to be taking a look at two separate but
very important processes the first one
is basically your programs lifecycle
often you would know this as the game
loop or well life cycle again we're
going to look at how your program
updates when you've got your game
objects in Godot you might be said
they're going alright now to do
something like you see in front of your
I got the sprite on screen how do I make
it live and that's exactly what we are
going to look at in two ways first off
is how to update things on a per frame
basis to actually so your code can be in
there controlling how your notes operate
the second thing is going to be handling
and responding to input those two go
together to add life or logic to your
game itself so like I said this is a
very important subject we're going to
jump right on in in a second let me just
say this entire series assumes that
you've seen or are aware of all the
content up to this point so if I cover
something very briefly that it doesn't
really make a lot of sense there's
probably a good chance it was from a
previous tutorial
if that happens make sure you check
previous one and even then if you find
that I didn't cover completely I may
have skipped over something without
being aware of it
let me know in the comments and I'll
make sure I cover it going forward on
top of that we're also going to be
covering later on we're gonna jump a
little bit into the C++ code behind the
Godot game engine specifically I want to
jump into the main loop and let you have
a real good understanding of what Godot
is doing with your game it's really
critical to understand how your game is
performing even if it's you know a lot
of this logics being buried away in the
game engine it's good for you to know
how the program flows and how it
executes so understanding the life cycle
of the program even running within the
game engine is critical so we're going
to jump into the C code a bit I'm going
to show you how the main loop is
actually structured within C++ you can
completely skip over that you do not
need to know this stuff to be successful
with Godot but if you really want to
understand it stay tuned at the end of
this video we're gonna jump again a
little bit into the C++ code what you
see in front of you I've already just
created an empty Godot project this all
stuff we've done I've added a single
node our our sprite right here added a
graphic to it and that's
I've attached a script but the script is
empty so now and you're going to find
this quite commonly you've come into a
good deal you've created your stuff on
screen now you want to add some logic to
it how do you do this and it's not
completely intuitive so if you're
struggling a bit with how to figure this
out don't worry it is not obvious
fortunately it's quite easy now let's
just jump right into our script like
yeah why didn't you open all right empty
script nothing to it if you want to be
called each frame oh I'm gonna pause for
second explain something in case you're
if you're completely new to game
development there's something you need
to understand if you've already done a
game you probably know all this and I'm
sorry I going to waste about a minute of
your life but behind all successful
games all successful game engines there
is fundamentally a game loop it's
universal it's just something that is
there all the time and a game loop is a
pretty simple concept it's more or less
your program starts up does its
initialization and then it runs and that
process of running is what we call the
game loop how its structured is not
always necessarily a loop it almost
always is but it is just this process I
go through over and over and over again
quite commonly they do things like check
for input update the physics engine
update all the items in the world render
the results up to screen remove the
garbage and do it all again and that's
loops over and over and over again and
that is called a game loop that is the
heart of any game application now when
you're using a game engine that logic is
hidden away from you that's what we're
looking at the source code later on but
that logic is part of the game engine
and your program itself responds to
different points of time within that
loop so each loop through it will call
into your program and your program needs
to know when to update however sometimes
you actually have to tell Google that
you want updating which is exactly what
we're going to start with when you have
some logic you want to perform in your
and you want one of your nodes you have
to register to say hey I've got some
processing to do and it is done and
you're ready call by going on the set
process spelt right process
it's true so what you're saying is I
have processing to do in every frame
every time that Godot runs through its
own game loop it will now call your note
and say oh here go ahead and what it is
going to call is the virtual function we
are now going to override called process
process has passed a single floating
point value which is the amount of
elapsed time since the last time it was
called all right so now we're going to
do so let's actually update our sprite
I lost Mel's focus here we go update our
sprite every frame so each time this guy
is called in we're going to go ahead and
get current position equals self that
get position or position dot X plus
equals a hundred times Delta the logic
here is what we're saying Delta is going
to be a very small number I it's
generally in a fraction of second so
zero point one two or whatever well you
can take that value and multiply it by
unit and get a per second amount so what
we're saying is we want to move by a
hundred units and if I did this as it is
it would happen almost instantly because
it would call move by a hundred units
every single pass through the loop and
you've probably heard of game loops or
games running at a fixed frame rate
thirty frames per second 60 frames per
second well when the game loop is also
running at 60 Hertz it means it's going
to call itself 60 times it could
potentially on a really fast computer be
calling itself 250 260 times so if I
call this logic here 200 times at 100
pixels per call it's going to just do
instantly off-screen so what we do is we
multiply it by the amount or the
fraction of a second that has occurred
since the last call and that will smooth
it out and this will in turn make this
so that the X is updating itself by a
total of 100 units per second as opposed
to 100 units per call a very common
thing to do
very handy the only time this really
falls on its face is logic is if for
some reason your update is taking longer
than a full second but if your update is
taking longer than a full second you got
way bigger problems on your hands so a
neat little trick for smoothing out
coordinates across calls across
so they run the same speed on different
machines so now we just want to take it
so that if our guy moves off the screen
we're going to move him to the other
side now keep in mind and we covered
this in the last tutorial
the default pivot location for your
sprite is in its center so we're going
to have to take into account half of the
width on the way out and half of the
width on the way in so that it looks
like rolling fully off the screen and
then fully back onto the screen so let's
just go ahead and set that if current
position dot X is greater than self dot
git so we'll get the viewport size size
dot width plus self dot and then half of
our width get item rect oops
call size dot with if two so if we're
off the right hand side of the screen
and curve position x equals minus half
of our width so that'll put us off just
off the left hand side of the screen one
after scrolling soft up self dot yet
item right size thought with two I can't
type today sorry about that all right so
we'll go ahead and set the position to
the newly updated position like so all
right so let's make sure that this runs
there you go so it's going to run get to
the screen and come back in the other
side and this will happen again it again
again again it's a very simple example
but this shows how you can add some
logic to your nodes that it's going to
be called every frame every pass through
the game loop your node can now update
itself and again to do this all you do
is say set process equals true and then
implement process and you put whatever
logic in here you want if it was a world
simulation and you were aging the
character you put that logic there you
could put whatever game logic you want
it doesn't have to be stuff to update
the screen like we're doing here now
this just shows well in a demo so that
is how processing works now let's um
yeah SEC I got a pause for ah much
better
sorry about that all right now let's
take a look at
there's two ways of looking at input in
goodell thirds you can either pull it or
event-driven polling it basically works
on the process of you just asking over
and over again has anything happened has
anything happened has anything happened
has anything happened has anything
happened and if it does you respond to
it otherwise you can have event-driven
where basically it goes this happened
what do you do this happened what do you
do this happened what are you going to
do both have their merits well structure
well into code and both can be handled
by Goodell so let's look at each one in
turn first let's start with input
polling it's probably the simplest and I
can put it into our process logic as it
is so let's just get rid of everything
we just did and we still want process to
be called because we're going to be
pulling for input now and we're going to
handle it somewhere process makes
perfect amount of sense so all going to
do is go input this global object
available to us with the input States in
it and there are a bunch of is functions
is key press is mouse button press is
joy button pressed and action pressed
will touch on action later joy in Mouse
I'm assuming you can pretty much figure
out both them but we will actually be
taking a look at using key and mouse
eventually joy I don't have one plugged
in so I can't show you but the process
is almost identical so you can easily
figure that out I'll probably do a
joystick specific tutorial somewhere
down the road when I plug one in so
let's check if the key is pressed there
are a number of globally defined values
for us they are all named key underscore
something and we're going to check for
key escape being pressed if it is let's
also check if another key is down if
input is key pressed we'll make sure the
shift keys down because we're going to
exit the program when this is done so we
don't want to make sure that they
actually meant to do it okay and if is
then let's just self dot get three ones
dot quick
no dot all right right what are you dot
it okay so I'm going to come back and
explain this a little bit more in depth
in a second but more or less what logic
is going to say is every time we every
update face so every pass through the
loop it's going to say is the escape key
pressed if it is we're gonna say okay is
this a shift key also present if it is
then we're going to go ahead and quit
our application so let me just go ahead
and run that and hit shift escape and
boom shutdown so that is how simple
polling keyboard input is in good dough
I'm going to stop and explain this guy
for a second this call might be a little
confusing as the inheritance goes we
covered a bit of this last tutorial but
your scene is automatically a member or
so your ah your nodes are automatically
a member of the parent if there's
nothing above it the parent is
automatically the viewport well the
viewport itself is actually owned by
another guy which is called the scene
tree the scene tree is the data type
that holds the scene that you're running
and the viewport and all of your nodes
and everything else so the very top
level object here the the you know the
guts or the heart of your game is this
scene tree scene tree itself implements
a class called main loop so your own
program itself always has the very top a
seen tree and the seen tree is capable
of doing a lot of neat stuff the key of
which is being able to exit will stop in
here let me just pull up the docs first
okay here we go
so the very top of your when you create
a scene when you create something in
Godot there is this scene tree made and
here you can see it actually inherits
from main loop and this is your
implementation of a main loop now if you
don't provide one there's actually a
default C++ one provided for you I will
look at this again at the very very end
but the main loop there's sort of two
main loops if you want to think about
there's one that's the Godot engine
itself loops over and over and over
again calling all of these things but
there's also one unlike the scripts side
or your game side
that is implemented and ultimately
inherits from this class main loop and
scene tree is derived from a liberal
scene tree itself you'll notice there's
a couple of very key functions in here
and mostly our get route gets the top of
your the viewport at the very top of
your scene tree hierarchy and then the
quit that we just used earlier but you
can also get the total count of nodes
with the very this is the container that
holds all of the data that makes up your
game world and it in hence implements
main loop may loop is a very simple
defined class pretty much yeah you see
there's one member function and that's
handle input we will we'll jump back on
that later on I just want to note like
the heart of your application what would
actually probably often be known as
application in other game engines here
is your scene tree and you can get that
at any time by calling dot get
underscore tree and that gets the top
level control app control object of your
game I hope that made sense it might be
a little bit confusing it will make
sense in time but essentially what we've
done here is we've said our give me that
and quit the program so there's how you
go ahead there's how you process a
keyboard input as you pull for keyboard
events now let's take a look at dealing
with Mouse events very similar in
polling we just do if input thought is
mouse button pressed and a button left
like so so if the user press the left
mouse button let's just lock it out if
they do so come here and we'll just
print out the console string mouse
button pressed at and so this was the
the event being passed in oh no sorry
I'm getting added myself
overall point instead we're going to
poll using the global object so input
and then you'll notice here get and
depends on the kind of input you're
dealing with but there's a lot
out of different options here so get
joystick access name get the
accelerometer etc but we want to do is
go ahead and get the current Mouse's
position just do get Mouse position like
so that should be it go ahead and run
that and don't make an error those
strengths oh yeah that's the bracket now
go ahead and run that and now when I
click you'll see down here that it's
updated here now you'll notice that
there's a lot of them as events fire
really really fast so you could probably
have sixty plus event updates per second
so you're gonna probably want to do that
without in your code a lot of times
you'll only want to deal with it like
set a flag if it's pressed so you only
get it the first one and you're you want
to deal with most up as opposed down etc
but this polls if the button is pressed
if it is spit out the location you can
see it's that simple to do now sometimes
however you actually want to deal with
event so instead of checking to see if
something's done you actually want to
respond to it so you want good door to
say to you a buddy
something happened deal with this and it
works just like you did with process
except it's self dot set again itself
completely optional something I do
process input it's true like so let's
just comment that guy yo cuz I don't
that code actually run anymore and so
this is going to get called all
everytime others input you will call it
and pass it into your node and you have
to override the virtual function input
and it is passed an input event and we
shall call that event input event is an
object that has details about the event
that occurred we'll see a little bit
more of that in a second so now let's do
the same logic we're going to check to
see if the mouse button is pressed and
so if you vent dot types let's figure
out what kind of it is these are defined
in the input event class that mouse
button so if it's a mouse button event
now let's just go ahead
we'll use the index of the mouse instead
of the mouse button that we did earlier
so we're go event dot button underscore
index and let's go Oh button thank well
I'm I not getting code up that was just
slow button right so if they press the
right mouse button I will go ahead and
position our object at that location so
the coordinates are being passed into
the event objects being passed into our
input like so all right why are you
being so slow event dot come on show me
all right never mind
unfortunately there's a there's a lot of
members in that event method depending
on what type of event is occurring so
keyboard will have keyboard state events
etc so in the case of the mouse the two
of the values of a lebar the x and
y-coordinates that are currently pressed
unless I made an error which is why I'm
not getting I don't think so all right
so now I press the right hand mouse
button yeah there is an error stuff you
know I guess I should actually read what
the error is valid call to set position
in sprite expected one argument mmm oh
my dad all right
and that would be why I wasn't good
events so let me show you in a minute
come on
you're being annoying go ahead and run
right click automatically positions
where we want okay so that's dealing
with the most event let's take a look
now so that's keyboard event-driven and
that was just mostly not driven sorry
now let's take a look at the same thing
for keyboard same basic logic so this is
going to be if a keyboard event occurs
so event dot type equals input event dot
key and if event that scan code so you
said the event is being I wish it gave
me completion here because I could
actually show you quite a deal here
there was a bunch of different different
members available based off the
different types of the event so like I
said in the case of mouse there's an x
and y-coordinates of the current mouse
cursor in case of a keyboard event there
is a scan code value which is like the
key itself that was pressed and that
would be event scan code and then we'll
check to see if it is set to key that
right so if they press the right key so
here we're doing it it's not frame
smooth at all there's no Delta to
multiply it by we're literally just
updating the position and let's set that
position like so and same logic for they
hit the left arrow
let's have that back and minus
all right so they press the right left
or right arrow so if it's a key press
get the location if it's right increment
by ten if it's left decrement by ten and
run so now when I hit the arrow keys we
update hold down the arrow key we update
a lot there you go
so that's responding to keyboard driven
event event-driven now what you
sometimes have is that you don't want
that event to propagate any further you
want to be the one that handle it and
done so you don't want other controls or
other notes to have a shot at dealing
with it or you don't want another class
to touch it in that case you can
actually do this in that tree the scene
tree becomes very important in dealing
with this so let's say on the event of
the key right or key left you don't want
to respond to keyboard events any
further oh sorry you don't want this
particular event to be propagated any
further up the chain now quick overview
when an event happens in Godot there's a
bit of an order of how it goes is it's
given to all of the UI controls we'll
touch on those later but those are
things like buttons etc the gooey stuff
gets first crack at control so your node
overriding this behavior won't affect
that then it's passed to the nodes as
the hierarchy down the tree so anything
that came before us in the the tree
hierarchy is already had a shot at
dealing with this event so when we say
okay we've dealt with it that means no
nodes after us will be able to access
event however if one of the ones before
us so let's say if this sprite was
parented to another sprite if that's
bright eight the keyboard event this one
this call would have never even happened
so that's the order that these these
things are propagated and when you want
to stop that propagation you just do a
self dot git tree so we're getting that
scene tree a very critical little class
I call set input as handle you're saying
I dealt with this current input leave me
alone and now nobody else is gonna get a
shot at it so if you press left or right
no other classes are going to get this
let me just go ahead and run it make
sure many errors right now
left and right so that does leave the
question of what happens to unhandled
input or what doesn't make it through
now let's take a look at that there is
it's very similar to this one you can
actually say to a node often it would be
maybe a logging class or a top-level
class that handles all input processing
you can go ahead and say all unhandled
input goes here and once again it's a
two-part process first part is up here
self and you say cell set process
unhandled underscore oh no sorry uh yeah
no I'm right
unn and they'll underscore input and you
pass the value of true and then finally
you need to have let me put it up here
nice method for dealing with this func
auto score on handled input
I believe it passes in the event like so
and let's just log out what it is like
so let's go ahead and run that and you
are going to get a lot of messages when
this is running see if you look down
here shows the mouse motion events not
being handled I'll start doing some
clicks left click isn't being handled
double click scroll etc so all of that
and here let me just hit some keys now
I'm going to go ahead and hit the right
arrow you notice it didn't show up
that's because it was handled input and
we we made that call set input as
handled so it doesn't propagate beyond
so if you want to do like a catch-all
handle or a catch-all input handle you
can do this unhandled input event that
only works that it will only get the
input that happens after it in the
hierarchy of processing so that means UI
controls will have already had a crack
at it and nodes higher up in the scene
will have already had a crack at it but
prevents all the people further down or
your own children from seeing this input
so that's the basics of dealing with
both
pulled or event-driven input which one
you go with often is determined by your
game itself now the catch is this input
call right here it's going to actually
generate a lot and you saw in the
debugging it generates a lot of calls to
your node itself so you'll probably find
that polling if it fits is the more
performant option of the two finally you
can actually look at something called um
an input map and this is kind of nice
because what you have a lot of times is
I want the right arrow or the watt voise
key WASD keys or the joystick left d-pad
or up and down on the mouse I want all
of these things to map to the same thing
and you find that all the timing a lot
of times your your input process can end
up being a bunch of if and if and if and
if and logic for the same thing and this
becomes particularly a nightmare if you
want to start letting the user define
their own control mappings so an input
map is very handy an input map is
basically saying these inputs call them
this and handle them as an alias and
it's nicely built into the Godot engine
if you want to use an input map just
going to scene and project settings and
you'll see there's a tab up here called
input map you'll see right away there's
a bunch of them defined for UI
processing and let's look at this UI
underscore as set the event is sent if
they hit the return key the enter key
the space key or the button 0 or a on an
x-box control pad of the very first
controller plugged in very handy so all
of those things are now being mapped to
this UI underscore a step command let's
go ahead and create our own we'll call
it move underscore right you just you
name it and you add it boom or so data
to the bottom and click over here to
this plus and then you can define what
does a move right constitute and let's
obviously do the right arrow and add
another one key and we'll make it the D
key
and I don't have a joystick plugged in
so I can't do those to show you but I'll
go ahead with a mouse button and those
wheel down of the very first device that
alright so all of these are now masked
although this input is now masked to the
command move underscore right so we're
done click Save it's saved and closed
now the process of dealing with an input
map is pretty trivial let's go back to
you're going to pretty much everything
except for process oops
die all right there we go and we don't
need input
we don't need unhandled we're just going
to pull on this one so you're garbage
and let's uncomment you alright so in
the process calls to the call of our
each frame we're just going to go ahead
and we're going to check to see if that
action happened and that's a matter of
input dot is action pressed remember I
told you we'd come back to that and then
you just pass in your name like so and
do the same thing we've been doing its
POS for POS plus equals other times
Delta so set POS POS like so all right
so I'll go ahead and run that and now if
I hit the right arrow again there I made
a mistake I did it again alright I have
stuff doing that vector to o the area
try that again so I press right and we
move I press D and we move or I use the
scroll wheel and okay nothing's actually
happening that one might be a bit of a
bug but as you see the right key and D
key are now both mapped
that same control and that is handled
using input Maps which Maps a name to
the event now you're going to find input
maps need to be sort of on off type
values they're literally things that are
is pressed like so you use an input map
for move right or but there's no because
all these things are being masked
together
you'd either do to do more logic so
let's say if you're pressing right now
using move right and I'd map the
controller in I can't tell you how far
right it's pressed you can do this with
logic though again you just come back to
go if input dot is or I suppose get joy
axis dot all right I'm using this wrong
and I'm not getting Co completion
anyways you could you can do more logic
to test to see what kind of event you're
dealing with or what the current devices
status is but what happens when you're
using an input map is it it more or less
becomes an on or off type value that is
set so you would use it more for button
II type controls you don't get define
you want because what you are doing
effectively is treating keys and mouse
buttons and joystick controllers and all
those things as being the same thing and
that they lose the nuances of their own
individual ability so in that case you
probably use a more traditional approach
if you want to really take advantage of
things but there's a lot of times where
like you I okay click you don't care how
it was done or how long I was held down
or etc you just literally want to know
if it was done and this allows you to
Malta to map multiple input sources to a
single command so input maps are very
very handy thing so that's the basics of
it this is processing and input they're
all handled almost identically you flag
back to though itself tell it that you
want to handle something so either via
set process set process input or set
process unhandled input and once you've
registered those you then override the
corresponding function and implement
your logic however you need it to be
additionally you can pull for your input
using the in
put thought global object polling or
event-driven again it all comes down to
your game which one works most
effectively but the logic is very
similar line finally you can use input
maps to make your input generic so it
doesn't matter what kind of devices that
you worked with it allows you to easily
let the user remap their controls the
input map actually has a number of
functions available so you can add and
remove to it dynamically you don't have
to use the UI that we just used so you
can use an input map to easily allow
reconfigurable controls it's a nice
built-in system for doing that alright
as I said earlier we're now going to
take a quick look into the source code
so you can understand how the main loop
or at least where it is and how it works
now the dough itself is hosted on github
github alright so here we are into the
master repository the key guys we're
looking for is actually core missus Cora
mmm all right main sorry
particularly enough main is the one guy
of importance and inside of main there
is a method called teach to iterate I
believe so I do I just search iteration
this is essentially the heart of the
game loop there's a bunch of other stuff
that just happened for setup there's a
bunch of logic in here because Godot can
run in engine mode so the tools are
actually kind of a game
the Godot is implemented for you so
internally they kind of look the same
but there's a lot of logic in there for
saying are we editing versus playing a
game so you'll see a lot of things done
that way but ultimately after all the
setup happens there's a loop that's
called an every loop every iteration
through the loop this main that
iteration is called you see the logic is
it's pretty consistent to the long I
guess I it was on the text version I
said this but the basics of a game loop
you can see them all here it's funny how
much times happened figure out the Delta
or the elapsed time between then
find out fraction of a second that's
occurred and then let's see it's like
we're updating the physics updating 2d
physics and then here's a critical call
this is very important here what they're
doing is they're saying get me the main
loop of the of the loaded scene more or
less so we'll look at how this is
defined in a second but this is calling
the main loop its iteration and I'll
look at the seat the the basic c+
implementation of the main loop now once
again you can define your own main loop
if you're wanting to create your own
entirely C++ based game based on good ol
that is probably where you start you
will implement your own game loop and go
from there but they do provide a
reference one or you could actually
implement one in Gd script you just have
to implement or sort of inherit from
that main loop class and implement the
methods required the kree one the key
one here being iteration so this call
this iteration call that we're in in
main it's going to be called over and
over and over and over again as it's
called sort of every time the the main
loop runs and it's going to do things
update the physics update the sound
engine but this was the key one it calls
into our scripts iteration call and the
rest it's more the same
it's literally per frame updating stuff
you can jump into it with more detail
later on it's not that important to you
what's important is to know that this
main loop itself after updating the
physics of sound etc is actually calling
it main loop and iterating it now get
main loop I'm gonna have to pause for a
second to locate it okay the default
implementation provided is in the folder
core OS and its main loop dot CPP and
dot H this is the one that all of our
programs use if we don't provide our own
and you're going to see in a second
there's nothing to it there is a method
called for input text an input event and
all that the input events happening is
each time the game loop passes in an
input event to us we simply pass that
into oops I missed down
get the script that's running and call
its input underscore event method so
it's just it is just a game of pass
along and this is how ultimately your
input event script method is being
called ditto this is your iteration
called every frame and all it's doing is
calling iteration on the active script
so that is the logic behind the scenes
and if you're creating your own game
from scratch and you want to use C++ as
opposed to Gd script you will probably
go in here you will implement your own
version of main loop like I said this
one's pretty simple there's not a whole
lot to it but you could kind of roll
your own and go from there way beyond
the scope what we're talking about now
perhaps this one we're down the road
we'll do a C++ specific tutorial but
this is the heart of how the main loop
is processing so it in the main CPP
there is a method called iteration that
is called every time it itself is then
the calling into main loop which here is
your very basic implementation of a main
loop and all it is doing in turn is
calling iteration on your script now
you're seen script and that it term will
call the process function of every node
that is registered to receive so that's
the heart of how processing is happening
behind the scenes with Godot only one
final thing to point out is if you do
decide to roll your own main loop or you
implement your own or whatever you
inherit from that main loop class which
I suppose I should actually show you
that main loop dot H I know it is
root-level class sorry if you do roll
your own if you create your own main
loop derived class you set it in project
settings your general main loop type and
you put your class name there that will
then call the non-standard non default
one for most people just setting out or
probably most people in general ever you
have no need to implement your own main
loop you just let it deal with it how
its dealt with now and you deal with it
in your scene using process etc however
it could be overridden and if you do you
just register your type here and that
will call that main loop instead if
you're working in C++ then that also
covers you'll have to do your extension
your scons file etc something we will
probably talk about extending Godot
using C++ later on down the road but
once your type is actually registered
which is part of what you have to do
when you're making a C++ module you just
give the type name in here and that will
be used for the main instead of the
default one
but most people working in script you
really just have to worry about it at
the underscore process level and this is
what we just covered so I hope that was
useful stay tuned for the next part
thank you very much bye