Introduction to GDScript in Godot 4 Half 1

Scripting is a basic talent for any recreation developer. You’ll be able to implement nearly any recreation mechanic you may consider by writing a number of scripts that tells the sport engine what to do. From making a personality transfer to creating enemy AI that taunts you from behind a canopy, it’s all attainable by writing some code.

On this tutorial, you’ll study the fundamentals of GDScript 2.0, the primary programming language of Godot 4. You’re going to create a easy recreation impressed by Winterbells, a basic Flash recreation from 2006 by Ferry Halim. The aim of this recreation is to leap larger and better by hitting the bells together with your white rabbit good friend.

The sport you’ll be making entails hitting vitality orbs with a robotic to spice up your self up as excessive as you may.

There’s nothing higher than making a small recreation to get a really feel for a programming language! The tutorial is break up into two components, on this first half you’ll study:

• The basics of GDScript and the built-in script editor.
• Creating and utilizing variables to alter and steadiness the gameplay.
• Utilizing Godot’s highly effective sign system to cross values from one node to a different.
• Polling for participant enter and utilizing it to alter the sport state.
• Scripting leaping and gravity.

Getting Began

This tutorial makes use of the newest model of Godot 4, which you’ll be able to obtain right here.

Obtain the initiatives by clicking Obtain Supplies on the prime or backside of the tutorial and extract the zip file to a location of your selecting. After extracting the zip, you’ll see two folders: starter and closing. The starter challenge is what you’ll be utilizing to construct upon.
To import the challenge, open Godot and click on the Import button within the Venture Supervisor. Now both paste the starter folder path within the textual content area, or click on the Browse button to navigate to the folder.

Subsequent, click on the Import & Edit button to load the challenge in Godot’s editor. Be sure that the 2D display is energetic and the recreation scene is opened. If this isn’t the case, open it by double-clicking recreation.tscn within the scenes folder.

Earlier than having a look across the totally different scenes that I arrange, attempt to run the sport by urgent F5 in your keyboard or clicking the Run Venture button on the prime proper. It is best to see a blue robotic standing on the backside of the display whereas some music performs within the background.

If that’s working as anticipated, it’s time to provide a fast tour across the starter challenge.

Venture Tour

I’ve ready some fundamental scenes and property so you may focus totally on scripting. To begin off, check out the FileSystem dock and the folders and recordsdata inside:

• music: A single audio file that’s used for the background music.
• scenes: All scenes used all through the challenge. Extra on these under.
• sounds: A glass-shattering sound impact.
• sprites: This comprises the background graphics and the sprite sheets for the robotic and jumper orbs.
• credit.txt: An inventory of sources and attributions for the included property.

Subsequent up is a short overview of the scenes.

Recreation Scene

The primary and most vital one is recreation. This the primary scene and it comprises the next nodes:

• A Camera2D with a repeating background Sprite2D as a baby
• A floor Sprite2D node
• An occasion of the player_avatar scene named PlayerAvatar
• An AudioStreamPlayer that routinely performs and loops a music observe
• An occasion of the ui scene named UI

Notice: If you happen to’re unsure what a selected node does, you may right-click the node and choose Open Documentation within the context menu. This opens the documentation for that node class within the Script display.

On the finish of this tutorial, this would be the scene the place all of the motion occurs because the avatar will transfer about and hit vitality orbs referred to as “jumpers” to launch itself upwards. Talking of jumpers, double-click the jumper.tscn scene file to have a look what’s inside.

Jumper Scene

On this scene, the foundation node Jumper is an AnimatedSprite2D which holds its animations. The Area2D node and its CollisionShape2D are used to detect collisions with the participant avatar. Lastly, ShatterSound is an AudioStreamPlayer2D that references the glass shatter sound impact discovered within the sounds folder.

Now open the player_avatar scene and take a peek at its nodes.

Participant Avatar Scene

At its root is a Node2D node which is used to group its kids collectively: an AnimatedSprite2D with a number of animations and an Area2D used for detecting collisions. Easy however efficient!

The ultimate scene to check out is the UI scene, which yow will discover in ui.tscn.

UI Scene

The UI scene comprises the person interface for the sport, which is a CanvasLayer that has two textual content labels to maintain observe of the peak and rating. The MarginContainer and HBoxContainer nodes align these labels to the underside of the display with some margin from the borders of the display.

