Learn 2D Game Development: Godot 4 & C# from Scratch

Introduce the basics for all skill levels, explain computer skills and C# through a hands-on game, and guide setting up Godot with VS Code and .NET on Windows, macOS, Linux.

Get quick help for gem catcher and Godot issues by using the Q&A, Discord, or email, and email a zip of your project so the instructor can run it.

Install the Godot mono build and the .net sdk, set up Visual Studio Code, create a foundations 2D project, add a C# script, and run to verify output.

Explore the foundations of Godot, its ide, and C# integration, learn nodes, resources, and 2D position, movement, and rotation, and write basic scripts to build a visual project.

Navigate the Godot 4.3+ editor in a 2D layout, mastering docking, default view, and VS Code integration for C#; explore the scene tree, import tab, and file system.

Explore the Godot 2D viewport, origin, and node tree, where root and sprite 2D textures form scenes that render through the main scene and asset imports.

Explore aspect ratios in Godot by setting a base resolution and using stretch modes to keep aspect ratio, height, or expand, with viewport rendering considerations and pixel-art texture filtering.

Scale the plane and new sprites to 0.5, add a helicopter and carrier as sprite 2D nodes, and use grid, pixel, and rotation snap to align them precisely.

Learn how Godot draws game scenes from top to bottom by manipulating z index and y sorting, using parents and relative values to control layering.

Learn how position, rotation, and scale relate to a node's parent and how global position and global rotation place objects in the world. Explore how parent-child relationships affect transforms.

Explore scripting in Godot to move and rotate nodes, extend node functionality with C#, and access scene nodes; learn to set up VS Code for running and debugging with breakpoints.

Access and manipulate nodes in Godot 4.3+ with C# in VSCode, explore the game loop using ready and process, and use export node paths for safe sprite control.

move a 2d sprite in godot by updating x and y with delta time, rotate using code, and use a new vector2 to set sprite.position for 50 pixels per second.

Move a plane with UI up input in Godot using input map and built-in actions. Learn how the helicopter responds to UI down and how parent scale affects speed.

Learn to rotate a sprite using left and right inputs in Godot, with radians and delta time, and compare setting rotation to the built‑in node 2D rotate.

Explore translation in Godot 4, comparing global translate and local translate, and observe how a parent's scale affects movement, with practical helicopter examples.

Learn how vectors in 2d games store x and y, encoding position. Use normalized vectors and transform x to move toward what you face with speed and delta time.

Explore this C# introduction to write and run simple code with the dotnet runtime, csproj projects, and Visual Studio or VS Code, using intellisense.

Set up a dotnet console project by creating an empty folder and using dotnet new console, then learn explicit vs implicit usings and run the program with dotnet run.

Explore C# variable basics in Godot, covering integers, strings, booleans, doubles, floats, characters, and constants; learn naming rules, string interpolation, comments, and how var helps concise code for games.

Explore arithmetic operators in Godot 4.3+ and C#, including addition, subtraction, multiplication, division, and modulo, with int and float examples and casting considerations.

Explore conditionals and comparison operators in c sharp, including if, else if, else, and switch. Learn about scope and blocks, boolean logic with and, or, not, and the ternary operator.

Solve a conditionals challenge by reading console input for character name, hero status, and ring count; implement if-else and a switch to decide roles, fellowship membership, and Frodo's quest outcome.

Explore conditionals in a C sharp challenge, using hero and villain checks with rings, a switch on character name for fellowship of the ring, and nested ifs for ring destruction.

Learn arrays and lists, including fixed-size vs dynamic collections. Practice for, foreach, while loops, indexing, length, and basic Linq queries.

Explore dictionaries as a fundamental reference type with keys and values, learn to add, access, modify, remove, and iterate entries, and understand key uniqueness and JSON data relevance.

Create a dictionary called character abilities mapping names to lists of abilities, with at least three characters and two having speed, then print all names with abilities and speed-only characters.

Map character names to lists of abilities in C#, print names and abilities, and filter characters that have the speed ability.

Learn how functions prevent code repetition by using a return type, name, and parameters; invoke them to output and return values, including void and int, and one-line arrow syntax.

