Godot 2D Academy: Create a Brotato style game with Godot 4

Explore Godot 4.5 beta updates, including tile map chunk colliders, 3D bone constraints, abstract classes in GDScript, improved import and rendering, and debugging enhancements with GitHub tickets for details.

Discover the Godot 4.5 official release with stencil buffer masking, screen reader support, shader baker, internationalization live preview, and improved 2D tile map physics and deep copies.

Explore Godot 4.6 dev updates across dev 1–5, including drag-and-drop export variables, an object profiler, a new default theme, and game speed controls for testing.

Explore the Godot 4.6 stable release, highlighting quality-of-life improvements like draggable windows, scene-based tile placement, visible margin sizes, and the default Jolt physics engine for 3D.

Create a reusable unit base for players and enemies, configure movement, health, damage, and wave-based stats with unit stats, and instantiate player variants by inheriting from the base scene.

Create a new Godot 4 project for Brotato-style game, import assets, and configure input actions for move left, right, up, down, and dash using a 1920x1080 viewport with canvas items.

Develop a base unit scene in Godot 4 to support a Brotato-style game, enabling player and enemy to share health components, visuals, and animations for idle, move, and die.

Create a Godot 4 player scene with a sprite, circle collision, and a Player class inheriting from Unit. Implement movement input, velocity, and idle/move animations with rotation and shadow adjustments.

Add dash mechanics to the player in godot 4 by using timers (dash timer and cooldown timer), exporting dash duration and speed, and disabling collision via set_deferred during the dash.

Define a unit stats resource with player and enemy types, including health, damage, speed, luck, and icon, then configure a well-rounded player and link stats to entities.

Create a dash trail in Godot 4 by drawing a Line2D from the player's past positions, updating a points array, and rendering the trail behind the player for a duration.

Create all players by inheriting from a base well-rounded scene, swapping sprites and stats. Define unit stats resources, set health, speed, luck, blockchains, and assign gold drops.

Build an arena in Godot 4, set up a clamped player position and a following camera using a global autoload to share the player reference.

Learn to fix a collision setup by using area 2D as the parent for collision shapes, updating player and enemy scenes, and saving changes to enable proper collision detection.

This introduction shows how to create an enemy system from a base scene, build chasers and shooters with hitbox, health components, a health bar, and floating damage text.

Create enemy scenes by inheriting from the base unit in Godot 4, add a vision area with area2D, and configure stats via a unit stats resource.

Create an enemy chaser in Godot 4 that follows the player while avoiding nearby enemies using a flock push, a 60 unit distance threshold, vision area, and rotation handling.

Create a hitbox component to manage damage, critical hits, and knockback, enable and disable monitoring and monitorable properties, wire it into entities, and use area enter signals and collision layers.

Create a health component with signals for unit hit, unit die, and health changed, including setup, take damage, heal, and die behaviors, integrated with unit stats.

Create a Godot 4 health bar user interface with a progress bar, custom colors, and a health text label; update the bar on health changes for the player and enemies.

Add a flash effect by switching the sprite to a white shader material for 0.2 seconds, then revert to the default material using a timer activated on damage.

Implement a block chance system in a Brotato-style game with Godot 4 by using a global get_chance_success function to compare a 0–1 random value against a block chance, blocking attacks.

Create a configurable floating text system in Godot 4 to display damage numbers, block attack indicators, and health regeneration, using tweens, random rotations, and signals to spawn text above units.

Configure and implement melee weapons in a Godot 4 project by building weapon base scenes, tiered items, and data-driven stats, enabling rotation toward the nearest target, melee attack, and knockback.

Create a reusable item system in Godot 4 with an item base, weapon stats, and tiered upgrades for weapons and passives, including four punch weapon levels and resources.

Create a weapon scene from a base with a range area, circle collision, and cooldown timer; add a weapon punch and a weapon class to store item weapon data.

Create a weapon container in Godot 4 to position up to six weapons around the player using marker 2D nodes, count-based references, and an update function.

Equip weapons by instantiating weapon instances from the weapon container, storing them in current weapons, and updating each weapon's position and setup data for collisions with players and enemies.

Determine the closest target by comparing distances to each enemy and rotate the weapon toward that target, accounting for idle rotation, facing direction, and weapon spread during attacks.

Create a reusable weapon behavior system in Godot 4, with a base weapon behavior and melee and range behaviors, enabling damage calculation and critical hits.

Implement knockback for enemies in Godot 4 by applying a directional push based on the player's punch, managing knockback power with a timer, and resetting after impact.

Complete the remaining melee weapons by creating four tiers (common to legendary), inheriting from the weapon base, and setting up scenes, sprites, hitboxes, collisions, and related punch and stat resources.

Review all melee weapons, inspecting axe, chainsaw, mace, sword, punch, and wand scenes with hitboxes, collisions, weapon behavior, and references; note labels from common, rare, epic, and legendary.

Create range weapons, configure their behavior, implement a new range attack system, and manage projectiles for pistol, laser, revolver, SMG, and shotgun to shoot and rotate.

Configure range behavior by creating a pistol weapon, implementing range attack with a projectile, and animating recoil via a tween, while updating visuals based on facing left or right.

Create a pistol projectile in Godot 4 by building a 2D scene with sprite and hitbox, configuring velocity, damage, critical, and knockback, and destroy on viewport exit.

Configure a four-tier pistol with labeled items, rare to legendary tiers, and set damage, accuracy, cooldown, range, and recoil stats across levels using references.

Create multiple projectile types by inheriting from the base projectile pistol in Godot 4, adding laser, shotgun, SMG, and revolver variants with sprites and collisions, saved in the projectiles folder.