That concludes the challenge tour. Don’t fear in the event you’re unsure what the scenes are imagined to do exactly but, you’ll get accustomed to the smaller particulars whereas including logic through scripts and playtesting. With the fowl’s eye view out of the way in which, it’s time to begin your GDScript adventures!

Why GDScript?

GDScript is a high-level, object-oriented programming language that was constructed particularly to be used with the Godot recreation engine. Whereas different languages like C# and C++ will also be used with Godot, GDScript is commonly the language of alternative as a result of wealth of examples, questions, and tutorials accessible on-line. It’s additionally the first-class citizen in Godot because it’s absolutely supported by the built-in script editor.

If you happen to’re accustomed to Python, you then’ll discover GDScript’s syntax to be intuitive and straightforward to study. Even with minimal data of different programming languages, you’ll be comfy with the language with a number of days of apply.

On this tutorial, all scripting shall be completed utilizing Godot’s built-in script editor, so that you gained’t want anything to get began. If you happen to choose to put in writing your code in a unique window or IDE, you should use an exterior editor like Visible Studio Code, Vim or Elegant Textual content. Personally, I like to recommend utilizing Visible Studio Code with the godot-vscode-plugin, though some features like debugging will not be but suitable with Godot 4.

As a closing suggestion, listed below are two editor settings for the built-in script editor you would possibly need to change through Editor ▸ Editor Settings within the prime menu:

• Disable Textual content Editor ▸ Conduct ▸ Clean Scrolling. It is a private desire, however I discover easy scrolling slows down the velocity to navigate a script by scrolling.
• Allow Textual content Editor ▸ Completion ▸ Add Kind Hints. This provides static typing to variables and features generated by Godot, which improves efficiency, autocompletion and reduces the probability of bugs. I’ll clarify why that is the case later within the tutorial.

Scripting Fundamentals

Let’s put the speculation and background info apart for now and give attention to what you got here right here to do: write scripts!

Creating New Scripts

To begin off, create a brand new folder on the root of the challenge’s filesystem by right-clicking res:// and deciding on New ▸ Folder.

This folder will maintain all of the scripts, so identify it scripts. The primary script you’re going to create shall be for the participant avatar, so open the player_avatar scene. Now choose the foundation PlayerAvatar node and press the connect script button that appears like a scroll with a inexperienced plus signal.

This opens the Connect Node Script window, which you should use to set the preliminary settings for the script.

Right here’s a rundown of those settings:

• Language: Godot helps different languages in addition to GDScript, which you’ll be able to select right here. The default construct of Godot solely comes with GDScript, whereas the .NET construct additionally has C# included.
• Inherits: The Node class to inherit the script from. This provides your script entry to variables and features distinctive to that node kind.
• Class Title: The category identify of the script. This solely applies to totally different languages than GDScript. For C# this is able to be PlayerAvatar for instance.
• Template: What script template to use. This adjustments how the brand new script shall be structured, with or with out feedback for instance. Godot comes with a Default and an Empty template out of the field. You may as well create your individual script templates.
• Constructed-in Script: By default, Godot saves scripts as recordsdata. When that is checked, the script is constructed into the scene itself. This may be helpful in uncommon circumstances, however having exterior scripts is extra intuitive and higher for supply management.
• Path: Venture path the place Godot will create the brand new script.

Discover that the trail factors to the scenes folder by default. Make sure that to interchange “scenes” with “scripts” within the path, both by hand or by clicking the folder icon and navigating to the scripts folder. The default filename “player_avatar.gd” is ok as Godot makes use of snake_case for its recordsdata and folders. With the proper path set, click on the Create button to create the script.

This may routinely open the script editor with the brand new script opened. Press CTRL/CMD + S to save lots of the scene and the script after which have a look across the totally different components of the editor.

Under is a abstract of the totally different sections:

1. The toolbar situated on the prime of the display comprises a menu on the left with typical instructions present in textual content editors plus some helpful scripting choices like altering the syntax highlighting. On the correct facet are two buttons; On-line Docs which opens Godot’s on-line documentation in your default internet browser, and Search Assist which opens a search window that means that you can search and discover information in regards to the built-in lessons.
2. Opened scripts are displayed on the prime, whereas the underside record reveals the features of the script you’re enhancing.
3. The textual content editor shows the content material of the script, and is the primary workspace you’ll use all through this tutorial. On the prime proper is a minimap, which makes it straightforward to shortly navigate bigger scripts.
4. The panel on the backside has an arrow button to cover the 2 lists on the left, and reveals any warnings and errors on the proper, together with the road quantity and column the caret is positioned on.

