Master Godot 4: Craft a Survivors Roguelite with GDScript

This video demonstrates setting up a tile map background in the game world using Godot 4.41's TileMapLayer. We create a Grass layer with a terrain set for light grass tiles, configure bit masks for automatic tiling, and add a Dirt layer with shared tile set resources. We draw a two-tile-wide dirt path over the grass, leveraging layer transparency for seamless integration, enhancing the scene's visual appeal.

This video covers adding tree props to the game level using the Pixel Crawler Pack. We create a Tree scene with a Sprite2D and Atlas texture, offset it for proper Y-sorting, and organize trees under a Props node. We also create an inherited Tree Autumn scene, ensure unique textures, and group trees into Tree Blocks for efficient duplication. We adjust Z-index for ground tiles, add a follow camera, and tweak tree positions to avoid roads, enhancing the scene's visual appeal.

This video demonstrates how to enhance the game scene using stump props from the Pixel Crawler Pack. We create a Stump scene with a sprite2D, set its texture and offset for proper Y-sorting, and organize stumps under parent nodes (Stump Blocks) for easier management. We address Y-sorting issues for trees and stumps, adjust sprite offsets, and reposition misplaced props to avoid roads, ensuring a visually appealing and functional level design.

This video sets up an auto-firing weapon system for a Survivors-like game. We create a Weapon2D script with a timer to spawn projectiles, a WeaponDefinition resource for weapon stats (name, icon, cooldown), and a Projectile script for the spear with a sprite. The weapon instantiates spears in a Projectiles group node, sets their position, and fires them rightward every second, laying the foundation for further projectile movement and stats.

This video focuses on implementing projectile movement for the spear in the game. We add a launch function to set the projectile’s direction, ensure it moves using physics_process with a defined speed, and set it to auto-free after one second to prevent performance issues. We also add an assertion to ensure the direction is set before adding the projectile to the scene, refining the weapon2d script to call launch properly for consistent movement.

In this video, we create an Orc enemy, setting up its sprite, animations (idle, run, death), and collision shapes. We establish a hitbox for the spear projectile and a hurtbox for the Orc to enable damage detection, connecting signals to track hits. We also address project warnings by underscoring unused parameters and organize the enemy in a dedicated folder.

This video implements a damage system for orc enemies. We enhance the Projectile script to connect to Hitbox2D's hit signal, passing damage to the Hurtbox2D via a try_deal_damage method. A StatController node manages NPC stats (HP, max HP, alive status), ensuring damage reduces HP correctly. The Hurtbox2D checks invincibility via can_be_hit and applies damage, with debugging confirming HP updates from 100 to 90 on hit.

This video sets up a simple enemy state machine using LimboHSM for an orc NPC. We create EnemyHSM, ChaseState, and DeathState scripts, binding the animation player to a blackboard plan. The chase state plays the run animation, while the death state plays the death animation, sets the NPC as unalive, and frees it upon completion. Transitions occur when the NPC's HP hits zero, triggering an alive_changed signal.

This video enhances the weapon system by adding a WeaponsLoadout script to manage multiple weapons under the player node. We parent the SpearWeapon to WeaponsLoadout, ensuring it accesses player input via a helper function get_facing to retrieve the facing direction. In Weapon2D, we rotate instantiated spears to match the facing direction using radians, adjusted by π/2 for correct orientation, ensuring accurate projectile aiming and rotation.

Add sound effects for projectile launches and enemy deaths using AudioStreamPlayer2D nodes. Implement a death sound for orcs via the animation player and add looping background music to the game world, with volume adjustments for balance.

Set up a combat system in Godot 4 for floating combat text. This video covers creating a singleton combat system, configuring it as an autoload, and connecting it to the hurtbox to report damage. Learn how to build the foundation for displaying damage in your action game.

Create and animate floating combat text in Godot 4. This video walks through setting up a UI scene with a label and animation player, scripting the text behavior, and animating position, scale, color, and transparency with keyframes for dynamic damage visuals.

