Godot 4 2D Game Dev: Build 3 Games with GDScript

We overview what we want from our game and what concepts we will cover.

In this lecture we will learn how to set up a new Godot project from scratch.

Let's learn about nodes and scenes in Godot and how they form the foundation of every project.

In this lecture we will dive into the physics system of Godot and learn how it works.

Let's learn how to instance a scene so that we can reuse our scenes throughout the project.

In this lecture we will explore the scene tree and learn how Godot organizes all nodes at runtime.

Let's learn how the 2D coordinate system works in Godot and how to position objects in 2D space.

In this lecture we will learn about parent and child nodes and how they relate to each other in the scene hierarchy.

Let's learn how draw order and Z index work in Godot to control which nodes appear in front of others.

In this lecture we will write our first GDScript and learn the basics of scripting in Godot.

Let's learn how to print strings to the output console, a fundamental skill for debugging in Godot.

In this lecture we will learn about variables and the different data types available in GDScript.

Let's learn how to specify data types for our variables to write cleaner and more reliable GDScript code.

In this lecture we will learn how to perform number operations such as addition, subtraction, multiplication, and division in GDScript.

Let's learn about operator precedence and how Godot evaluates mathematical expressions in our scripts.

In this lecture we will learn about the Vector2 type and how to use apply_impulse to move physics objects.

Let's learn how to create and call functions in GDScript to organize and reuse our code.

In this lecture we will learn how to pass parameters into functions to make them more flexible and reusable.

Let's learn how to return values from functions so we can use the results of our calculations elsewhere in our code.

In this lecture we will learn how to generate random numbers in GDScript to add variety to our game.

Let's learn about the process function and how to use it to run code every frame in Godot.

In this lecture we will learn how to use if statements and comparison operators to make decisions in our code.

Let's learn how to handle player input and implement player movement in Godot.

In this lecture we will learn about variable scope and how it determines where variables can be accessed in our scripts.

Let's learn how to use Camera2D to follow the player and how physics materials affect object behavior.

In this lecture we will learn how to use StaticBody2D and create polygon collision shapes for our game objects.

Let's learn how signals and Area2D work in Godot so we can detect and respond to overlapping objects.

In this lecture we will learn how to use groups to organize nodes and how to properly free nodes from the scene.

Let's learn how to add sounds and manage audio references in Godot to bring our game to life.

In this lecture we will learn how to create particle systems in Godot to add visual effects to our game.

Let's learn how to set up planets in our game and add UI labels to display information on screen.

In this lecture we will learn how to export our Godot project so it can be shared and played outside the editor.

Wrapping up the Asteroid Attack section with some final thoughts.

We overview what we want from our game and what concepts we will cover.

In this lecture we will learn how to set up a new Godot project from scratch.

Let's learn how to use CharacterBody2D to create a physics-based player character in Godot.

In this lecture we will learn how to read axis input in Godot to move our player along both horizontal and vertical directions.

Let's learn how to limit the player's position so they cannot move outside the boundaries of the game screen.

In this lecture we will learn how to use else if statements to handle multiple conditions in our GDScript code.

Let's learn how to use clamping in Godot to restrict values within a minimum and maximum range.

In this lecture we will learn how to use the AnimationPlayer node to create and control animations in Godot.

Let's learn how to create classes in GDScript to better organize and structure our game code.

In this lecture we will learn about inheritance in GDScript and how to extend classes to share and reuse functionality.

Let's learn how to create a projectile scene and implement its movement so it travels across the screen.

In this lecture we will learn about delta time and how to use it to make movement frame-rate independent.

Let's learn how to use AnimatedSprite2D to play sprite sheet animations on our game objects.

In this lecture we will learn how to detect one-time input so actions are triggered only once per key press.

Let's learn how to create custom signals in Godot to communicate between nodes in a clean and decoupled way.

In this lecture we will learn how to instance scenes directly from code so we can dynamically spawn objects at runtime.

Let's learn how to use VisibleOnScreenNotifier2D to detect when a node enters or leaves the screen.

In this lecture we will learn how to call a function directly from an animation using the AnimationPlayer node.

Let's learn how to create an enemy scene and implement enemy movement in our game.

In this lecture we will learn how to animate multiple textures on a single sprite to create more dynamic visual effects.

Let's learn how to create an enemy spawn timer so that enemies appear at regular intervals during gameplay.

In this lecture we will learn how to use arrays in GDScript to store and manage collections of data.

Let's learn how to pass parameters through signals so we can send data along with our signal emissions.

In this lecture we will learn how to add difficulty scaling to our game so it becomes more challenging over time.

Let's learn how to use class_name to define named classes and the is operator to check an object's type in GDScript.

In this lecture we will learn how to handle enemy death by playing effects and removing the enemy from the scene.

Let's learn how to implement a hit state for our projectile so it reacts properly when it collides with an enemy.

In this lecture we will learn how to handle player death and trigger the appropriate effects and game state changes.

Let's learn how to implement a respawn timer so the player returns to the game after a short delay.

In this lecture we will learn how to implement an invincibility period for the player after taking damage.

