Learn Godot Game Development: From Basics to 3D Shooter

[Music] Hello. In this course, you're going to learn how to code by making games in

Godot. We will create seven games in total. A runner game, a platformer, a farming

game, a monster battle game, a 3D space shooter, a 3D platformer, and a 3D shooter.

All the games will be made in the popular game engine Godot, which is entirely free and super easy to use.

By the end of this course, you will be able to create games and you should feel comfortable coding. Meaning you can

branch out into other areas like data analysis, AI, or app development. For this course, there are no requirements.

I will assume that you have no coding knowledge at all. Although, if you can code already and

you just want to learn Godot, you can skip the first part and jump straight into game development.

You can get this course on Patreon for £5 a month. On there, you also get all of my other

courses and you see future courses early. And if you don't like subscriptions, you can buy this course

on Udemy for about $10. This is why for the super regular discounts. And if you don't want to buy anything,

this video contains the introduction to coding and three of the games. The runner, the platformer, and the basic 3D

shooter. This will teach you all the basics of coding and Godot. So, I hope you enjoy.

Before we start coding, we need to talk about how video games work to understand what a game engine like Godot does.

Fundamentally, any video game is just an interactive movie. Like in a movie, we are playing

individual images in sequence. And for some reason, these images are called frames. If that happens fast

enough, it looks like a movement. For a movie, that is usually 24 frames per second. For a video game, you want

to have at least 30. Now, the difference between a movie and a video game is that video games

dynamically create each frame depending on player input, enemy movement, timers, and a range of other options. So, what a

video game engine like Godot does is it first calculates where stuff needs to be.

For that, it checks player input, the movement of every object, if an enemy was defeated, and loads of other things,

whatever you specify. And once all of that was calculated, we are drawing one frame.

This we do at least 30 times per second until the game is over. This is how any video game works.

So, Godot basically is giving you tools to capture user input, it lets you draw images and 3D objects, it can play

sounds, and you can use it for lots of other more advanced things like physics calculations, light simulation, and even

online communication. Godot is a really powerful tool and it is entirely free and open source.

To get it, all you have to do is go to godotengine.org and click on download latest.

The website should then give you the right download link. If you want something specific, just

scroll down. Godot works on basically any platform. Just choose what works for you.

Once the download is done, unzip and open the folder and then click on the icon that doesn't say console.

You should be seeing a dialogue like this. And yes, Godot does not need to be

installed. Just keep the downloaded folder somewhere safe so you don't accidentally

delete it. With this dialogue, you can manage all of your Godot projects. At the moment, we don't have any.

To fix that, you can either create a new one or import an existing project. I want to create a new one. Then you get

a create new project dialogue where you can give the project a name. Let's just call it test

project or whatever you want to call it, doesn't really matter.

After that, you get a project path where you can select where you want to store it.

Just choose a good spot. Ideally, create a folder specifically for your Godot projects.

Also, keep in mind, Godot is going to create a folder by default inside of this path.

If you don't want that, just disable this toggle. After that, we have three options for

the renderer. Forward plus, mobile, and compatibility. On the right side, you can see a bit of

information about them. Forward plus is going to give you the most options and the best look.

I'm going to use this one throughout this entire tutorial. However, if you want to make, for

example, mobile games, then you have to account for less powerful hardware and more limitations. Compatibility is

mostly for browser games where you have very limited amounts of hardware power. Now, in our case, we only care about

forward plus. That's the most straightforward one. You can also use version control, but that we don't

really care about. Once you have all of that, click on create.

And here we are. This is what you see when you start up Godot for the first time.

Now, I will be talking about the different elements in just a second. First of all, though,

you can customize this thing quite a bit. For that, you want to go to editor and

then editor settings. In there, you have interface and editor, which allows you to customize a lot of

different things. For example, if all of this is too small for you, you can set the display scale.

The default is auto at 150%, but this you can increase. Which you can even push further with a

custom display scale. In my case, to make sure all of this is visible, I'm going to set it to 2.5 and

then the display scale to custom. That way, we're getting this scale. If you now go to save and restart,

Godot is asking if you want to save the current scene, which I do want to do. And then we get the same editor with all

of the elements quite a bit larger. Now, in your case, you probably don't have to do that. Just choose something

that fits your needs. Most people leave it as it is, which is totally fine. But in my case, lots of people watch these

videos on a phone. For those purposes, this thing has to be larger. Besides that, you can go to theme and

choose a custom theme. Under preset, default is this bluish color, which I wouldn't recommend

because blue is just a bit distracting. My default is gray. If you have that one selected, after a

second, Godot is going to change the look and there we go. We have something much more neutral.

Finally, if you want to hide the top bar, you can press shift and F11

and then you are in full screen, which is what I'm going to go with, but in your case, just choose whatever you

prefer. Cool. With that, we can start working inside of Godot. Let's talk about the different UI

elements. The really big thing right in the middle of the screen is the viewport.

At the moment, it's 3D. If you hold the middle mouse button, you can rotate in here.

Later on, we are going to explore this quite a bit more, but for now, it's not too important. Instead, if you look at

the top, we have 2D, 3D, script, game, and asset library. We are mostly going to work in 2D for

