Godot 4 Advanced Game Development Course

Develop a strategy game in Godot, controlling ships with clicks or a selection box, manage workers and units, gather resources, build town centers, houses, farms, towers, then attack to win.

Outline the RTS game planning, including the main screen UI, resource counts, and building interactions. Show how workers gather resources and construct buildings while units provide stronger combat and navigation.

Create a new Godot RTS project, make an art folder, download and import free assets from the Kenny site, including space shooter redux and sci fi rts.

Configure main scene in Godot by adding a main node, UI canvas, game objects, and a camera2D; set stretch mode to canvas items, save as current, and test the scene.

Create a complete Godot UI scene with backgrounds and resource labels, a mini map, and worker build options (town center, farm, house, barracks, range, tower), plus win and lose screens.

Set up a global script in Godot, declare shared variables like nav spots, resources, population, and unit targets, and implement a reset function to reinitialize them.

Develop a camera script for a 2D Godot scene that moves the camera and minimap based on the mouse position at the screen edges.

Create a worker build options script in Godot, exporting scenes for town center, house, farm, barracks, range, and tower, and wire buttons to instantiate buildings while deducting wood and gold.

Create and attach a UI script to the main UI node, update resource labels (wood, food, gold, population) from global counts, and toggle worker build options based on selection.

Create a game object script on the main game node to enable draggable selection of units and workers with a selection rectangle, using dragging, drag_start, and select_rect.

Create a tile map layer, add a tile set from the sci-fi tile sheet, enable the navigation layer and physics layer, adjust transform scale to 2.4, and paint navigation spots.

Create and attach a map script to the map node, manage navigation spots with add and no nav spot logic, and update tiles using vector2 coordinates.

Create a fully functional worker node in Godot by integrating sprites, collisions, an area for tools, a navigation agent, health bar, timers, and a tool-use animation to enable job interactions.

Create and test a Godot worker script, attaching it to the worker node, with navigation, movement, target handling, resource gathering, building, attacking, and a laser system with id tracking.

Create and configure the town center node in Godot: add area 2D, sprite, collision shapes, and a static body, plus a progress bar and UI to delete or spawn workers.

Explore building a town center script in the complete Godot advanced course: attach a TK script, manage placement with a packed scene, navigation spots, and a workers queue with timers.

Create the tree and gold nodes by adding new nodes, area trees and sprites, and configuring a selectable button and a timer, then center them within the scene.

Create a reusable resource script in Godot to manage trees and gold, handling resource counts, area interactions, and worker collection logic with dynamic grouping and id generation.

Create a new town center node by inheriting it from original, add place and build buttons, and implement a 0.2 second timer to reset worker navigation and color cues.

Introduces a new town center script repurposed as a universal unit builder, detailing variables, exports, placement logic, build progression, and UI controls for deploying workers and units in Godot.

Create and configure new unit buildings in Godot by adding barracks and range as inherited scenes, assign correct sprites, and set the unit queues and main script pool.

Create a new farm node from the town center, add farm dirt and plant sprites with collisions, adjust ui, then detach and replace the script.

Learn to implement the farm script in Godot, enabling building, harvesting, and removing farms via UI, while managing resources, plant visibility, worker interactions, and farm grouping.

Create a house node by inheriting from the town center, assign the house sprite, configure collisions and UI, keep the static body as a wall, detach the script, and save.

Design a house script in Godot to build walls and increase population. Reuse and adapt the unit-building code, updating max population count by ten to apply a population boost.

Create a tower node by inheriting from the house, add sprites, collisions, and a rotating turret, then enable automatic attacks on adjacent enemy units while preparing the related UI.

Develop a tower script in Godot that builds a tower, detects enemies in range, rotates the turret, and shoots a laser via a packed scene with a timer.

Create a laser in Godot, building an area 2D node with sprites, a collision shape, a color-coded laser, and a timer, wired to units and enemies.

Create an enemy node in Godot with a character body 2D, a sprite, collision shapes, and health bar; configure navigation agent 2D and timers, then save as enemy type one.

Learn to build a Godot enemy script that uses a navigation agent 2D, handles health, and attacks in range with a laser, targeting units and updating on a process loop.

Create and configure a unit node in Godot by inheriting a worker scene, adding sprites and collision shapes, and enabling navigation agents and attack enemies for allied units.

Learn to build a unit type script in Godot by adapting the worker script for combat. Implement in-range enemy targeting, laser attacks, and navigation while removing noncombat jobs.

Create and configure enemy buildings in Godot by inheriting a town center, adding sprites and collisions, scripting damage and deletion, and enabling auto spawn and attack building behavior.

Create the enemy tower by adding a new node with sprites and collision, script it to take damage and delete when defeated, and attack units in range; test the setup.

finalize game win and lose logic by displaying win and lose screens, using a timer for start, and enabling a restart that reloads current scene via the global reset function.

Master automating unit tasks, including managing collection and drop-off points, and enabling building construction and combat, while tackling pathing systems and exploring upgrade purchases for specific unit types and buildings.