Let's learn how to build a score system that tracks and updates the player's score during gameplay.

In this lecture we will learn how to create a score UI so the player's current score is displayed on screen.

Let's learn how to create a lives UI so the player can see how many lives they have remaining.

In this lecture we will learn how to create a game over screen that appears when the player runs out of lives.

Let's learn how to use the await keyword in GDScript to pause execution until a signal or condition is met.

In this lecture we will learn how to create a parallax background to give our game a sense of depth and motion.

Let's learn how to add background music and sound effects to bring the audio of our game to life.

Wrapping up the Galaxy Guardian section with some final thoughts.

We overview what we want from our game and what concepts we will cover.

In this lecture we will learn how to set up a new Godot project from scratch.

Let's learn how to use sprite sheet animations to bring our characters and objects to life in Godot.

In this lecture we will learn how to implement gravity and jumping so our player can move naturally in a 2D platformer.

Let's learn how to handle running and stopping so our player character moves and decelerates smoothly.

In this lecture we will learn about logical operators and how to combine conditions in our GDScript code.

Let's learn how to update our animations based on the player's current state so the correct animation always plays.

In this lecture we will learn how to implement a double jump so the player can jump a second time while in the air.

Let's learn how to create a tile set in Godot so we can build reusable tile-based levels.

In this lecture we will learn how to use the tile map to design and lay out levels using our tile set.

Let's learn how to create a dust effect particle system that plays when the player lands or moves.

In this lecture we will learn how to use autoloads in Godot to create globally accessible scripts and nodes.

Let's learn how to create a laser projectile scene and implement its movement across the screen.

In this lecture we will learn how to allow the player to shoot once per input press without holding the button.

Let's learn how to calculate the launch position and direction of a projectile so it fires correctly from the player.

In this lecture we will learn how to implement continuous shooting so the player can fire repeatedly while holding the input.

Let's learn how to create a walking enemy that moves back and forth across platforms in our game.

In this lecture we will learn how to use RayCast2D to detect objects and surfaces in the direction we choose.

Let's learn how to use collision layers and masks in Godot to control which objects interact with each other.

In this lecture we will learn how to set up a hit box on our enemy to detect when the player's attacks connect.

Let's learn how to set up a hurt box on our player to detect when the player has been hit by an enemy.

In this lecture we will learn how to implement an invincibility period so the player cannot be damaged repeatedly in quick succession.

Let's learn how to create a player hurt state so the player reacts visually and mechanically when taking damage.

In this lecture we will learn how to implement damage over time so the player loses health gradually from certain hazards.

Let's learn how to add hit and explosion effects that play when projectiles or enemies are destroyed.

In this lecture we will learn how to use RemoteTransform2D to control another node's position without parenting it directly.

Let's learn how to create a health bar UI that visually reflects the player's current health at all times.

In this lecture we will learn how to display the player's HP on the HUD so it updates in real time during gameplay.

Let's learn how to create a flying enemy that moves through the air and poses a threat to the player.

In this lecture we will learn how to implement smooth flying movement for our airborne enemy.

Let's learn how to make our enemy shoot projectiles at the player to increase the challenge of our game.

In this lecture we will learn how to create a fireball projectile that the enemy can launch toward the player.

Let's learn how to make our enemy shoot multiple fireballs so the player must dodge a spread of projectiles.

In this lecture we will learn how to create collectable items that the player can pick up throughout the level.

Let's learn how to use the match statement in GDScript as a cleaner alternative to long chains of if else conditions.

In this lecture we will learn how to create gun and double jump power-up items that grant the player new abilities.

Let's learn how to add item pickup visual effects so collecting items feels satisfying and responsive.

In this lecture we will learn how to display collected items on the HUD so the player can track what they have picked up.

Let's learn how to implement a player respawn system so the player returns to a set position after dying.

In this lecture we will learn how to create hazards in our level that damage the player on contact.

Let's learn how to implement one way collision so the player can jump up through platforms and land on top of them.

In this lecture we will learn how to create a template level that can be used as a starting point for designing new stages.

Let's learn how to change scenes in Godot so we can transition the player between different levels and screens.

In this lecture we will learn how to create a win screen that appears when the player successfully completes the game.

Let's learn how to build a start menu so the player has a proper entry point before jumping into the game.

In this lecture we will learn how to use tweens and a fader to create smooth transitions between scenes.

Let's learn how to use the await keyword with function calls to pause execution until an asynchronous operation has completed.

In this lecture we will learn how to temporarily immobilize the player during cutscenes or special game events.

Let's learn how to add background music to our game and manage it through an autoload so it persists across scenes.

In this lecture we will learn how to use dictionaries in GDScript to store and retrieve data using key-value pairs.

Let's learn how to use the for loop in GDScript to iterate over arrays and ranges to repeat actions efficiently.

In this lecture we will learn how to apply good level design principles to build an engaging and well-structured game level.

Let's learn how to export our Godot project so it can be shared and played outside the editor.

Wrapping up the Cosmic Cadet section with some final thoughts.