now and in there, we have a 2D space. Besides that, we have script in which we are later going to have all of our

scripts. Then we have game and finally, we have the asset library, which allows you to download different kind of

plugins. We are going to have a deeper look at this later on, but in the most basic

sense, it allows you to expand Godot by adding specific tools. And by the way, you can switch between these different

modes using the F keys. F1 is 2D, F2 is 3D, and F3 is script. Those are the ones you're going to use all the time. For

now, I want to work inside of 2D. Inside of this scene, you can place a whole bunch of elements.

Those you usually get from the file system that you can find in the bottom left.

By default, Godot has one folder with one image file, icon.svg. This is the Godot logo.

To add this to your game, in the most basic sense, all you have to do is drag and drop it into the viewport and then

you have one image that you can move around. And well, you can also scale it

and do quite a few things. I'll talk about this in a bit more detail later on, but for now, I want to undo it with

control Z. While you could simply add a graphic into this viewport, this is not usually how you're supposed to approach

it. Instead, you want to look at the scene panel. This allows you to create a scene tree

where we can create a 2D scene, a 3D scene, a user interface, or create another node.

If you click on other node, you can see all of the nodes in Godot. And nodes in Godot are incredibly important. I'll

talk about those in just a second. But basically, in here, we have a whole bunch of nodes that can do different

things. The easiest one is a timer, which is just a basic countdown timer.

I think this one is self-explanatory. Besides that, we have an animation player or if you look under node 2D,

we have an animated sprite 2D, which is just an animated picture. We have GPU particles, we have a camera,

we have a collision shape, and if you look under collision object 2D, we have, for example, an area 2D that lets you

check if something entered an area. For now, don't worry too much about these nodes. I'll talk about them in a

lot more detail in just a second. I guess what we can do for now is drag the image back into the viewport and then

you can see inside of the scene tree, we have one node called icon. That's because this file name is called icon.

The actual node is a Sprite 2D. If you hover it, you can see type Sprite 2D.

Once you have that, you can look on the right side. There you have the inspector. This gives you all of the

properties of this node. For example, under transform, we have the position, rotation, scale, and skew of this one

node. If you change these values, you can see they update inside of the viewport in

real time. And in there, you can do a ton of different things and

manipulate this node to your heart's content. Although not something I want to do,

let's undo all of this. That way, we are ending up right here. Every node has a ton of properties that

you could be changing. And being able to change them is pretty much what gives you a game.

And all right, with that, we have the basics of Godot. So, let's talk about how we combine all of these different

elements. To understand how Godot works, you have to understand scenes and nodes. They are

the fundamental part of literally any game made in Godot. Let's start with nodes.

Those are the fundamental building blocks of literally any project in Godot.

They could, for example, be images, timers, sounds, 3D objects, animation players, and really a lot more. Godot

has hundreds of nodes. Back inside of Godot, if you click on this plus icon, you can see all of the nodes.

There are lots of drop-down menus in here. If you click on them, you can see everything that's available.

Now, the way this is supposed to work is that you are combining different nodes inside of a scene. Scenes actually have

two purposes. Number one, they are container for nodes. In other words, you're combining different nodes inside

of a scene. Besides that, scenes also manage what is displayed inside of the game.

For example, a scene could be a level. Imagine a Mario level where you have a fire world, a forest world, a water

world, and so on. Each of these levels would be one scene and you can tell Godot which one to

display. Now, this is a concept we really have to practice. So, let's have a look at all

of this in practice right away. Back inside of the editor, I want to get rid of this Sprite 2D by simply deleting it.

Godot is going to double-check I do want to delete it. After we have that,

I want to create a root node. For now, a 2D scene. This node we can rename to, let's say,

first scene. Usually in Godot,

you are going with this naming style where you start with a capital letter and then you don't add spaces and

instead you are adding for the second word another capital letter. You could add spaces, but when it comes to coding,

those can be really confusing. So, I would recommend to not do that. This will be our first scene, which I want to

save. This you can do either by pressing control S or inside of scene, you can save the scene.

Then Godot is asking you for the location. I want to keep the default one here. So, click on save and then in the

file system, you can see first scene. Also, if you look at the viewport, we have our first scene.

And inside of this scene, we have one node at the moment, a very basic Node 2D. This is our root node.

To this, we can add other nodes. This you do by either clicking on the plus icon or pressing control and A. In

either case, you get to create new node. In there, you can select any of these nodes. There is kind of a color skin

going on. 2D nodes are blue and they are inside of Node 2D. If you click on the drop-down menu, you

can see all of the 2D nodes. Green ones are for user interfaces and there, for example, we have text and

text input. There's quite a bit more in here, but for now, that doesn't really matter.

Then we have red nodes. Those are for 3D games. These tend to be a bit more advanced,

but for now, it's not too much of an issue. Finally, we have other nodes and those

tend to be white-ish. For example, in there, you have a timer or you have an animation player

that can be used for both 2D and 3D games. I think at the beginning, this can be quite overwhelming. So, don't

worry too much about any of this. For now, you primarily want to work inside of Node 2Ds.

And one of the easiest nodes that you're always going to start with is a Sprite 2D.

And at the moment, I can't find it. Oh, there it is. Sprite 2D. Now, most of the time, you don't