Create a farming rpg in Godot with actions like planting, chopping, mining, fighting, fishing, and cooking. Implement an inventory, day night cycle, and animal purchases such as chickens and cows.

Plan a farming RPG in Godot by outlining the main game screen, inventory, and house/animal interactions, detailing crops, tilling, fishing, time progression, and energy and health management.

Set up a farming rpg in Godot by creating a new project, organizing folders for art, buildings, characters, plants, user interface, and objects, and importing tile sets and asset packs.

Create the main 2D scene with a root node and a world node, save it in buildings, and enable canvas items stretch and pixel snap for a top-down game.

Build a farm RPG map in Godot using layered tile maps for water, land, and soil, add animated water dots, and implement invisible borders to keep player on the world.

Create and animate the player sprite in Godot using a character body 2D, idle and walking animations, tools, collision boxes, hitboxes, and timers for responsive gameplay.

Create a bobber sprite inside the fishing pole and animate idle and fish-on-line states using sprite 2d, gpu particles 2d, and a timer.

Create a global inventory in Godot with current and default inventories, including items, types, and selection flags, then implement a move function to swap items between selected slots.

Create a global time script in Godot, define minutes per day/hour and game minutes duration, implement initial time setup, and emit time updates to drive plant growth and animal production.

Build a global stats script in Godot to save and load player data with a config file. Track health, energy, money, inventory, and in-game state.

Build and attach the player script in Godot, wiring movement, animation, and tool use while enabling farming actions (planting, tilling, fences) and health and energy management via tile map interactions.

Learn to build a bobber script in Godot that handles fishing, including instantiating fish, random timing with a timer, player state checks, and positioning the fish behind the player.

Build a player stats UI in Godot with a canvas layer, health and energy bars, colored progress visuals, and heart and noodle icons to represent core stats.

Create a stats script in Godot, attach it to the stats UI, and sync global stats to health and energy progress bars, then attach the UI scene to the player.

Learn to build a yes/no question UI in Godot by creating a canvas layer scene, styling a darkened panel, adding a question label, and configuring yes and no buttons.

Create an eat food question script in Godot with yes and no button handlers, update energy and health, decrement the noodles from inventory, and hide the user interface.

Create a money counter UI in Godot by building a canvas layer with a label and reset button, then sync with global stats and reset game data.

Create a kitchen UI in Godot by building a canvas layer scene with a panel, background, labels, and buttons for noodles, fence, and back, plus sprites for food items.

In the complete Godot advanced course, attach a kitchen UI script to the main kitchen UI to create noodles and fences via buttons, while updating and managing the player's inventory.

Create the bottom inventory hotbar in Godot with six selectable options, each with a sprite, label, and background, plus a menu button to open the main inventory panel.

Develop an option script for the Godot inventory UI, define item textures, preload assets, update sprite textures per selection, show item counts, and connect buttons to highlight inventory slots.

Create a multi-row player pack user interface in Godot with three rows of six slots, a centered label, and script-connected buttons to place and rearrange items in the inventory.

Create and integrate a Godot inventory script for the player UI, including reset and highlighting of slots, six hotbar buttons, and open/close pack behavior.

Debug the player in the main scene and verify movement and animation. Ensure camera 2D follows the player, UI elements, tile maps, energy bar, and inventory highlights start on game start.

Create collectibles as sprite 2D nodes with area 2D collisions and a reusable script exporting a resource type to add items to the player inventory via scene inheritance.

Create the fishing system by adding a dedicated fishing area 2D and a bobber script that spawns fish when the pole enters the area.

Build tree and rock objects in Godot using 2D nodes, sprite atlas textures, and area 2D hitboxes; animate idle and hit shake with an animation player and signals.

Create a nature script for trees and rocks, track health, spawn wood logs or stones when depleted, and handle ax and pickaxe interactions with an animation.

Create a daylight cycle UI by adding a canvas module, placing day and time labels, and applying a gradient to darken nighttime, then position it in the main world.

Implement a daylight cycle script that initializes day, hour, and minute, updates a day-night gradient texture, and refreshes UI labels on game time and time ticks.

Create a house node in Godot by building an outside house, an inside space with walls and floor, and an area 2D door trigger to move between them.

Set up a house script in Godot to spawn the player inside the house, and toggle the interior and exterior walls, doors, and collisions using physics layers.

In this section, create the player's bed in Godot with a sprite, area 2D and static body, plus a canvas layer UI with yes/no to restart the scene and day.

Create the player's kitchen area by adding an area 2D with a collision shape and a script to enable the kitchen UI via global stats when entered, enabling interaction.

Create a delivery chest in godot that accepts items via an area 2d, triggers an animation, and adds 200 for noodles or 25 for other resources to the next-day money.

Build a yellow plant in Godot with four growth stages, using sprites, area 2D, and a growth script that tracks watering and harvest to progress the plant.

Learn to create a map script that loads saved plant data, instantiates yellow plant and fence scenes, and places them on soil tiles using global stats.