Learn to make enemies chase the player in Godot 4 using a player context resource. This tutorial covers creating a resource to track the player, scripting chase state logic for orcs, and configuring collision layers to prevent enemy stacking, enhancing gameplay flow. (Duration: ~15 minutes)

This guide details the creation of a spawning system for a survivor-style game. A spawner node is added to the game world, with a script (spawner_system.gd) managing customizable properties: spawn margin (minimum distance in pixels), extra range (additional spawn distance), spawn frequency (a curve controlling spawn intervals), and spawn definitions (resource-based enemy types with weights). A dictionary tracks runtime stats, linking each spawn definition to its spawn count and last spawn time. The system initializes by creating stats for each definition, updates elapsed time, and uses a curve to adjust spawn frequency dynamically, increasing difficulty over time. A basic setup spawns enemies at the scene's origin, with the frequency curve tested to show accelerating spawns.

Learn how to spawn enemies or objects just outside the player's visible area for a polished, professional gameplay experience. In this lesson, we’ll calculate accurate spawn positions based on the camera’s viewport, apply randomization to vary direction, and avoid awkward instantiation on screen. Ideal for dynamic 2D games that need immersive enemy behavior and polished visual flow.

In this lesson, we expand our spawner system with:

• A new skeleton enemy and animation setup

• Weighted random spawning for varied enemy types

• Time-based unlocks to control when enemies appear

By the end, you'll have a dynamic system that spawns enemies off-screen, scales difficulty, and sets the stage for more advanced enemy behavior.

Build a combat system in Godot by adding a player hurtbox and enemy hitbox for damage on contact. We’ll configure nodes, collision layers, script damage logic, and fix a bug where dead enemies deal damage. By the end, your player will safely take damage only from living enemies.

Learn to enhance your Godot combat system with an invincibility timer to protect the player and custom stat definitions for characters. We’ll create a stat resource, apply it to the player and enemies, and implement damage logic with testing.

Enhance your Godot combat system by adding periodic damage to enemy hitboxes. We’ll script a timer to repeatedly damage the player during contact, apply it to Ork and Skeleton enemies, and test the results.

Learn to create a PlayerDefeatedState, set up a GameManager singleton for game over logic, and configure hierarchical state machine (HSM) transitions to trigger the death state when HP reaches zero. Explore why player removal requires null checks to prevent enemy errors, setting the stage for testing and refinement.

Test the player defeat system and refine enemy behavior. Learn to integrate player stats, fix errors with null checks, and add an enemy idle state for realistic behavior after defeat.

Learn how to create experience point pickups in a 2D game. This tutorial covers setting up a Pickup2D scene, scripting a base pickup system with a try_take function, and configuring collision layers and animated sprites for visual polish. Follow step-by-step instructions to enable players to collect XP and level up, with tips for extending the system for other pickup types like weapons or upgrades.

Discover how to create an experience pickup system using scene inheritance. This tutorial guides you through extending the Pickup2D scene to create an EXPPickup2D, implementing a custom try_take function, and managing experience points in the stat controller. Learn to set up reusable functions, handle collision detection, and prepare for level-up mechanics with clear, practical steps.

Learn to create a Collector2D node to enable players to gather experience pickups in a 2D game. This tutorial covers adding an Area2D node, scripting pickup detection, and integrating with the player’s stat controller. Additionally, it addresses fixing animation alignment issues by adjusting sprite frame positions for smooth transitions between idle, run, and death animations.

Learn how to implement enemy drop mechanics in your 2D game, enabling enemies to drop items like EXP gems upon defeat. This tutorial covers resizing pickups for consistent visuals, creating a drop system with weighted randomization, and integrating it into the game world using nodes and scripts. Follow step-by-step instructions to set up a flexible drop definition resource and ensure items spawn correctly in your game.

Discover how to create random item drop positions to avoid overlapping in your game. This tutorial guides you through coding a function to spawn items within a set distance using vector calculations. Learn to implement, test, and refine the solution for natural item placement, enhancing gameplay visuals.

Learn how to add a pickup gravity area to attract items toward the player, enhancing gameplay flow. This tutorial covers creating an Area2D node, setting up collision layers, and coding a script to move items dynamically with a customizable gravity curve for realistic motion. Perfect for streamlining item collection in your game.