Define your own types with the class blueprint and create instances. Manage properties and methods using constructors, access modifiers, and getters and setters.

Explore class-level concepts by defining constants and static members that track character creation, and build a utility class with public static methods for reusable functions across the application.

Explore inheritance in Godot by building a base animal class with age, walk, and sleep, then derive specialized characters using constructors, base calls, protected setters, and virtual/override.

Explore partial classes and namespaces in C#, how to extend classes with partial definitions, use namespaces to avoid conflicts, and understand the program main entry point and singleton pattern.

Learn the this keyword to disambiguate class fields, and implement the singleton pattern in C# and Godot, creating a single shared instance for global use like settings or scores.

Explore how attributes in Godot add metadata to classes and methods, with the export attribute revealing a sprite slot in the inspector and reflection reading attributes at runtime.

Explore string formatting in C sharp with practical examples for labels, UI text, and output, using format specifiers, two decimals, percentages, alignment, and interpolating values.

Discover how delegates and events work in Godot using signals, and learn to wrap delegates with events, manage handlers with plus/minus equals, and invoke them.

Explore enumerated constants in C# by defining an enum for weapons, learning how enums map to integers, improve type safety, and use them with intellisense and switches.

Explore classes, types, instances, and inheritance in Godot using C#, learning base and child classes, overriding methods, and how properties, methods, and signals compose objects.

Explore the Godot node lifecycle, from enter_tree and ready to exit_tree, and learn how process and physics_process fit into frame updates.

Learn the Godot run-time life cycle, where process runs every frame and physics process runs at a fixed 60 fps, with vsync considerations and how to adjust frame rates.

Learn how to create, save, and reuse scenes in Godot 4.3+ by building a Hobbit scene, instantiating it in the world, and understanding that positioning is relative to the parent.

Learn how signals act as events in Godot, subscribe to them, and react with functions and timers to simplify code and improve performance.

Learn to create and emit a custom signal in Godot 4, connect it to a wizard and hobbit, and shrink the Hobbit when the spell is cast.

Explore connecting signals in the Godot IDE, linking The Hobbit's kill wizard signal to the damage wizard function, and note GDScript auto-generation versus manual C# methods.

Build a dice catcher mini game in Godot to explore 2D game foundations, including multiple scenes, collisions, music, random spawning, and an initial UI to track the score.

Set up a Godot 4.3+ project for the dice catcher game, import assets, and build a 2D scene where a fox catches falling dice to score before game over.

Create a dice scene using area 2D for non-physics collision detection with a circle collision shape and sprite; spin and drop dice in the game scene and detect fox collisions.

Add code to the dice to remove itself when it goes off the bottom of the viewport using get_viewport_rect and its end y; schedule removal at frame end.

Create a fox in Godot 4.3+ using area 2D and a capsule collision shape, implement left/right movement with C# and get_access, flip the sprite, and expose speed in the inspector.

Detect when a dice overlaps the fox with area 2D area entered signal, play the eat sound via audio stream player 2D, and remove the dice.

Set up a points variable and a point scored signal on the fox; emit it when a dice is eaten, connect it in the game, and update the on-screen score.

Spawn dice in Godot 4.3+ using a packed scene and a timer to instantiate them at random top positions with a margin, then add them to the game scene.

Emit a game over signal when the dice exits the bottom, then stop the music and play the game over sound. Connect the signal and load the game over WAV.

Learn two pause methods in Godot 4.3+: manually stopping dice, fox, and timer using groups, or pausing the scene tree. Implement restart via reload current scene or r key.

Master Godot pause mechanics by using tree pause and selective process modes, and organize dice and fox under a pausable container to pause together and unpause on restart.

Create a plane-based clone of Flappy Bird, navigate between main scenes, add UI animations, physics nodes, parallax score, and persistence to save progress.

Set up a Godot 4.3+ 2D game project in C#, import assets, build scenes, wire nodes with signals, and learn parallax. Explore autoloads, scene navigation, UI, score persistence, and physics.

Outline the plan for a Godot 4.3+ 2D game: define assets, main and game scenes, plane and pipes gameplay, lasers, UI, parallax backgrounds, and scene transitions.