Now you’re a bit extra accustomed to the interface, it’s time to have a look at the script itself.

Script Anatomy

Godot’s default script template makes for an incredible place to begin to construct upon additional. It even comprises some helpful feedback! I’ll bridge the hole to make it extra apparent what the unexplained components do.
The primary line reads extends Node2D, which suggests this script inherits from the Node2D class. The extends key phrase permits your script to make use of the variables and features from the inherited class.

Under which can be two of probably the most used features in Godot: _ready and _process. Because the feedback counsel, _ready is known as as soon as at first of the node’s lifespan, whereas _process is known as each body. These are overrides for the digital features of the identical identify within the Node class, the category all different node-based lessons inherit from. You’ll be able to see which features override their base class by little blue arrow in entrance of the road quantity.

Each features begin with an underscore to mark them as personal, which means you shouldn’t name these features from one other script. Godot doesn’t implement this in any approach although, it’s a conference to maintain your code clear.
The cross key phrase in each features is a placeholder, it doesn’t do something apart from ensuring there’s one thing indented contained in the operate so Godot doesn’t throw errors. Strive eradicating the entire cross line within the _ready operate to see for your self.

This may present an error on the backside saying: “Anticipated indented block after operate declaration”. GDScript makes use of indentation with tabs (or areas) to specify what code belongs to what operate or assertion. Now change the _ready operate as follows:

func _ready() -> void:
    print("Participant avatar has loaded!")

The print operate prints arguments of any kind to the output console. Save the script and run the sport by urgent F5 to see it in motion.
If every little thing went nicely, it is best to now see the textual content being displayed on the backside. If you happen to don’t see the console, click on the Output button to toggle it on.

With the basics lined, you’re now able to faucet into the ability of GDScript!

Variables

The participant avatar wants to maneuver left and proper in direction of the place of the cursor. To do that, you’ll want preserve observe of the avatar’s present velocity, its motion velocity and the mouse place. You’ll be able to retailer these values as variables in your script.
You’ll be able to outline variables in Godot utilizing the var key phrase. To begin with, outline a brand new variable named velocity that may be accessed all through the script by including this line under extends Node2D:

var velocity : Vector2 = Vector2.ZERO

There are some things occurring right here:

• var velocity defines a brand new variable and names it velocity. This by itself is sufficient to create a brand new variable in the event you don’t care in regards to the kind or default worth.
• : Vector2 units the kind of variable, on this case a Vector2, which has a x and y coordinate to carry the horizontal and vertical velocity respectively.
• = Vector2.ZERO provides the variable a default worth. Vector.ZERO is a continuing with a price of 0 for each x and y.

Offering a sort for variables is elective in Godot, this referred to as dynamic typing. Setting the sort whereas defining new variables such as you simply did is known as static typing. It is best to choose static typing over dynamic typing for a number of causes:

• It makes Godot’s compiler perceive what you’re tying to do higher, which ends up in higher autocompletion within the script editor.
• The code shall be extra readable because it’s clear what worth a variable can maintain. This in flip makes your code much less error-prone.
• You get an enormous efficiency enhance at no cost, as statically typed code runs between 25 and 100% quicker than its dynamic counterpart.

All variables all through this tutorial will use static typing to make it simpler to comply with alongside and study the different sorts.

Subsequent on the record is the motion velocity, which is the velocity at which the avatar will transfer horizontally in pixels per second. Not like the rate, it is best to be capable of tweak its worth through the inspector. Add the next line under extends Node2D so as to add a brand new move_speed variable:

@export var move_speed : float = 600.0

By including the @export annotation earlier than the variable declaration, it exposes the variable to the editor. That is extraordinarily helpful for shortly altering values to enhance the steadiness or really feel of your recreation. The move_speed variable is a float, which is brief for floating-point quantity. It may well retailer numerical values with decimal digits and is commonly used for positional calculations.

Save the script player_avatar script, be sure to’ve bought the PlayerAvatar node chosen within the Scene dock and try the Inspector on the correct. It is best to now see a brand new property named Transfer Velocity with the a price of 600.