Learn to create and configure range weapons in a Godot 4 2D Brotato-style game, including pistol, laser, revolver, shotgun, and SMG, using inherited weapon scenes, muzzle markers, and projectiles.

Review range weapons in a Brotato-style Godot 4 game, examining revolver, pistol, SMG, shotgun, and laser configurations, scenes, and projectile references, and download the complete project in the next lecture.

Explore two enemy attack behaviors in Godot 4: a charging foe that follows and collides with the player, and a shooter that fires projectiles with an arc angle and cooldown.

Create a charge attack behavior for a charger in Godot 4, wiring a charge behavior class and animation player with prep time and cooldown controlling the charge.

Create a shooting behavior for an enemy shooter in Godot 4, enabling multi-projectile shots with arc angle, projectile count, and cooldown, using a fire position and player direction.

Create a spawner driven by wave data for waves 1–5, supporting fixed or random spawn every 0.5 seconds and weighted enemy selection, with per-wave updates to health and damage.

Create a weighted random spawner using wave data and wave unit data resources. Configure fixed or random spawn timing, wave time, and per-enemy weights, plus a get random unit function.

Learn to implement a spawner in Godot 4 by using a wave data resource to spawn enemies in an arena, with fixed and random timer options.

Complete waves in a Brotato-style game using Godot 4, showing current wave and time left, spawning enemies at random positions, and updating enemies' health and damage per wave.

Implement a destroy enemy function to stop movement, play die animation, await its completion, and remove enemies from the arena by clearing the spawn enemies array on wave timer timeout.

Add a global pause flag to halt all activity when a panel appears, setting global.gamePause to true as the wave timer reaches zero.

Create an upgrade panel that appears after each wave, showing four random upgrades to apply to the player, while displaying current wave, lag, and rarity chances (common to legendary).

Create a stats container panel for the upgrade and shop interfaces in Godot 4, building an eight-stat layout with labeled health, damage, lifesteal, and more.

Add three new stats—HP region, lifesteal, and harvesting—to the player, and update the stats container to reflect health, damage, luck, speed, block, and harvesting in real time.

Create an upgrade card panel in Godot 4, including an icon, upgrade name, value, and a select button, stored in a reusable scene with custom button and common styles.

Create and arrange the upgrade panel in Godot 4 using margin and box containers with upgrade card instances, and center the 'wave completed' label with a large font.

Create an item upgrade class inheriting from item base, export value and description, start id, and apply upgrades to player stats; test upgrades include block, damage, health, lifesteal, luck.

Load upgrades in Godot 4 by instantiating upgrade cards and binding them to item upgrades. Populate four random upgrades in the upgrade panel from the upgrade list.

Continue waves in Godot 4 by showing the upgrade panel after each wave, enabling upgrade selection and application to player stats, then start a new wave with health reset.

Implement HP regen using a timer that autostarts every three seconds, healing the player when health is below max and displaying a floating heal text in the arena.

Create a Brotato-style upgrade system in Godot 4, adding two common, two rare, one epic, and one legendary upgrade per stat (block, damage, harvesting). Match stat IDs and balance resources.

implement a tier-based upgrade probability dictionary in the upgrade panel to select common, rare, epic, and legendary items by current wave and tier.

selects four items for offer from upgrade and shop pools based on the current wave and tears, using tier probabilities and avoiding duplicates.

Create and apply tier-based item styles for the upgrade panel, defining colors, borders, and a get tier style function to map item tiers to styles across waves.

Add lifesteal and harvesting logic by calculating steal chance from player and weapon stats, applying heals, and awarding harvesting coins after wave completion.

Explore building and managing a dynamic shop panel in a Godot 4 game, loading weapons and passives, buying upgrades, combining items, selling weapons, and preparing for waves.

Create a shop card panel in Godot 4 by loading item icon, name, type, and description, using a rich text label and a coin icon with a coins label.

Build a Godot 4 shop panel by creating a Shop Panel scene, applying cohesive colors, and arranging items, weapons, and a three-button control for next wave, combine, and sell.

Load weapons into the shop panel by linking shop cards to item bases, updating icon, name, type, description, cost, and style, then manage coin checks and wave-based item offers.

Override the item weapon's get_description to build a dynamic, BBCode-formatted description for the shop cart. Display damage, cooldown, range, and critical chance in green with percent formatting in a RichTextLabel.

Hide the upgrade panel after selecting an upgrade, show the shop panel, then emit a signal on next wave to hide the shop and start the new wave.

Implement a two-part coin system with a ui coin display and a coin scene that moves to the player or toward the coins back in the ui, updating global coins.

Spawn coins on enemy died signal, create a random spawn around the enemy, then move remaining coins to the coins back position at wave end.

Build a weapon shop UI in Godot 4 with an item card system in the arena. Use on item purchased signals to equip weapons and update the UI.

Enable weapon merging in the shop panel by selecting a weapon, verifying two of the same type, and upgrading to a higher tier, such as laser level two.

Learn to merge two identical weapons into a higher level by validating a context card, removing two weapons and two cards, creating an upgraded weapon, and updating the shop UI.

Learn to sell weapons in a Brotato-style Godot 4 game by selecting a weapon card, selling it for 75% of its price, and updating the player's coins and weapon lists.

Create an item passive class in Godot with add value and remove value fields, apply these effects to stats on purchase, and organize passives in the shop panel container.

Add tier-based outlines to weapons using a Godot shader, copy an outline shader from a public repository, and apply per-tier colors for common, rare, epic, and legendary weapons.