Create the plane with a character body 2D. Animate the propeller using an animated sprite 2D, and leverage the physics engine for gravity and collisions; score via pipes and lasers.

Learn 2d plane movement in Godot 4.3+ with C# using a character body 2d, velocity and move and slide, gravity, and spacebar jump via input map.

Create a barrier with static body 2D and collision shapes to stop the plane from crossing pipes and detect floor hits with is_on_floor, using boundary normals and a die function.

Build the pipe and laser scenes using area 2D collision detection, score by passing through the laser, and animate the laser with an animation player to flash.

Learn to spawn pipes in a Godot 4.3+ 2D game, scroll them right-to-left, and remove off-screen using a visible on screen notifier and a spawn timer with random y positions.

Pause the game tree on plane death from pipe collisions, using upper and lower pipe body entered signals; score via laser exited events and add a jump animation.

Design the main scene user interface in Godot using control nodes, screen-space anchoring, and margin and container layouts to create a responsive interface with labels, textures, and background music.

Learn to navigate between main and game scenes in Godot 4.3 using UI cancel, packed scenes, resource loader, and a singleton game manager for global navigation.

Build a game UI in Godot 4 with score and game over labels, explore canvas layers, and manage screen space versus world space for reliable layout.

Explore how Godot handles inputs through layered processing, from input to gui input and unhandled input. Learn to control propagation using handled flags and gui input on control nodes.

Master a game over flow in Godot using signals, groups, and a global signal hub to decouple emitters from the user interface, with a game over label, timer, and sound.

Create a high score manager to save and load scores, and use a signal hub for updates. Disconnect signals on death to prevent double scoring; persist high score to file.

Persist the high score to file in Godot by using a high score resource saved to user data folder and loaded on game start, then shown in the user interface.

Implement parallax backgrounds in Godot 4 using the new parallax 2D node, with auto scroll and repeat sizes to create infinite scrolling with layered sprites moving at different speeds.

Master two scene transition techniques in godot 4.3+ from scratch: a simple interstitial loading screen between main and game scenes, and a complex fade using a top canvas and animation.

Explore rigid body physics in a Godot-based game loosely inspired by Angry Birds, focusing on full physics simulation and firing birds into cups.

Set up a Godot 4.3+ project with main and level scenes, building an angry birds-style game using rigidbody 2D physics, drag-to-fire, levels, cups, high scores, UI node reuse, scene inheritance.

Explore how Rigidbody2D introduces real-time physics: gravity, mass, gravity scale, friction, bounce, sleep states, collision shapes, static/kinematic modes, impulses, and dragging via code.

Create a Godot 4.3+ scene with a rigid body 2D animal and static cups, enabling input and contact monitoring, and drive physics-based launches with stretch, launch, and kick sounds.

Implement draggable animals in Godot by detecting drag input, tracking the start position, updating the animal with the mouse during physics processing, and applying an impulse on release.

Learn to implement drag movement for an animal in Godot 4.3, track the drag delta, update position as start plus drag vector, and clamp within a 60x60 bounding box.

Detects when the mouse drag is released using unhandled input, unfreezes the animal, and applies a central impulse based on the dragged vector to launch it across the screen.

Create a water scene in Godot 4.3+ using region-based tiling, collision shapes, and an audio splash to bring 2D gameplay to life.

Implement 2D animal regeneration in Godot 4.3+ by spawning from a start marker and using a signal hub to respawn on death, deferring to idle time to avoid physics errors.

Build a Godot game UI with a top-left level and attempts label inside a margin and VBox, updating the counter via signals while ensuring the UI ignores drag input.

Build a cup cutscene with a static 2D body, a collision polygon, and three sprites, then vanish the cup using a scale animation and sound, triggered when the animal rests.

Detect level completion and display a centered level complete UI with a large blue label and looping jazzy music while tracking remaining cups via a static cup counter and signals.

Learn to create multiple levels in Godot 4 by using inherited scenes from a level base, enabling shared nodes while customizing level specifics like cup placement and the animal start.

Learn to build a texture button level selector in Godot 4.3+, with level and best score labels, and navigate to each level by changing scene to file.