I discovered 600 pixels per second to be a smart velocity, however you may change this worth as soon as the avatar can transfer to make the sport simpler or troublesome. Subsequent on the record is getting the participant to maneuver the mouse cursor.
For this to work, you’ll have to get the place of the cursor, test whether or not it’s left or proper from the avatar after which regulate the rate accordingly each body. To get the place of the mouse cursor, change the cross key phrase within the _process operate with this:

var mouse_pos : Vector2 = get_global_mouse_position()

This grabs the place of the cursor through the built-in get_global_mouse_position() operate, which returns a Vector2. To check if that is working, you may add the next print name under the road you simply added:

print(mouse_pos)

This may print the cursor place each body. Go forward and provides it a go by urgent F5 in your keyboard to run the scene. Transfer your mouse round a bit and also you’ll see the positions showing within the console.

Now you understand that’s working, take away the print line you added for testing functions and change it with the next to make the avatar transfer to the cursor:

Notice: If you happen to get an error saying “Blended use of tabs and areas for indentation” whereas copying any of the code snippets to your scripts, press CTRL/CMD + I in your keyboard whereas within the script editor. This may routinely repair any incorrect indentation. The rationale you would possibly get this error when copying snippets from an internet browser is as a result of they have an inclination to transform tabs to areas, whereas Godot expects tabs.

    var x_distance_to_cursor = mouse_pos.x - global_position.x # 1
    var cursor_right : bool = x_distance_to_cursor > 0 # 2

    if cursor_right: # 3
        velocity.x = move_speed
    else:
        velocity.x = -move_speed

    global_position += velocity * delta # 4

1. Calculate the gap to the cursor by subtracting the avatar’s X place from the cursor’s X place. For instance, if the avatar’s place is (X:10, Y:0) and the cursor’s place is (X:50, Y:0), the gap could be 40 pixels. Retailer this worth in a brand new variable named x_distance_to_cursor.
2. Verify if the cursor is true or left from the avatar by getting the gap calculated above and seeing if it’s a constructive or detrimental worth. A constructive worth means the cursor is to the correct. Retailer this in a boolean variable named cursor_right. A boolean has two attainable values: true or false.
3. That is an if-statement that adjustments the X-value of the velocity to the motion velocity if the cursor is to the correct, or to the detrimental motion velocity if the cursor is to the left. If-statements in GDScript comply with the identical guidelines as features, so something that applies to the assertion ought to be indented with a tab and the statements finish with a colon.
4. The global_position variable is a part of the Node2D class and shops the node’s place as a Vector2. The code applies the velocity to the avatar’s international place and multiplies it with delta to make it framerate-independent.

That was rather a lot to absorb directly! Your efforts are rewarded although, as you’ll see when operating the sport by urgent F5.

The avatar now easily follows your cursor! You might need observed slightly quirk although: whenever you transfer the cursor exterior of the borders of the window, the avatar follows and disappears off-screen. To repair this, you may get the rectangle that makes up the viewport, add a border to the perimeters and restrict the avatar’s horizontal motion inside.

The illustration above reveals the idea of a digital border that the avatar can’t cross with a pink coloration. To implement this in code, you want the dimension of the viewport, the border width and the avatar’s place. To get the viewport’s dimension, add this line to the _process operate, under mouse_pos:

var viewport_size : Vector2 = get_viewport_rect().dimension

This line will get the viewport’s rectangle, which is the place and dimension of the sport window, and extracts simply the dimension from it. This worth then will get saved in viewport_size.
For the border, you’re going so as to add one other exported variable, so you may tweak its worth within the Inspector. To do this, add the next to the highest of the script, proper under the move_speed variable declaration:

@export var viewport_border : float = 80.0

That is the width of the border in pixels. To truly restrict the avatar’s motion, regulate the velocity-changing if-statement in _process as follows:

    velocity.x = 0 # 1

    if cursor_right:
        if global_position.x < viewport_size.x - viewport_border: # 2
            velocity.x = move_speed
    else:
        if global_position.x > viewport_border: # 3
            velocity.x = -move_speed

Right here’s what this does:

1. Reset the horizontal velocity so the avatar doesn’t transfer if there’s no horizontal velocity utilized additional down.
2. If the avatar desires to maneuver to the correct, solely permit it if its place hasn’t handed the border on the correct. The border calculation takes the horizontal dimension of the window and subtracts the scale of the border from it.
3. This does the identical as above, however for shifting to the left. As a substitute of taking the scale of the viewport into consideration, you merely use the border dimension because the leftmost viewport place is 0.

