Jumpstart to 2D Game Development: Godot 4 for Beginners

Explore where the course assets come from, including Open Game Art, Sunnyland Pack, Pixel Adventure, and other free sources, and how licensing and donations support platformer, memory, and shmup games.

Acquire basic computer skills to start the course: extract zip files, create and locate folders, install software, download and run Godot from a zip, and learn coding during the course.

learn how to get help in this Godot 4.4+ beginner course through q&a, email, zoom, or discord, and share a zip of your project for quick diagnosis.

Zip the res folder contents to create a game zip for debugging, then email it to the instructor; no export or compile in Godot is needed.

Beginners learn that early errors are normal when learning Godot, and they should not be disheartened; ask for help and practice patiently.

Discover the foundations of Godot 4.5/6, from quick interactive movement to GD script basics, nodes, and signals, with options for all levels and a Dice Catcher mini-game.

Download Godot from godotengine.org, extract the 160 MB file, and run a Foundations 2D project. Create an Ocean scene to test hardware compatibility, and use compatibility mode if needed.

Explore Godot basics by building an ocean scene with a plane and helicopter, importing assets, and scripting movement and rotation for engaging 2D gameplay.

Discover how Godot uses nodes for functionality and resources as data containers, reuse resources across nodes, and add audio with an audio stream player to build interactive scenes.

Explore how nodes and scenes form a scene tree with a root and child nodes, and how the ocean main scene starts the game in the viewport.

Master aspect ratio in 2D game development for mobile targets by adjusting the base viewport size, stretch modes, and keep aspect ratio for consistent visuals.

Learn how position and global position differ in Godot, and how a child's transform is relative to its parent using plane and carrier examples.

Demonstrate how rotation and parent-child relationships affect local versus global position in Godot. Use unique access names to keep node paths stable and avoid transforming the root node.

Explore how scale affects nodes in Godot, showing how a parent's scale multiplies child transforms and how to use global versus local positions, and the translate function to move correctly.

Explore moving game objects with translate and global translate using vector2, scaled by delta, and compare local versus global movement on a plane and a carrier.

Discover how vector 2s power position, direction, distance, and angle in Godot, normalize vectors for smooth movement, and use look at and get global mouse position to chase the mouse.

Explore how to manage drawing order in Godot 4.5/6 to control z-index and y-sort, and organize the 2D game scene within a canvas item hierarchy.

Explore how Godot's transform uses vector2 components to represent the local X and Y axes and rotation, and move a plane along its local X using transform.x.

continue your journey with Judy's Script Basics for new coders, then explore Godot essentials like life cycle, multiple scenes, and signals, finishing with the minigame Dice Catcher.

Discover the basics of GDScript variables in Godot, including declaration and printing, plus integer, string, float, boolean types, dynamic and static typing, and constants.

Master arithmetic and comparison operators in Godot GDScript, explore vector and float quirks, including is equal approx, and practice with a health and arrows readiness exercise.

Explore control flow in godot scripting with if, else, and elif decisions, and use while and for loops with break, continue, and range; understand scope and indentation.

Learn to use arrays and dictionaries in Godot, including typing, appending, erasing, indexing, pick random, and shuffle; explore keys, values, and nested dictionaries for level data and character info.

Learn to create and call methods in GDScript, roll dice with randi, and define functions with parameters and returns, including default values and pass-by-value versus pass-by-reference.

Master enumerated constants and match in Godot's GDScript, using race.hobbit, elf, dwarf, and wizard for readable code; learn string handling and formatting with substrings, find, and format specifiers.

Master advanced GDScript concepts by defining a character class with health, name, and weapon; create and initialize instances via init, print info, and explore unique instance IDs.

Explore encapsulation and property management in Godot by implementing getter and setter functions for a character's health, including clamping to 0 to 100 and using properties with get and set.

Explore statics and the static keyword at the class level, separate from instance state, with examples like character count, GetCharacterCount, and class-level constants.

Learn how inheritance creates a base animal class with age, name, sleep, walk, and signals, then extend it for cat and dog and apply overriding.

Discover how Godot handles memory: allocate and free basic types and non-variant types, manage variant types, and extend object or node with ref counted memory and queue free.

Set up a Godot project for the dice catcher by importing assets, configuring canvas stretch and aspect, and creating a world scene while exploring multiple scenes, signals, and node lifecycles.

Learn to use multiple scenes in Godot for 2d games, creating reusable hobbit and wizard scenes with sprite 2d, instantiating instances, and applying rotation scripts while preserving the root node.