Persist per-level high scores to a file using an exported Godot dictionary, with a global score manager that updates and displays the best score for each level, default 9999.

Add a direction arrow as a sprite 2D to visualize the drag direction and impulse for the animal in Godot, hiding until drag begins and scaling/rotating with drag length.

Add an audio stream player named music, load birdsong, and autoplay. Implement kick and stretch sounds for cup hits and drags using signals and drag vectors.

Explore how Godot handles input events across ui nodes, color panels, and a static body, revealing input override order, gui versus unhandled input, and propagation rules.

Learn to build a memory tile game in Godot 4.3+, focusing on user interface layouts and generating levels from code rather than the editor.

Develop a 2D memory madness game in Godot 4.3+ using user interface only with control nodes, learn navigation without scene removal, sound control, custom resources, and a dedicated score-tracking system.

Structure a master scene with two toggleable scenes, a sound controller, a grid of memory tile scenes with moves and pairs, a panel overlay with tweened front sprites.

Build the main scene visuals by creating a level button (texture button) and a front sprite, then lay out the user interface with a color rect, vbox and hbox containers.

Visualize the game screen in Godot, building a memory tile scene with a six-column grid and margin, then add moves and pairs labels and an exit button.

Discover how to create a custom level setting resource in Godot with C#, expose it in the inspector, attach it to level buttons, and configure rows, columns, and target pairs.

Emit a level selected signal when a level button is pressed to configure the grid with memory tiles using the level setting.

Attach scripts to memory tiles and the game, instantiate tiles as children of the tile grid according to level settings, and adjust grid columns to match each level.

Implement complete navigation by wiring the exit button to return to the master screen and select levels, and use a signal hub to clear tiles before re-entering a level.

Use the image manager and a tile images holder resource to preload and shuffle glitch images from the assets glitch folder, supplying textures for the front sprite and memory tiles.

Animate the front sprite using a Godot tween to randomly scale, rotate, and swap images, looping with dynamic spin time and random rotation, driven by an image manager.

Implement memory tiles in Godot 4.3+ by using texture rects for the frame and item images, and reveal them on click with a reveal(show) function and pressed signals.

Learn to implement level data selection in Godot, creating a level data selector that returns a shuffled list of image pairs for memory tiles, and wire up memory tile setup.

Learn to implement a memory game scorer that manages tile selections, reveal timing, and animations, preventing extra clicks until two tiles are revealed and matched.

Learn to detect memory tile pairs in Godot: expose textures, compare textures for matches, scale paired tiles to zero to keep grid gaps, and update the scorer.

Enhance the scorer to track moves made, pairs made, and target pairs via level settings, reset on new games, and update UI labels using string getters each frame.

Learn to build and style a game over UI in Godot 4 with a panel container, vbox layout, and labels, showing moves and reacting to game over and exit signals.

Tween the memory tile on kill, rotate 720 degrees and scale to 1.5 by 1.5 in 0.5 seconds in parallel, then shrink to zero while raising the z index.

Set up a centralized sound controller in Godot to manage music and effects via signals, wiring tile, level, and button actions to audio playback.

Explore building a pixel platformer in Godot 4.5, covering tiles and tile physics, animatable body 2D, raycast 2D, animation tree, node state machine, camera, hitboxes, moving platforms, boss.

Create a new Godot 4.5 project named FoxyAntics for mobile rendering, import assets, set 1024×768 window with viewport stretch, and build level base and main scenes with globals.

Add a looping music track and a title label foxy antics in the main scene, then implement quit-key navigation to switch to level base and back via the game manager.

Create a player scene in Godot 4.5 using a character body 2D, capsule collision, and physics layers to move, jump, and collide with tiles, while a following camera handles view.

Set up the animation player in Godot to create idle, run, jump, fall, and hurt animations with keyframes, looping, and sprite flipping by direction.

Learn to set up an animation tree and a state machine in Godot 4.5, linking idle, run, and hurt states with automatic transitions.

Build a reusable enemy base in Godot 4.5 with a character body 2d, animated sprite 2d, and an area 2d hitbox, to support snail, frog, and eagle.