actually go for this menu manually. Instead, you search at the top.

I want to have a Sprite and then Godot is already going to a Sprite 2D. This I want to use, so click

on create. Then we have our first scene and a Sprite 2D.

This Sprite 2D at the moment is not visible. If you zoom out,

then you can see that, well, we can't see anything. That is because this Sprite 2D needs to

have a texture, which you can see inside of the inspector. At the moment, the texture is empty.

Now, if you click on the drop-down menu, Godot is giving you a ton of options. For example, you could create a simple

gradient 2D and then you are getting something that you do want to customize. So, in there, you want to drag and drop

the points around and then you get a proper result. Although not something I want to do. So,

let's undo it. Instead, you are supposed to drag a texture in there that you're getting

from the file system. In my case at the moment, we only have a single file, icon.svg.

Drag this one inside of texture and then finally, you can see the actual image. And once again, inside of the

inspector, you can transform this thing to your heart's content. Like you have seen a few minutes ago.

By this system, you can add more and more nodes to your scene. For example, we could be adding another Sprite 2D

with another Godot logo and then move the second Godot logo somewhere over here.

To make those two distinct, I could go to visibility and then modulate. This one lets you add a color tint. If

you click on it, you can change the color quite a bit. Let's make the Godot logo quite red or

really whatever you want. It doesn't really matter. With that, we have two Godot logos inside of the scene.

Or in other words, we are building a scene tree. This is effectively what we are creating in here.

Now, really important thing that you do have to understand is that these nodes are related. For example, this Sprite 2D

is a child of the first scene node, which means when we are changing this first scene, the changes also apply to

both of the children. If I go to first scene and then to transform,

there we have rotation. If I rotate this node, the children rotate as well. However, if I rotate a child on its own,

like this Sprite 2D, then the other nodes are not affected. In other words, a parent affects the

child, but the child does not affect the parent. On top of that, these two nodes right now are siblings.

They both have first scene as the parent, but otherwise, they're not really related, which means if you move

one, you don't affect the other. However, what you could be doing is attach this Sprite 2D 2 by simply

dragging it onto Sprite 2D and then Sprite 2D 2 would be the child of Sprite 2D, which itself is the child

of the first scene. Because of that, when we are changing Sprite 2D, we are also changing its

children. And if we change the first scene, then we are changing all of them as well.

I hope this system makes sense. Basically, once a node is a child of another node,

it is affected by all of the changes to the parent. A super important thing to understand. Now, besides that, if you

want to create a new scene, all you have to do is click on this plus icon. Godot already tells you add a new scene and

then you can create another scene. Inside of this scene, I want you to do an exercise.

Create a Godot stick figure by using Sprite 2Ds. The end result should look something

like this. This should happen via nodes and scenes. Pause the video now and see how far you

get. Inside of Godot, I want to create a 2D scene

that I want to rename right away to stick figure.

To this node then, I want to add a Sprite 2D. You can do this either via what you had

selected before or inside of recent nodes. Click on create and then once again, we can't see

anything. For that, you want to drag icon.svg into texture.

Then we can see Godot and let's say this part could, for example, be the torso. To make that look a bit more realistic,

we want to scale it up by using these points or by going to transform and then increasing the scale on the Y axis.

By default, those two scale together. If you want to scale one individually, click on this chain icon and then you

can change these individually. Alternatively, you can also drag these points and then change all of this

dynamically. This gives us the torso. Attached to that, I want to have another Sprite 2D

which should be the head. For this head, once again, we want to add icon.svg to texture. Once we have

that, we can't really see a difference, but if you move the head to the side, you can see that, well, the head,

because it's a child of the torso, is going to get the same scaling behavior. In other words, if I change

the scaling of the torso, we are also affecting the head. Which is usually not ideal, but for now,

what we can do is simply scale this thing quite a bit down to something like so and so

and then move it on top of the node. That way, we're getting some kind of a head.

Besides that, once again, I want to add another Sprite 2D, which you can also do by simply dragging icon.svg into the

viewport. That way, Godot is automatically creating another Sprite 2D with the name of the file you just

added, which is not what I want. This should be, let's call it the right arm. Which at the moment is not a child of

torso, so it doesn't get the scaling behavior applied to it. That's totally fine. This thing, I just

want to scale down a bit to something like so and then, inside of transform, I want to

rotate it to something like this. Next up, I want to press control and D. That way, we are duplicating the node, and

this gives us the other part of the arm. Which we want to rotate as well. Let's say something like this.

And I guess right arm two should be a child of the right arm. That way, if we're changing the upper arm, we're

changing this node as well. Next up, I want to add another node. This is going to be

the left arm. Which at the moment is a child of the right arm, which I don't want.

I simply want to drag it onto stick figure, and then left arm is not a child anymore.

Because of that, if you go to transform, we can undo all of these changes, and then we get the default Godot logo.

And this I want to once again scale down a bit and rotate so it looks a bit more like an arm.

Then we can duplicate this thing again, move it here, and transform it just a bit more.

Let's say something like this, and then left arm two should be a child of left arm.

Two more things I want to add, and for that, I simply want to add the other Godot logo, and once again, this should