Learn to create a clean and functional player UI featuring HP and EXP progress bars. This tutorial covers setting up a panel container, organizing UI elements with VBox and HBox containers, and customizing progress bar textures with a pixel art style. Discover how to use a canvas layer for independent UI rendering and adjust scaling for optimal display.

Learn to create a dynamic UI for player stats in a game, focusing on canvas layer setup and signal-based stat updates. This video covers scripting a canvas layer for automatic visibility, building a StatChangedData class for stat encapsulation, and setting up signals for HP, max HP, and experience changes. Follow clear steps to connect player stats to UI elements efficiently.

Learn to connect player stats to a dynamic UI by scripting HP and EXP displays. This video covers creating modular scripts for UI components, linking signals to update progress bars and labels, and debugging common issues like integer division. Follow step-by-step instructions to build reusable, scene-based UI displays for efficient game development.

Learn to resolve common console warnings and errors in a game development project. This video covers fixing issues in pickup scripts by implementing a guard system to prevent duplicate pickups, optimizing function signatures, and addressing unused parameters and naming conflicts in UI and spawner scripts. Follow practical steps to clean up code for a robust, error-free game.

Learn how to create a leveling system for a 2D game, focusing on managing experience points, level progression, and stat upgrades. This video covers setting up a stats controller, creating a level definition resource, handling level-up logic, and updating the UI to display experience progress. Follow step-by-step coding to integrate a functional leveling mechanic into your game, with tips on organizing scripts and avoiding common errors.

This tutorial covers the initial steps for a roguelike level-up system. Learn to adjust XP thresholds for player leveling, define multiple level requirements, and connect signals to trigger a level-up UI. Follow along to create a control node for the UI, set up a script to handle level-up events, pause the game during selections, and ensure proper UI visibility, with clear steps for your game project.

Learn to create a level up UI with animated text. This tutorial guides you through setting up a panel container, adding margin and VBox containers, and using rich text labels with BBCode for rainbow and wave effects. Perfect for designing engaging UI elements for player progression.

Learn to create a reward selection UI for a level up system. This tutorial covers setting up horizontal and vertical containers, adding rich text labels, icons, descriptions, and buttons, plus scaling, centering, and basic scripting.

Learn how to implement a weapon leveling system in your game to enhance player progression. This tutorial covers setting up a weapon level resource, defining upgrade stats like damage, cooldown, and projectile count, and integrating these into a weapon definition script. Follow along to create a scalable system for upgrading weapons at different levels, ensuring each level feels rewarding.

Learn how to create weapon item resources to support leveling up active Weapon2D nodes in your game. This tutorial covers building a leveling options resource, setting up an item class, and implementing weapon item logic to apply upgrades to a player’s loadout. Understand how to link weapon definitions for effective progression.

Learn how to implement a weighted item selection system for level-up rewards in your game. This tutorial covers setting up a leveling options script, creating a dictionary for weighted items, and coding a rewards box container to dynamically populate UI with random, weighted selections. Understand how to filter valid items, calculate total weights, and ensure unique reward choices for a polished player experience.

Learn to code a reward selection system for game leveling, emphasizing signal propagation for seamless player choice handling. This tutorial covers scripting item population, managing signals to apply item effects, and debugging the logic. Assumes prior UI setup knowledge.

Discover how to apply weapon level stats to projectile spawning and instances in your game. This video walks you through coding projectile behavior to use level-specific stats like speed, random damage, max hits, spawn offsets, and delays. Learn to pass weapon level parameters, manage projectile duration, and implement multiple projectile spawning with practical testing and debugging steps for a polished weapon system.

Learn how to implement a scythe weapon with unique rotation mechanics in your game. This video covers duplicating an existing spear weapon scene, modifying the sprite and hitbox, and adding a rotator node with a script to handle circular motion. Set up the scythe’s weapon definition, levels, and integration into the player’s loadout for dynamic gameplay. Ideal for game developers enhancing their game with varied weapon behaviors.