Learn to implement a snail enemy in Godot 4.5 with a shared enemy base, using gravity, speed, raycast 2D floor detection, wall and gap turning, and safe cleanup when off-screen.

Design and animate a frog enemy in Godot 4.5 using C#, implementing idle behavior, facing the player, gravity, and a jump sequence within a base enemy class.

The frog waits offscreen until visible, then uses a timer to jump toward the player, overriding timeout in a frog class and using a one-shot timer with randomized wait.

Set up an eagle enemy in Godot that stays hidden until visible, then flies with constant vertical velocity, zigzags toward the player, and uses a raycast to detect the player.

Create a bullet base with area 2d, collisions, and sprites; derive enemy and player bullets, implement a setup for direction and speed, and add a lifetime scene to remove bullets.

Learn to centralize spawning with an object maker that uses signals to instantiate bullets, pickups, and explosions, deferring to idle time to avoid physics conflicts.

Learn to build a shooter scene in Godot 4.5, including a 2D shooter node, shoot timer, bullet scene, and a shoot function that enforces a 0.7 second firing delay.

Instantiate an explosion scene when an enemy dies, using a six-frame animated sprite and a sound, created via the object maker at the enemy’s position and removed after animation ends.

Build a fruit pickup in Godot 4.5 with area 2D, collision, and animated sprite 2D, featuring random animation, point emission on collect, and a short disappearing lifetime.

Implement the player hurt state in Godot by using the hitbox to trigger a hurt animation, set an is hurt property, play a hurt sound, and control with a timer.

Implement a temporary invincibility state for the player in Godot 4.5 using a separate invincible animation, a flashing transparency effect, and a goInvincible workflow that prevents damage during the animation.

Learn to build an enemy boss in Godot 4.5 using triggers, hitboxes, and animation tree to animate arrival, pulsing, attacking, and invincibility, including shooting bullets at the player.

Finish implementing the boss attack by adding a shoot function, calling it from the attack animation, and firing bullets at the player using the boss visuals position and a hitbox.

Learn to implement boss damage in Godot 4.5: trigger invincibility and flash on hit, tween back to start, and manage lives, points, and end-level checkpoints.

Build and wire a checkpoint in godot 4.5: trigger the opening animation after boss defeat, enable collision detection, and emit level complete signals to finish the level.

Create a responsive hud in Godot 4.5 with hearts, score and level indicators, using canvas layers, hbox/vbox layouts, texture rects, and an overlay for game over or level complete.

Add a level complete overlay on the game HUD with a timer and you win sound, pause the tree, and enable navigation back to the main menu or next level.

Learn to implement scoring in Godot 4.5 with C#, exporting boss, fruit, and enemy points, emitting on scored signals, and updating the game hud in real time.

Learn to implement a configurable lives system in Godot 4.5, exporting lives per level, updating the UI hearts via onPlayerHit signals, and handling game over in the GameHUD.

Learn to build ball spikes that follow a path with path 2d and path follow 2d in Godot 4.5, and add floor spikes using area and hitbox to injure players.

Implement a path-following moving platform in Godot 4.5 using Animatable Body 2D and path follow 2D, and manage sync to physics by turning it off when updating position manually.

Create an animated moving platform in Godot 4.5 using a tween for A–B movement with from/to marker 2D points and sync to physics, contrasting with the animation player approach.

Implement a two-resource high score system in Godot 4.5 with C#, using a score manager to save up to 10 scores and display them in a UI grid.

Display scores on screen by building Godot high score display: a packed scene with score and date labels instantiated for each score from the score manager, using grid container.

Persist high scores in Godot 4.5 by loading and saving a score file, updating score history, and displaying results in the main menu and game hud.

Learn to create multiple levels in Godot 4.5 using inherited level scenes, navigate between levels, and carry the score with a game manager that loads next levels and supports reloads.

Implement a parallax background scene in Godot 4.5 using parallax 2D, switchable backgrounds via resources, and camera-driven scrolling with per-layer scroll scales.

Learn to implement a responsive camera shake on player hits and enforce camera limits at level edges in Godot 4.5, using exported boundaries and signals to manage shake timing.