With this added, run the sport once more and transfer your cursor exterior of the window. The avatar will now wait patiently at one of many borders.

With the horizontal motion completed, you’re now able to discover Godot’s sign system.

Alerts

A sign in Godot is a message emitted by a node when a sure occasion happens. Nodes can subscribe these indicators to do actions of their very own. Some built-in examples if indicators embrace:

• The urgent of a button
• A node getting into the viewport
• The collision of two areas
• A sound impact that completed taking part in

This a robust system that means that you can preserve your code versatile and loosely coupled, because the node emitting the sign doesn’t care about its subscribers.

To begin off, open the jumper scene within the scenes folder and add a brand new script to the Jumper node named jumper.gd. Like with the player_avatar script, be sure that to put it within the scripts folder.

After creating the script, it ought to be routinely opened within the script editor. Take away each the _ready and _process features, as you gained’t want them. Try to be left with simply this line:

extends AnimatedSprite2D

In distinction to the participant avatar’s Node2D, the foundation node kind for the jumper is an AnimatedSprite2D, which inherits from Node2D and provides assist for animations.
You’ll be utilizing a sign to detect when the avatar enters a jumper’s Area2D node. Alerts may be linked to a script both through the editor or through code, on this case through the editor makes probably the most sense. Choose the Area2D node within the Scene dock and open the Node tab subsequent to the Inspector tab.

You’ll now see a listing of indicators the chosen node helps.

Within the case of Area2D, this record is very large and filled with helpful sign to connect with. To detect when one other Area2D enters this one, you’ll want the area_entered sign, so double click on it to begin connecting it. This may present a dialog window with some choices for the connection.

By default, it would choose the foundation node, Jumper because the node to connect with. That is what you need, so there’s nothing to alter there.
Under that’s the Receiver Technique, that is the identify of the operate that shall be referred to as when the area_entered sign is emitted. The default worth, _on_area_2d_area_entered works tremendous on this case. Now click on the Join button to attach the sign, it will add the brand new operate to the jumper script.

Any more, each time one other Area2D enters the Jumper’s Area2D, this operate shall be referred to as. You’ll be able to inform the operate is related to a sign by the inexperienced “exit” image to the left of it. Clicking that reveals what indicators will name this operate.

To check if this truly works, change the cross key phrase with the road under:

print("Obtained hit!")

By now I’m certain you understand precisely what this does: printing textual content to the console, a programmer’s greatest good friend.
Save the script and open the sport scene in 2D mode. Now drag a number of situations of the jumper scene from the FileSystem dock onto the viewport, subsequent to the participant avatar.

What you simply did there may be referred to as instantiating scenes, which is utilizing a scene as a blueprint and creating situations of it in one other scene. This highly effective system means that you can create a scene as soon as, and use it wherever you want.
With the jumpers added, press F5 to play the challenge. Transfer the avatar in opposition to the jumpers and it is best to see messages popping up within the console as anticipated.

Now to make issues extra attention-grabbing, the next ought to occur when a jumper will get hit:

• Play a shatter sound
• Play a shatter animation
• Destroy the jumper on the finish of the animation

How do you do all of this? By scripting in fact! Open the jumper scene once more and swap to the script editor. To play a sound impact, you want a reference to an AudioStreamPlayer node first. If you happen to keep in mind, jumper occurs to have one named ShatterSound.

There are two methods so as to add a reference to a node in your scripts when working within the built-in script editor: the boring guide methodology or the superior speedy methodology. I’ll begin off with the primary one, which is including the next line under extends AnimatedSprite2D:

@onready var shatter_sound : AudioStreamPlayer2D = $"ShatterSound"

I like to recommend typing this one out your self in the event you haven’t been doing so already, to see how the auto completion helps you by itemizing all nodes within the scene when you get to the final half.

Right here’s a breakdown of this variable declaration:

• @onready is an annotation like @export. This makes it so the variable will get assigned when the node enters the node tree for the primary time. This would possibly ring a bell, as that’s the identical time because the _ready operate is known as you’ve seen earlier than. In essence, @onready means that you can write one-liners to create and assign a node to a variable.
• var shatter_sound declares a brand new variable.
• : AudioStreamPlayer2D specifies the kind of the variable as a AudioStreamPlayer2D.
• = $"ShatterSound" will get a reference to the node named ShatterSound. The greenback signal ($) is shorthand for the get_node() operate.