Create and place fences in a Godot scene by building a fence node with a sprite, area and static body, scripting wood log consumption, and interactive removal on axe hits.

Build a Godot passed out scene with a sprite 2D, animation, canvas layer, timer and a 'passed out' label, then script it to restart the next day via global stats.

Build a flame monster enemy with collision shapes, sprite, and idle and hurt animations. Implement random movement via a timer, health, sword damage, and a flashing hurt effect.

Craft a noodle bowl from a yellow plant and a fish, collect ingredients, and eat to restore health and energy, while debugging item removal in the eat-food script.

Create a chicken in Godot by adding an animated sprite, collision shape, and a movement script that spawns eggs as growth progresses.

Create a cow node with an animated sprite, idle and walking animations, a collision shape, and a movement script that creates milk based on age, mirroring the chicken workflow.

In the complete Godot advanced course, build a builder that lets players purchase barns, coops, and animals via a shop UI, with area 2D detection and scripts.

Build a barn and coop in Godot, with unbuilt and built tile maps and labels. Scripts spawn cows and chickens at the start of each day from spawn points.

Final review highlights a multi-component game where a farmer can fish, cut trees, plant, water, and collect items, while building an inventory system and suggesting future locations and NPCs.

Build an open world platformer in a randomly generated world, collecting resources, crafting items, placing blocks, managing inventory, using chests, and a day night cycle with saving to persist progress.

Plan an open world platformer by detailing the main game screen, UI, inventory, chests, crafting, and world creation. Define the player components, animations, and a selector system for interactions.

Set up a new Godot project in 2D, create organized folders (art, blocks, characters, data, nature, resources, UI), and import Kenny's assets pack into the art folder.

Create the main world scene by adding a world node, setting up background (skybox) and earth tiles, then configure project settings, input map, and lighting.

Create world view by building an earth background from a tile set, adjust tile size to 128 by 128, scale to 0.3, layer dirt, stone, bedrock, apply canvas modulate.

Create a global script in Godot to manage game data, including config storage, world map, inventories, chests, and player position, with save, recover, reset, and item-move functions.

Build a Godot resources system: create a collectable resource node with sprite and area2d, and populate it with dirt, axe, coal, diamond, iron, wood, torch, seed, integrated with player inventory.

Create a dirt block in Godot by building a scene with a dirt sprite, a top grass variant, Area 2D sensors, a static body collision, and a getting-hit timer.

Create a block script with variables, health calculations, and resource preloads; implement area signals and hit logic to destroy blocks and spawn dirt, stone, iron, diamond, and other resources.

Create basic blocks in Godot by adding a node for each block type, assign sprites and signals, and build dirt, bedrock, chest, coal, diamond, iron, stone, torch, plants, and mushroom.

Explore building a growable tree block in Godot, featuring three growth stages, 2D sprites, area 2D with collision shapes, and a script handling growth and wood resource drops.

Create and attach the earth script to generate and populate a game world with blocks, randomizing nature and ores, and loading saved worlds in Godot.

Create a world clock script to track in-game time, update day-night lighting with gradient textures, and manage world generation and testing toggles for faster development.

Create an in-game UI in Godot featuring a canvas layer, a time label, and a main menu with continue, new world, and save—updated by a script.

Build a Godot hotbar and inventory UI with six item slots, a bag button, and scripts to manage current item visuals. Implement scene setup, dynamic previews, and bag interactions.

Create a Godot bag UI with 18 slots (three rows) and a close button, with item count labels. Implement slot scripts to manage movement and inventory updates.

Complete crafting system in Godot advanced course: create a crafting node, torches, tools, chests, and trash items, with slot reset, resource checks, and item creation.

Create a chest UI in Godot to move items between chest and player inventories, open on player contact, and close with a dedicated button.

Create a Godot player node by assembling a character body with limbs, tools, animations, and a proximity selector ring; implement idle, walking, in-air, and tool-swing animations.

Create a Godot player script to handle movement, gravity, jumping, and tool use with animations. Implement a selector to aim tools with the mouse and flip sprites by direction.

Create a player light with a point light 2D and radial gradient texture, and script it to turn on underground, then integrate with the player and torch.

Create the placement block node with a sprite, then add area 2D collision zones for the center and sides. Assign groups hitting and none, and prepare the placement block script.

Learn to build a placement script in Godot that places blocks on a grid, manages inventory, and updates the world map with dirt, stone, chest, torch, tree, weeds, and seeds.

Review and fix a wide range of bugs in this Godot advanced course lesson, from lighting gradients and UI on for images to collision shapes, crafting logic, and inventory indexing.

Learn to generate a random world, save it for later use, enable character interaction and block placement, manage components, and plan enhancements like more block types and an enemy system.

Complete the course and apply your growing game design skills, using three templates to add to or adapt for your own games.

Explore higher level Godot game development courses to continue training and create more complex style games. This will give your players more to enjoy; see the document with course links.