be a child of stick figure. Then I can undo all of these changes. And for this part, I simply want to add

a leg. So, let's make this a bit thinner and a lot longer and move it down here.

This should be the right leg, which we can duplicate and then move it to the side.

This would be the left leg. And with that, we have a very basic Godot stick figure.

All of this, I want to save as stickfigure.tscn. Click on save, and now, inside of the

file system, we have stickfigure.tscn. Looks pretty horrendous, to be honest, but I think you get the idea. Now, once

we have that, what is super important to understand is that this scene can be added to another scene.

For example, to our first scene, we can click on this icon, where we can instantiate a child scene.

If you click on it, you can see all of the scenes inside of the project. At the moment, we only have two. First

scene, that's our current scene, and then the stick figure, which is what I want to add.

If we are doing that, we are getting the stick figure. At the moment, it's rotated because

first scene itself is rotated by a certain amount, which I don't want to have.

If I undo that, then we have the stick figure inside of our first scene. And I hope

you understand how this system comes together, because it's really important to understand. For example, later on,

the stick figure would be replaced by a proper player, which has all of the parts that the player actually needs.

And then the first scene would be a level. That itself is a scene with all of the

parts of the level, and one part of this level is the player itself. So, effectively, the scene is going to be

what you display inside of the game, and the scene is something that organizes different nodes. It does two things. If

you then combine different scenes together, you can create pretty complex projects that are still maintainable,

because you only ever touch small parts of it. We are going to practice this sort of system a lot more throughout

this course. I just hope for now you understand the absolute basics of it. Two more things that I absolutely want

to cover. Number one, let me move this thing a bit down here, this thing here, and this Sprite down here.

All of this should be inside of this blue frame. This is what you actually see when you

are running the game, which by the way, you are doing via these buttons up here. The most important button is run

project, or F5. If you click on it, Godot is asking you what the main scene is going to be. You can select one

manually, or you can select the current one, which in our case is first scene, which is what I want to do.

If you click on it, then the game is going to run, and we can see the stuff that we have just created.

On top of that, on the top of this window, we get a lot more things that aren't too important, so don't worry

about them. Although, the one thing you do want to worry about is the resolution, which at the moment is 1152

by 648. Now, if you resize this window, this can change. You can also go to project, project

settings, and then, under display and window, set a custom window resolution. Although,

that's not too important at the moment. Besides that, what can be really confusing is the positioning inside of

this window. If you click on first scene, we have a position of zero and zero. This is in the top left. You can

see it via this red cross dot thing. If you click on the first Sprite 2D, this one here, it currently has a position of

151 and 168 for X and Y, or the horizontal and vertical axis. What do these numbers actually mean? To

understand them, you have to understand how the window works. The origin point is in the top left. This is position

zero for X and zero for Y. If you go further to the right, then X is going to become larger and larger

until you reach the right side. This at the moment would be position 1152. In other words, this for example could

be 100, this could be 200, and so on until we reach the right side of the window.

I think this part makes sense. The further right you get, the greater X becomes. On the Y axis, this gets a bit

more confusing, I think. To go down, you want to increase the number. For example, this would be 100 pixels. If

you go down a bit further, you'll be at 200 pixels, and if you keep on going down, at some point, you reach the end

of the window, which I think was 648. This can be sometimes counterintuitive. You want to increase the number to go

down. Most game engines work like that, where the origin point is in the top left, and

if you want to go up, then you have to go with negative numbers. So, this part here, for

example, would be negative 100. Especially in the beginning, this can be confusing, but once you work with it for

a bit, it does become fairly intuitive. And just to play around with it for a bit,

if you have this node selected, I can set the value to zero and zero. That way, we are right in the center.

If I then increase this value for X to, let's say, 50, we are going further to the right, and

if I set the Y value to 100, we're going quite a bit down. If I set Y to negative 100, then we are

going up. And via that system, you can place different nodes inside of this window. And well, with that, we have the

foundation of Godot. At this point, you just have to learn about more nodes that do more things, and you have to learn

about GDScript to make all of this interactive. To add a script to a scene, you want to have a node selected, and

then click on this icon. Via that, you can attach a script. Let's stick with our first scene, and

then we can select the language. The default here is GDScript, that's totally fine.

Then we have inherit. This has to match the type of node that we are working with, and usually, you

want to stick with the default. The next important field is the path where we want to save the script that we are

creating. Most of the time, you can stick with the defaults and simply click on create. Once you have that, inside of

the file system, we have firstscene.gd. And we can write some code in here. That way, we can create the logic for our

game. From this point on, you can continue in two ways. If you don't know any coding,

simply keep on watching from here. I will talk about of coding. If, however, you already know some coding, even just

a little bit, I would recommend that you skip ahead and start with the first game. If you

have done any kind of coding before, you should be good to go already. And of course, you can always go back and look

at the coding part. I guess if you are not sure, here are a couple of code snippets that we are going to use inside

of the first game. If this doesn't look overwhelming, you safely skip ahead. Let's get started with coding. And for

this part, I will assume that you have never touched a programming language before.

Don't worry, it's actually not that hard. In the most basic sense, all that we are

doing is create some kind of logic. For example, if you want to move an object to the