Now you understand what this line does, it’s time to study in regards to the extra thrilling approach so as to add a reference to a node.
Take away the road you simply added and begin dragging the ShatterSound node from the Scene dock into the script editor. Maintain CTRL/CMD earlier than releasing your mouse button to finish the drop. This may add a node reference routinely, how cool is that?

You’re now one of many few folks that find out about this arcane data, use this energy nicely!
With the reference to the AudioStreamPlayer arrange, now you can make it play its sound impact each time the avatar hits the jumper by changing the print name with this:

shatter_sound.play()

This calls the play operate on the AudioStreamPlayer, which is able to make a pleasant glass shattering sound. Save the script and run the challenge to provide it a strive. Every time the avatar passes over a jumper, it is best to hear the sound impact play.
If that’s working as anticipated, you may transfer on to taking part in the shatter animation, which is so simple as including this line under the road you simply added:

animation = "destroy"

As a result of Jumper is an AnimatedSprite2D node, it has a property referred to as animation, which units the present animation by its identify. If you choose the Jumper node and try the underside of the editor, you’ll see a listing of accessible animations. The default animation is aptly referred to as “default”, whereas the animation you’re setting right here is known as “destroy”.

As soon as once more, it’s time to check if that is working as anticipated, so play the challenge and check out shifting into the jumpers once more. The jumpers ought to now shatter when hit!

On to the precise self-destructing, which ought to occur after the animation finishes taking part in. There’s approach of realizing when the animation ends in the mean time, and when you may use some kind of timer, a way more elegant approach is by utilizing a sign. AnimationSprite2D has an animation_finished sign you may connect with, however connecting it through the editor now would lead to it being emitted continuously because the default animation is taking part in on a loop.

The answer is to attach the sign through code after beginning the destroy animation, as that ensures good timing and the operate is simply being referred to as as soon as. To begin off, create a brand new operate that you simply need to be referred to as by the sign to the top of the script:

func _destroy_animation_finished() -> void:
    queue_free()

As this operate isn’t meant for use exterior of the script, it begins with an underscore. It does one factor: name the queue_free() methodology, which queues up the Jumper node for removing from the node tree, successfully destroying it.
To attach the animation_finished sign to the _destroy_animation_finished operate, add the next line under animation = "destroy" within the _on_area_2d_area_entered operate:

animation_finished.join(_destroy_animation_finished)

This connects animation_finished to _destroy_animation_finished, similar to how you probably did it earlier than through the editor. The good thing about connecting indicators through code is that it makes it straightforward to “rewire” indicators simply by enhancing a number of variables and you’ll join and disconnect them everytime you please. All of this performs into the modular nature of working with Godot and its nodes.
Play the challenge as soon as once more to check if the jumpers disappear after their animation finishes.
There’s a small bug although which may not be apparent immediately: in the event you hit a jumper, transfer away and hit it once more earlier than the animation finishes, the sound impact will play a second time and also you’ll get an error. Right here’s what it says:

<code>jumper.gd:9 @ _on_area_2d_area_entered(): Sign 'animation_finished' is already related to given callable 'AnimatedSprite2D(jumper.gd)::_destroy_animation_finished' in that object.</code>

This error is thrown as a result of there was already a connection made on the animation_finished sign. In different phrases, the _on_area_2d_area_entered operate bought referred to as twice on the identical jumper, which is undesirable. To repair this, you may set a flag on the jumper that states whether or not the jumper is energetic or not. When inactive, it shouldn’t react to any collisions.
To implement this, add the next variable under extends AnimatedSprite2D:

var energetic : bool = true

This boolean will act because the flag and it begins as true, which means jumper shall be energetic out of the gate. Subsequent, change the code contained in the _on_area_2d_area_entered operate as follows to make use of the flag:

if energetic: # 1
    energetic = false # 2
    shatter_sound.play()
    animation = "destroy"
    animation_finished.join(_destroy_animation_finished)

Right here’s what this does:

1. An if-statement that checks if the jumper is energetic earlier than doing anything.
2. Set the energetic flag to false. This may stop the code being ran greater than as soon as.

You should definitely save the script when you’re completed. With this security test added, the script is bug-free and also you’re able to make the avatar bounce.

Bounce Utilizing Participant Enter

The aim of the sport shall be flying from jumper to jumper, so that you want a approach of propelling the avatar upwards. The primary bounce shall be carried out with a mouse click on, which suggests you want a way of studying the participant’s enter and act upon it.