Master inheritance in Godot, building on classes, objects, and signals. Extend base types like node2d and canvas item, and create new types with scripts and class names.

Explore the node life cycle from init to exit_tree, and learn how enter_tree and ready ensure child readiness. Compare process and physics_process, frame rates, vsync, and physics ticks for timing.

Explore Godot signals to trigger actions, like revealing a wizard after a timer timeout, and connect per-instance timers in hobbit and wizard scenes, using exported timer values in the inspector.

Define and emit custom signals in Godot 4.5/6, connect them across wizard and hobbit, and shrink characters via timer-driven events.

Learn signals in Godot 4.5/6 by wiring connections from code with the ready function, connecting and disconnecting hobbit and wizard signals, and using one-shot flags for automatic disconnection.

Build a quick dice catcher that ties input, movement, spawning, scoring, and signals into your first Godot project, guiding a fox to catch falling dice.

Outline the dice catcher game in Godot 4.5/6, with scenes game, dice, and fox, area 2D collision, sprites, a score label, a timer, and audio for music and munch sounds.

Track the score by counting the dice the fox eats, update via the eaten_dice signal, and display a top-left, zero-padded score label.

Implement game over when a dice leaves the screen, switch to a game over sound via signals, and reload the current scene with the R key.

Finish the game over label and learn how Godot reuses resources, from label settings as external resources to making unique sub resources to avoid global changes.

Launch into building a game, Tappy, a flappy bird–style tapper, wiring gravity, animations, scrolling pipes, scoring, parallax backgrounds, and a full game over loop, developing core 2D skills, in Godot.

Craft the tappy game, a flappy bird clone, in Godot 4.5, learning project setup, scenes, GDScript basics, signals and inheritance, parallax backgrounds, scene switching, UI canvases, and saving scores.

Discover asset selection and scene organization for a Godot 4.5/6 beginner game, using cc0 glitch garden assets, titan font, parallax backgrounds, and pipe, laser, and tappy scenes.

Design and animate the tappy scene using a character body 2D root, collision shapes, and an animated frog sprite. Learn about 2D physics bodies and velocity vectors.

Master Godot 2d physics by setting velocity, using move and slide, applying gravity, and handling collisions with static bodies and world boundaries.

Explore the Character Body 2D utilities isOnFloor, isOnCeiling, and isOnWall, and learn to display live state with a label while adjusting move, slide, and max angle for platformers.

Animate the frog's animated sprite 2D in Godot with an animation player by keyframing scale and rotation for a quick wiggle, plus a reset state and Bezier curve notes.

Build a pipes scene from two pipe instances and a laser, set up area 2D with collision shapes and pivots, then instantiate in the game and animate the laser flash.

Scroll pipes from right to left at 120 pixels per second and remove them off screen using a visible on screen notifier 2D, connecting screen exited to queue free.

Configure collision detection with body entered signals to detect tappy hitting pipes and the laser for scoring, using layers and masks to limit detections and prevent double scoring.

Implement a die function in tappy.gd to pause the game when hitting the floor or pipes, checking is_on_floor and body type, and trigger game over.

Create the main scene with Godot 4 UI nodes, mastering anchors and margin containers for responsive layouts, adding a background, labels, music, and a flashing press jump prompt.

Learn how to navigate between scenes in Godot 4.5/6 by switching the main scene to the game scene with load and preload, avoiding circular references, and using auto load.

Learn to build game user interface with canvases and a canvas layer to keep it in screen space and avoid layout breaks, signaling Tappy's death to show game over label.

Implement a signal hub in Godot to decouple game logic from the UI. Emit Tappy died through the hub so the game over label updates without tight coupling.

Explore parallax using the parallax 2D node in Godot 4 and layer sprites for a depth-rich background. Set the repeat sizes and auto scroll speeds to achieve smooth right-to-left parallax.

Implement a central score manager to track current and high scores, emit point scored signals via a signal hub, and update the user interface across game and main scenes.

Learn to persist high scores in Godot 4.5/6 by saving and loading a 32-bit score via file access in the user data folder, with practical code examples.

Understand how Godot processes inputs through a cascade of input functions and how UI can swallow clicks. Learn to ignore or propagate input and use is action just pressed.

Create a simple transition between the game scene and the main scene using a loading screen, controlled by the game manager and a one-second timer to swap scenes.

Create a top-layer fade transition with a full-screen colour rect and a 0.4-second animation to fade between scenes, loaded via an autoload and a call-method track.