right, if its position is less than 800 pixels, it would look something like this.

We start by creating an if statement by writing if. Then we are checking a value that can change. So, this position X

could be part of an object that is moving to the right. This we are comparing against a static value, in

this case 800. This condition can either be true or false. If it is true, then we are doing the stuff that is

indented on the next line. And if that is the case, we're getting the current position X,

and we are assigning it a new value, which is going to be the current value plus five. So, we are moving it further

in a certain direction. And that's really all we are doing most of the time. The majority of the logic

isn't going to get that much more complicated. In practice, this kind of logic can be created in multiple

different ways. Godot is actually supporting multiple coding languages. The default one is called GDScript,

which is really really easy to learn. It is actually very similar to Python, which is one of the most common

programming languages. If you know GDScript, you basically know Python. And Python can be used for a ton of other

things, like data science, databases, AI, and so on. Besides that, Godot does support other languages, but I'm going

to focus on the basics. So, we're going to work with GDScript. Once we have that, to actually write code in Godot,

you want to attach a script to a node. And via that, you can change the property of that node, like the

position, size, rotation, and anything that you can find inside of the inspector. Or in other words, back

inside of the scene that we have seen earlier, if you click on this Sprite2D,

you can change any of these properties, like position, rotation, scale, and skew.

You could also change the visibility, modulate, and really anything that you see in here can be changed via GDScript.

All you have to do is hover over the property, and then Godot is telling you how you can change it. And there can be

a ton of information in here. You can also change other nodes, create new nodes, target other scenes, and even

get data from the internet. There's basically no limit to what you can do. Godot is incredibly flexible and lets

you do a ton of things. We are nearly ready to start. There's just one more thing that we have to

cover, and that is that Godot organizes the code via functions. Functions, in the most basic sense, are

just blocks of code. Via those, you are grouping different lines of code together to do a certain thing.

For now, we are going to work inside of two functions that are inbuilt into Godot. The ready function, which is

executed when a scene is ready. You'll see in a second what that means. Besides that, we have the process

function, which is run on every single frame of the game. And before I start throwing too much theory at you, let's

have a look at all of this in practice. Back inside of Godot. This is getting a bit too complex, so I

want to create a new scene, which is supposed to be a plain 2D scene. Let's rename this one to coding one.

This I want to save right away. You could create another folder in here if you click on this icon, but in my

case, I'm going to leave it as it is. Click on save. And now,

we have a scene with one node, coding one, which is totally fine for now. To this scene, I want to add a script,

like we have done before. So, attach a new script, and leave all of the defaults here in place.

Then create. And now, to actually do something, we have to work inside of a function,

because remember, all of the logic in Godot has to be inside of a function. To create a

function, you want to write the keyword funk, and then the name of the function.

You can basically choose any name in here, but there are some special names. They usually start with an underscore.

If you simply type an underscore, then Godot is suggesting you all of the inbuilt Godot functions.

The one that I want to work with is ready. If you click on that, you get ready,

then two parentheses, an arrow, and then void. This last part we actually don't need, so you can get rid of it to keep

things easier. This would be the most basic way to create a function.

You have the keyword funk, this always has to be there, then the name of the function, and then

two parentheses. We will see later why these are important. If we only type this, Godot is going to

complain, which you can see at the bottom, that Godot is expecting an indented block

after the function declaration, which means we have declared a function here, and after that, if you press enter,

Godot is creating an indented line, which basically means that we are pressing tab, and whatever we are

writing next is going to be indented. Having this line being indented means it is part of this function.

That way, if we later on create another function, let's call it something,

then anything that is indented afterwards is part of this function. Or in other words, via indentation, you

can group things together. So, what can we actually do inside of this ready function?

And well, the most basic thing that you want to do is to print data for now. For that, you simply want to write

print, and then use parentheses again. After that, whatever you write inside of this

print statement is going to be printed out once we are running the game. For now, let's simply write a number, 1

2 3. Could be any number for now, doesn't really matter.

Once we have that, we want to run this one scene, coding one. If you simply click on this icon,

run project or F5, then nothing is going to happen because earlier, we have set this first scene as

the main scene, which means no matter where you are, if you are clicking on this icon, you always run the first

scene. If you don't want that, inside of coding one, you can click on

this icon here, where you are running the current scene, or simply press F6.

If you are doing that, then the game is going to run, and if you look at the bottom,

there we have the output tab, and this at the moment says 1 2 3. That we are getting because inside of script, we are

printing 1 2 and 3 once the scene is ready. Alternatively, what you can also do,

inside of project, project settings, you can go to run, and then set the main scene.

I guess for now, we can set the main scene to coding one. Then I can close this dialogue, and

simply run the project. And now, we are running coding one via F5 or this button.

At the moment, we are using two inbuilt functions of Godot. Print is a function, and ready is a function. But this might

be a little bit confusing, because for the first ready function, we had to use funk, whereas for the second function,

we don't do that. So, what's happening here? To understand that, let's talk a bit more about functions. There are two

things that we are doing at the moment. Number one is we are creating a function. For that, we are using the

funk keyword, then the function name, and then we have parentheses that can accept parameters, which we don't have

at the moment. That's going to come later. But via those, we could add information to the function. After that,