Whilst you can arduous code mouse button polling, Godot has a helpful enter system that makes use of enter actions to deal with participant enter. Take a personality shifting ahead for instance, with out enter actions you’d have one thing like this:

if Enter.is_physical_key_pressed(KEY_W) || Enter.is_physical_key_pressed(KEY_UP) || Enter.get_joy_axis(0, JOY_AXIS_LEFT_Y) < 0:
    move_forward()

With enter actions, you may assign the W key, arrow up key and joystick up to an motion and test that:

if Enter.is_action_pressed("move_forward"):
    move_forward()

That’s a complete lot nicer, isn’t it? This lets you reassign keys and buttons tied to an motion from the editor and even throughout gameplay. You may as well assign a number of inputs to the identical motion.
So as to add an motion your self, first choose Venture ▸ Venture Settings… within the prime menu to open the challenge settings.

Now open the Enter Map by clicking the corresponding tab on the prime.

This the place you may outline new actions. Add a bounce motion by clicking the Add New Motion area, typing “bounce” adopted by clicking the Add button to its proper.

With the bounce motion added, you may add enter occasions to it by clicking the plus button subsequent to its identify. This opens the Occasion Configuration window. In right here, choose Mouse Buttons ▸ Left Mouse Button and click on the OK button on the backside to substantiate.

Again within the Enter Map, now you can see the bounce motion is tied to the left mouse button. Candy!

Go forward and shut the Venture Settings window. Now open the player_avatar script once more because it wants some additions to make the avatar bounce.
To begin with, add a brand new variable for the bounce velocity to the highest of the script, under viewport_border:

@export var jump_speed : float = 2500.0

That is the vertical velocity of the avatar when leaping, each time it jumps from the bottom or when it hits a jumper, that is the quantity of pixels per second it would journey at. To make use of it, add the next operate under the _process operate:

func _jump() -> void:
    velocity.y = -jump_speed

This _jump operate will change the Y velocity of the avatar to the worth of the bounce velocity you simply added, however detrimental. The worth must be negated as constructive Y means down in Godot, whereas detrimental Y means up.
To name _jump, add this operate above the operate you simply added:

func _process_input() -> void:
    if Enter.is_action_just_pressed("bounce"):
        _jump()

This operate calls upon the Enter class to test whether or not the bounce motion was simply pressed after which calls the _jump() operate if that’s the case. The is_action_just_pressed methodology checks for a single press, not a steady maintain, in contrast to is_action_pressed. To complete the operate chain, add this line on the finish of the _process operate:

_process_input()

This may name the _process_input operate each body, which in flip checks for any inputs. Whilst you may have put every little thing in _process, that makes it tougher to trace down the items of code and alter them afterward. Writing clear code is a talent in itself. :]
Time for one more check drive, press F5 to play the challenge and attempt to make the participant bounce.

I’d say that could be a profitable bounce. It’s extra like a rocket launch in the mean time, however that’s fixable!
The rationale why the avatar leaves the display and by no means returns is as a result of there’s no gravity utilized to it. What goes up should come down in spite of everything. Add a brand new variable under jump_speed named gravity:

@export var gravity : float = 4000.0

It is a downward pressure that shall be utilized to the avatar. To use it each body, add this line to _process, proper under velocity.x = 0:

velocity.y += delta * gravity

This may push the avatar down constantly, simulating gravity. Run the challenge once more to see if this improves the leaping. You’ll discover the avatar falls down immediately and retains falling, except you click on at times to bounce it again up.

This concludes the primary a part of the tutorial, what a cliffhanger! Or is it cliff-faller on this case? :]
Don’t fear, within the second a part of this tutorial you’ll assist the poor avatar out so it doesn’t have to leap on a regular basis to forestall falling the countless abyss.

The place to Go From Right here?

Thanks for studying this primary a part of the tutorial! You’ll be able to obtain the challenge recordsdata utilizing the hyperlink on the prime and backside of this web page.
Within the second a part of this tutorial, you’ll learn to use a finite state machine to neatly handle the avatar’s state, instantiate scenes utilizing code, make the digital camera comply with the avatar and way more! On the finish, you’ll have a small recreation to construct upon additional.

We hope you loved this primary a part of the tutorial. Depart a remark under or be a part of the discussion board dialogue to share your ideas and ask any questions you might need!