Learn how to build a weapons display UI for your game’s inventory system. This video guides you through creating a UI scene with a panel container, margin container, and HBox container to display equipped weapons and their levels. Follow step-by-step instructions to set up a weapons view, add icons and level indicators, and connect the UI to the player context using scripts. Perfect for game developers looking to enhance their game’s user interface with dynamic weapon displays.

Learn how to connect signals and set up a weapons UI in a 2D game. This video covers creating and emitting signals for weapon changes, updating the UI to reflect the current loadout, and configuring item definitions for weapons like the scythe and spear. Discover how to debug projectile behavior using a test scene and fine-tune UI elements like icons, text size, and margins for a polished in-game display.

Learn how to implement a stat-boosting items to enhance player attributes like HP in your game. This tutorial covers creating a flexible stat boost item class, handling multiple stat changes, and integrating it into a level-up system using a dictionary for efficient stat management. Follow along to add dynamic upgrades with clear code examples and practical testing.

Learn how to create an HP Boost pickup in Godot, enabling players to walk over and instantly apply item effects in the game world. This tutorial covers duplicating scenes, modifying sprites, scripting pickups, and integrating them into the game. Additionally, fix player level up selection UI for consistent scaling and icon sizes, ensuring a polished upgrade system. 

Learn how to implement a health potion pickup in your 2D game, including duplicating an existing item, customizing its properties to restore 25 HP, and setting up enemies to drop it with weighted probabilities. This step-by-step guide covers scene setup, icon selection, and drop mechanics for seamless integration into your game world.

Learn how to add a dynamic camera shake effect to enhance the intensity of player hit and death events in your 2D game. This tutorial covers attaching a script to the Camera2D node, setting up variables for shake strength and duration, connecting to the player’s health signals, and calculating shake intensity based on damage taken. Follow along to create a polished, immersive experience with smooth transitions back to the original camera position.

Learn how to implement a Game Over screen in your 2D game, triggered when the player is defeated. This tutorial guides you through setting up a centered UI panel with a title, icon, description, and a Main Menu button. You'll create a script to display the screen based on the player’s alive status and configure a scene change button for seamless navigation to a Main Menu scene.

Learn how to add a high score system to your game by tracking enemy defeats and player survival time. This tutorial covers creating a game stats manager, implementing signals for real-time updates, and building a UI to display stats like enemies defeated and time survived. Follow step-by-step instructions to set up a singleton game manager, reset stats on new games, and format UI elements for clarity. Perfect for developers looking to enhance gameplay with persistent stat tracking.

Learn to create a save and load system for high scores using JSON. This tutorial covers building a save-load component within a game manager, serializing game stats (enemy defeats and survival time) to a JSON file, and loading them for persistent data. Understand file operations, dictionary conversions, and high score comparisons. Ideal for game developers seeking to implement data persistence effectively.

Learn how to build a main menu for a 2D game, including a high scores display and a start game button. This video guides you through setting up UI elements like margin containers, Vbox layouts, and rich text labels with BB code for visual effects. Discover how to save high scores to a JSON file, create a custom background using a screenshot, and configure scene transitions for a seamless game start experience.

Enhance your 2D game prototype with this guide on polishing key elements. Learn to debug errors in item pickups, adjust UI layouts for better readability, and balance gameplay by tweaking enemy spawn rates, movement speeds, and weapon stats. Discover how to add audio effects for level-ups and loop background music to improve the player experience, ensuring a refined and engaging game demo.

In this bonus video, we explore MultiMeshInstance2D - a powerful technique for rendering thousands of enemies, projectiles, and objects without tanking your frame rate.

Learn why traditional Sprite2D + AnimationPlayer setups hit a wall at ~5K characters, and how GPU-based batch rendering can push your survivor-like games to the next level.

What you'll learn:

- Why node-based rendering bottlenecks at scale

- How MultiMeshInstance2D uses shaders for efficient GPU rendering

- When to use this vs traditional approaches

- Brief intro to ECS (Entity Component Systems) concepts

- Setting up benchmarks to measure real performance gains

Creating a Benchmark World Scene as the starting point for measuring our performance gains