we have indented code with the actual logic. Now, the important thing is that this is only creating a function. It

doesn't actually use that function, at least by default. To actually use this function, you have to call it, which is

another way of saying that you want to execute the code that you have created. For that, you want to use the function

name, and then add in arguments, depending on how many parameters you have. Now, in our case, we are creating

the ready function. And this function is special because Godot is calling it internally. Whenever we are executing

the project, this function is being called by Godot once the scene is ready.

So, we only have to create it, Godot is calling it for us. But for the print function, it's the

other way around. It's an inbuilt function into Godot, so we don't have to create it, we just have

to call it. And when we are calling it, we have to add an argument into it. At the moment, this is 1 2 and 3.

And the result of this is that Godot, inside of output, is printing 1 2 and 3.

If you want to display some text in here, you couldn't simply write something.

That wouldn't work. Instead, I will talk about later why this doesn't

work. But what you have to do is put this inside of quotation marks. Single or double ones would both work, you just

have to be consistent. I will use double ones because that's what Godot uses internally, but it's

really up to you. If I now run the project again, we get something inside of the output.

And that way, you can print anything inside of the output. To practice all of this, I want you to create a new

function and call it as well. So now we're doing both things. The new function should print something

and 1 2 3. In other words, you want to call the print statement twice inside of that new

function. And the new function itself, you want to call inside of the ready function.

Pause the video now and try to figure out this one out and see how far you get.

First of all, we want to create a new function. For that, once again, we will need the funk keyword and then the name

of our function. I guess I should have mentioned this earlier, but this has to be inside of

one string of characters. This could, for example, be something. After that, you need the parentheses,

opening and closing ones, and then colons. Then, inside of the function, we need one level of indentation, like so.

Godot should be doing this automatically, and then we want to call the print function.

And write something. And on the next line, we also want to print 1 2 and 3. By that, we have a new

function that does two things. We are printing something, and we are printing 1 2 and 3. But this function, by

default, doesn't do anything. If I run the code, the output is only something, which we

are getting from this print statement. To actually use this function, you have to call it, which you do by writing the

function name, in my case, something, and then add the parentheses afterwards, opening and closing ones.

If you're doing that, then we're getting something twice and then 1 2 3.

The first something comes from this print statement, the second one from this one, and then we get 1 2 and 3. I

guess the first print statement should say something else, let's say test, then this becomes a bit easier to see. We

have test, something, and 1 2 3. And by that, I think you can already see a couple of basic things. The most

important one is that Godot is executing code line by line. We are starting inside of the ready function, which is

called once the scene is ready. In there, first of all, we are calling print and test.

After that, we are calling the something function, which is down here. Inside of this function, we are printing

two more things. Something and 1 2 and 3. Because of that, we can see test first,

then we have something, and then we have 1 2 and 3. So with that already, we can create a new function, and we can call

functions as well. Either in-built ones or ones that we have created ourselves. In a little bit, we are going to talk a

lot more about functions. They tend to be slightly more advanced, and usually you cover other things

first. But since Godot executes all of the code inside of functions, I had to cover it right away. So I hope this part

isn't too confusing. The only thing that you have to really understand is that you are creating

functions via funk, the name of the function, and then parentheses. Also, don't forget about the colon.

You want to indent some lines, so you know that this line belongs to this function.

After which, you can write any kind of logic. In the next part, we're going to talk about that a lot more. To call a

function, you want to write the name of the function and then parentheses. Inside of the parentheses, you can add

arguments, which we don't have for the something function, the one that we created, but

for the print statement, we can add one argument, and this one prints a certain thing.

So with that, we have functions. Next up then, we can work on actual logic. Now that we can create basic functions, we

can work on logic and variables. And let's start with logic right away inside of Godot. Here we are again, and

I want to keep on working inside of coding one, specifically the script. At the moment, we are only printing

test, which doesn't really do very much. So instead, let's do something a bit more interesting.

And I guess while we are here, we can get rid of all of this stuff as well, because it's going to be a bit

confusing. I only want to have the ready function where we are printing something.

And that something is not going to be a word, it's going to be a math equation. And for that, you can simply type

something like 2 + 2, run the project, then you get the result, four. Other operations would be

2 - 2, then we get zero. You can also do two multiplied with two,

or let's say two multiplied with three, that way we are going to get six. And finally, you can do two divided by

three. Although then we would be getting zero, because Godot is rounding this value, that we can change later. For

now, not too important. Let's do 9 divided by 3, that way we're getting three as the result.

These are the very basic things that you can do via math inside of Godot. And Godot supports a huge range of math

operations. The best way to learn about them is to use the documentation.

Godot actually has multiple kinds of documentation. There's one inside of the Godot engine right away.

If you click on help, there's search help, and then you basically get an overview of all of the parts of the

engine. This isn't really a tutorial, it's more of a manual. If you go to Google, you

can look for GDScript reference. That way, the first result should be the

Godot documentation. If you click on that, you get a page that tells you all about

GDScript. It is quite a long page, but in there, you have a ton of information. I would recommend to have this page open

all the time, it's super super useful. Right at the beginning, we have an example of GDScript, and there are some