Build an angry animals game in Godot, inspired by angry birds, by applying rigidbody 2D physics, force impulses, and vector math, with inherited scenes for multi-level design and enhanced UI.

Begin Godot 4.5/6 project for beginners, building a two-screen game with level buttons, cups, and inverse scoring, while learning reusing user interface nodes, rigid body 2D physics, and scene inheritance.

Explore Rigidbody 2D in Godot 4.5/6 by experimenting with gravity, mass, forces, impulses, and collisions using static bodies, collision shapes, and physics materials to observe realistic interactions.

Build an animal scene in Godot 4.x with a frozen rigid body 2D, released by impulse to land in a static cup, featuring debug label and audio cues.

Master 2D game development in Godot by implementing animal selection and dragging with a frozen rigidbody, drag start tracking, and release impulse to launch.

Master the animal release mechanic in Godot 4.5/6: drag to aim, release to apply a calculated impulse, scale and rotate an arrow indicator, and safely defer physics updates.

Spawn the animal in the level base at the start marker using a spawn function, instantiate and place it. Use a signal hub to respawn on death, deferring add.

Set up a game UI in Godot using margin and VBox containers to display level, attempts, and level complete prompts, while preparing for a deeper dive into input handling.

Explore how Godot handles input across input, GUI input, unhandled input, and input events, and learn how to propagate or stop events to preserve intended interactions.

Learn to signal and track level progress in Godot by counting cups via a cup group, updating current cups on destruction, and displaying a level complete with looping music.

Update the Godot 4.5/6 game UI to track attempts with a dynamic label and on attempt signals, and pause the game on level completion to prevent further attempts.

Learn to build a reusable main menu and level scenes in Godot using inherited scenes from a level base, creating levels 1–3 efficiently.

Build interactive level buttons in Godot 4.5, showing level numbers and scores with a texture button, hover scale, and on-press navigation to the chosen level; include back navigation with escape.

Implement a level scores system in Godot with LevelScoresResource and ScoreManager to track, load, save, and update the best per level score (default 9999) for level buttons.

Review the wrap-up: add a static block with a sprite and collision shape; update level two with cups and bouncy blocks; leverage rigid body 2D physics to shape play.

Explore building a memory tile game in Godot 2D, focusing on UI, code-driven level generation, and transitions within a base scene from menu to play, plus a sound manager singleton.

Build memory madness using UI nodes and hidden panels, not scene changes. Set up a 1024 by 768 project with a master scene, sound controller, and global resources.

Build the visual main screen in Godot 4 by arranging level buttons and front sprites without code. Configure a VBox/HBox layout, tinted background, and a 1024 by 768 base.

Lay out the game screen with an hbox root, a central grid container for memory tiles, and a right-side vbox showing moves, pairs, and an exit button.

Learn to implement level settings in Godot 4.5/6 by creating a level setting resource with rows and columns, exposing it to level buttons, and displaying grid sizes.

Select a level via the level button to switch from the main screen to the game screen in the same frame, using a signal hub to pass the level setting.

Build an image manager by exporting a tile images holder resource of texture 2d, preload it, and fetch random textures for memory tiles and the front sprite, ensuring deployment works.

Use tweens to animate the front sprite in Godot, scaling, rotating, and swapping random images with random durations, looping to keep timing unsynced.

Create a level data selector with getImagesForLevel to shuffle tile images via the image manager, pick paired textures for memory tiles, and test with Godot's debugger.

Configure memory tiles with a frame and item image using a setup function, then reveal tiles on click to display images and validate the level setup.

Coordinate the scorer scene to manage tile selections, hold two revealed tiles with a reveal timer, and re-enable selections after detecting pairs.

Detect memory tile pairs, remove them from the grid by making them transparent, and track pairs with a scorer while updating the UI label.

Wire the movesMade counter into the scorer, pass target pairs, and update the moves display as players reveal pairs, detecting game over when movesMade equals target pairs.

Create a game over UI in Godot using a panel container and VBox with labels, styling options, margins, and padding, hidden by default.

Reveal the game over UI when the target pairs are complete. Disable selections, emit on game over with the moves, and update the label via the signal hub.

Implement a memory tile tween in Godot 4.5/6 that spins 720 degrees and scales up before fading out, using parallel tweens and precise timing to reveal polished gameplay effects.

Learn to add sounds in Godot by building a sound controller with music and effects, wiring level, tile, click, and score events for a polished UI-driven game.