things that we have already seen, like for example, a function with a couple of parameters, that we're going to cover

later. Besides that, there are loads of things that you haven't seen yet, so don't worry too much about it.

Instead, go down a bit further to the operator part. In there, you can see all of the math operations, like x +

y, x - y, and then you get all of the other operations as well. The only things that you need for now are these

operations, everything else is going to be a bit confusing. But it is still super useful to at least

have a look at this page and see what you can be doing. By the end of this course, all of this

is going to make sense. Now, using this information is really important, so I want you to do an exercise right away.

I want you to calculate Pythagoras' theorem, where side A is 10 and side B is 20.

Calculate the output using GDScript. Just in case you don't know what Pythagoras' theorem is, you can go to

Google and then look for Pythagoras' theorem calculator,

then Google is giving you the formula that you have to write inside of GDScript.

You are taking the square root of the square of A plus the square of B. By that formula, you can calculate a

side C inside of a triangle simply from knowing side A and side B. So in our case, we know side A is 10 and

side B is 20. The result should be around 22. This is what you should be getting.

So effectively, what I want you to do is to put this formula into GDScript. For all of that, you want to look at

these couple of lines inside of the documentation and figure out how to combine them. Pause the video now and

see how far you get. Back inside of Godot, I want to print the result, like we have

seen before. Although before that, I want to add a hashtag and then add exercise.

If you add a hashtag, then Godot knows this is going to be a comment, meaning the code is going to entirely ignore

whatever you write in here. Which makes it much easier to document your code.

Not something you have to do, but I think in this case, it does make things a bit easier to read. Once we have that,

we have to write the actual formula. You can see it in the bottom right at the moment. First of all, we want to get A

squared, which in our case is 10 and then squared. Which you do by adding two asterisks and

then two. That way, you are squaring the number 10.

Then we want to add something, which is the value for B, which in our case is 20. Which we also want to square.

So two asterisks and then a two. If we run the project now, we are getting 500.

That is because the square of 10 is 100, and the square of 20 is 400. If you add both of them together, you're

getting 500. But now, we have to take the square root of all of this.

Now, getting the square root might have been one part that is a bit more complicated, because there's no square

root in any of this. However, what you can do is use the power once again.

If you take half the power of any value, you are taking the square root. Or in other words, let me demonstrate it

really quickly. We can print nine asterisk asterisk, so the power of 0.5.

That way, we are taking the square root of nine. The result is going to be three, or at least I hope it is, and it

is, 3.0. However, now there's another thing that we do have to worry about. If I simply add

asterisk asterisk and 0.5, we are not going to get 22. If I run the entire thing,

we are getting 120. And to only focus on the value, let me get

rid of this one. This value should return 22. Whatever we have seen down here with 22.

The reason why we don't see it is because this square root only applies to this value. But we want to apply it to

the entire thing. To do that, you want to wrap them inside of parentheses, like so.

And let me add a bit more spacing to this, that way it's going to be a bit more visible.

We first of all want to do this operation, and then take the square root of the entire thing.

Via these parentheses, we can control the order of operation. If I now run the entire thing, we should

be getting 22.something, and we do. This looks really good. So, I hope this part wasn't too overwhelming.

But effectively, we have used different kind of equations and put them together to create a bit more advanced logic. And

this logic you can control via parentheses, and that way, with a bit of practice, this should become fairly

straightforward. But now, what if we want to make all of this more dynamic, where the numbers aren't always going to

be 10 or 20? For that, we have to learn about variables. Variables are basically buckets that

store data. You can either read them, or you can change the value.

This is super useful to keep things organized. And once again, if you look at the

GDScript reference, at the top, we have a whole bunch of variables. Let's create some of those.

Those you can create outside of a function, and they are just about the only thing that you can create outside

of a function. To create a variable, you always start with var. That way Godot knows you want

to create a variable. Then you need a variable name. This could, for example, just be A.

After that, you want to assign a value to this variable, which you do via equal, and then the value you want to

assign. Like, for example, a 10. Next up, we can create another variable, B,

and this one can be 20. And now you have two variables, which you can use inside of this

equation. All you have to do is replace the 10 with A, and the 20 with B. If you run the code now, we are still

getting 22.something. But if I change these variables to, let's say, 20 and 30,

then we are getting something else, whatever the output is. Via that system, you can be much more

descriptive in terms of what your code can do. So, I think just looking at this, it

makes quite a bit more sense instead of just having random numbers in here. Although, when you're naming variables,

you do want to be careful. There are a couple of things that you have to do. Number one,

variable names cannot start with a number, have a space in them, or use special symbols,

like the dollar and the ampersand symbol. Those are reserved by Godot.

Other than that, you are basically good to go. And by the way, these rules also apply to functions.

They basically have the same kind of naming scheme. Besides that, variable names are usually

written in the snake case convention, meaning you only use lowercase letters, and if there's a space, use an

underscore. That's what most people use, but it's just a convention. You don't have to follow it.

That being said, it is recommended that you do. For example, instead of simply using A,

you might want to go with side_a. And for B, you want to have side_b.

Once you're doing that, Godot is complaining because now variable A and variable B don't exist

anymore. Instead, they have been renamed to side_a and side_b.

Once you're doing that, Godot is happy again, and we are good to go. That way, the variable naming is also a lot more

descriptive. Most of the time, you do want to be quite careful how you name variables.

If you mess this up, and your code becomes more complex, this can be incredibly confusing.

Other than that, though, this is basically how you create variables. You create them in the first few lines of

the code, and then inside of any function, you can use them as a stand-in for any other number.

So, at the moment, we are simply reading a variable. Besides that, what you can also do is override the value. So, for

example, side_a can be, instead of 20, a 100. After the line, I can print side_a again,

run the code, and now as an output, we are getting a 100. And I think now it's important to understand how Godot is

executing the code. It goes through it line by line. It first does this line,

then it does this line, and then it does this line. Because of that, for this formula, the value of side_a is 20. But

on the next line, we are changing that value to 100. And just to demonstrate, let me run the project. The current

output of the formula is 36.something. This is what we're getting from this statement. But if we move side_a being

100 one line before that, and run the thing again, then we are getting a different number,

104. That is because now side_a is 100. So, inside of this formula, side_a is 100.

But if we update value A afterwards, then this side_a is what we're getting up here,

20 in my case. So, it's really important to understand how this code is executed. Godot goes

through it line by line, and then simply goes through all of these operations. Really important to understand,

sometimes this can give you some weird results. Besides that, along with variables, we

have to learn about data types. Now, inside of Godot, there are a ton of different kinds of data types. So, for

now, I am only going to focus on the most common ones. First of all, we have text.

These, inside of Godot, and really any kind of programming language, are called strings. You are creating them via

double or single quotation marks, and then whatever kind of text you want to have inside of them. Besides that, we

have numbers. And those are actually two data types. We have integers and floating point values, or simply floats.

The difference between them is that integers are full numbers, meaning 1, 2, 3, 20, and so on. Could also be

negative, like -100. Floating point values have decimal points, like 1.0 would be a floating

point value. Could also be 1.5 or -2.4. Then we have true and false values.

Those are called booleans. They can only be true or false. Once we get to if statements, those are becoming

incredibly useful. Finally, we have different kinds of lists. Those can store multiple values inside

of a single variable. Now, those I am not really going to touch yet. There's going to be a

separate part on them. But there you have arrays, dictionaries, and vectors. I do want to mention them now because

they are incredibly important, really, really common. Variables and data types.

You can force a variable to only accept a certain data type. For example, you can tell a variable to

only hold integers or floating point values. That way, it would be impossible to assign text to it,

which is generally a good idea. It's a good safeguard to make sure a variable doesn't get the wrong kind of data.

Although, if you don't do that, variables by default can hold any kind of data. But let's play around with all

of that. Back inside of Godot, let's say I want to create a new variable.

And this can just be called test. Test should only hold strings. Like, for example, some

test string. This value I want to print. And this we can do all the way at the

end, inside of the ready function. I want to print test. If I now run the project,

we're getting some test string. That works pretty well. We are printing this piece of text, or

this string. However, before this final line, we can assign a different value to test. Like, for example, 1 2 and 3.

If I now run the code, as an output, we're getting 1 2 and 3, which would be an integer, because now

we have a full number. If we want to avoid this kind of behavior,

what you can do, after naming this variable test, you can add a colon,

and then tell it to always be a certain kind of data type. For example, a string.

If we have that set up, then Godot, on this line, is going to throw an error that we cannot assign a

value of type integer as a string. We are telling Godot that this variable always has to be a string, meaning we

cannot assign an integer to it. If we change this to some other string,

Godot would be perfectly happy because we still have a string. Besides string, we also have integer.

And if I do that, Godot is going to complain on these two lines that we are trying to assign a string to

a variable that can only hold integers. Which means now, this has to be numbers. So, 1 2 3 or really any

other that you can be very explicit in terms of what kind of value you are working with, which usually is a good

idea. Especially once projects become more complex, you want to be very very

explicit in terms of what values you have. Without that, you can very easily get

some random errors that you don't understand. And always having the right data type is a good way to avoid that.

Now, this can be sped up quite a bit. If you simply add colon and equal to a certain kind of

value, then you're forcing this variable to only hold the data type that is first

assigned to it. In this case, an integer, meaning now if I try to add a different kind of

value to test, like for example, a string, then Godot is going to complain because

this variable can only hold a type integer because that's what we first assigned to

it. Or in other words, this has to be a string. So, with that, we have

different kinds of data types. We have integers and we have strings. Besides that, you

can also add floating-point values, like 30.0 or let's say 30.2. Now, both of those are numbers and if

you use them inside of an equation, they would still work. So, if I run the code, Godot is still going to execute all of

this and we are good to go. But sometimes, this difference between an integer and a floating-point value

does become apparent. We have actually seen this earlier. If we have 2 / 3, so the first operation

we did, in the beginning, we have gotten a zero because we are dividing an integer by

another integer. And the result is also going to be an integer, which has to be a full number.

Godot is actually giving us a warning about that. If you look at the debugger down here, we are getting errors.

Although in there, we have errors and warnings. Yellow ones are warnings. We have an integer division, where the

decimal part will be discarded. That happens on this line. To avoid that, to get an actual value, you want to have