← Game DevelopmentGodot Game Developer PathwayGet Godot 4

Grades 9–12 · Eight core lessons + six system studios

Build the loop.
Grow the world.

Learn the shared grammar of 3D engines—scene graphs, transforms, systems, assets, and real-time loops—then use Godot to ship Signal Run, a small 3D collection game. Add only the systems that fit your own idea.

0 of 8 core lessons complete

Core pathway8 × 50–70 minute lessons
Extension track6 independent system studios
Starting levelNo Godot experience required
Engine + languageGodot 4 and typed GDScript
READY

Studio protocol

Protect working builds and make learning visible.

One project, clear restore points

At each green Save marker, duplicate the entire project folder before beginning the next lesson or system.

Run after every change

Add one node, property, or code block; press Play; observe; then continue.

Evidence before completion

Definitions of done require a demonstration, explanation, recording, or test result—not only checked boxes.

Remix after reliability

Complete the required behavior first, then change one rule and explain the effect.

Folder rule: Keep scenes in res://scenes, scripts in res://scripts, levels in res://levels, UI in res://ui, data in res://data, and media in res://assets. Clear ownership prevents broken paths later.

Core build sequence

Every system has a reason to come next.

Complete these in order. Each lesson supplies a dependency the next lesson needs.

LAB

Interactive systems lab

A feature is a conversation between systems.

Press a player action. Watch which systems receive the event, what data changes, and what the player sees. This is the same event-driven thinking you will use with Godot signals.

PLAYER EVENTitem_collected("berry")

Architecture ruleThe object that detects an event should announce it. The system that owns the data should decide what changes. The UI should display the result.

Optional system studios · 09–14

Add only what your game can use.

These are independent upgrades, not a longer prerequisite chain. Open a studio to see the model, smallest useful code, a test, and a remix.

09InventoryStore item IDs and quantities; let UI observe the data.DATA → UI

Model it before you draw slots.

An inventory is data first. Keep item definitions (name, icon, description) separate from the player’s changing quantities. The inventory owns the numbers and emits changed; the UI listens and redraws.

inventory_panel.tscnInventoryPanel · ControlMarginContainerGridContainer · slot buttonsItemDescription · Label
inventory.gd · Autoload or player component
extends Node
signal changed
var items: Dictionary = {}

func add_item(id: String, amount := 1) -> void:
    items[id] = items.get(id, 0) + amount
    changed.emit()

func remove_item(id: String, amount := 1) -> bool:
    if items.get(id, 0) < amount: return false
    items[id] -= amount
    if items[id] == 0: items.erase(id)
    changed.emit()
    return true

Test: Add two berries, consume one, reopen the menu, and prove the quantity is 1. Remix: Add a capacity rule or item categories.

10Saving & loadingSerialize durable facts, validate them, and rebuild runtime state.DISK → STATE

Save facts, not active nodes.

Write only data that must survive closing the game: unlocked levels, inventory quantities, quest states, settings, and position at a safe checkpoint. Do not save velocity, timers, or temporary visual effects.

  1. Gather dictionaries, arrays, strings, numbers, and booleans.
  2. Write JSON to user://save.json.
  3. Validate missing keys with safe defaults.
  4. Rebuild scenes and UI from loaded facts.
save_manager.gd · Autoload
const PATH := "user://save.json"
const SAVE_VERSION := 1

func save_game() -> void:
    var data := {"version": SAVE_VERSION,
        "inventory": Inventory.items,
        "quests": QuestLog.states}
    var file := FileAccess.open(PATH, FileAccess.WRITE)
    file.store_string(JSON.stringify(data))

func load_game() -> Dictionary:
    if not FileAccess.file_exists(PATH): return {}
    var data = JSON.parse_string(FileAccess.get_file_as_string(PATH))
    return data if data is Dictionary else {}

Test: Save, close the whole game, reopen, load, and compare values. Also test no save file and one missing key. Remix: Add three save slots.

11Survival needsTurn time into pressure without creating unfair hidden rules.TIME → CHOICE

Make every drain readable and answerable.

Use named rates per second, clamp every meter, and give the player at least one reliable recovery action. Update continuous needs with delta; use timers for discrete ticks such as damage.

HUNGER72

A visible rate lets the player predict when to act.

survival.gd · player component
signal hunger_changed(value: float)
@export var hunger_rate := 0.8
var hunger := 100.0

func _process(delta: float) -> void:
    hunger = clampf(hunger - hunger_rate * delta, 0.0, 100.0)
    hunger_changed.emit(hunger)

func eat(nutrition: float) -> void:
    hunger = clampf(hunger + nutrition, 0.0, 100.0)

Test: Compare hunger after 30 seconds at different frame rates; results should match. Remix: Make sprinting drain hunger faster, then playtest whether the choice feels fair.

12Quests & dialogueRepresent promises as state, then let world events advance them.EVENT → STORY

A quest is a small state machine.

Use stable IDs rather than display text. A quest moves from LOCKED to ACTIVE to READY to COMPLETE. Dialogue reads that state and chooses the right line; it should not secretly own quest progress.

LOCKED→ACTIVE→READY→COMPLETE
quest_log.gd · Autoload
signal quest_updated(id: String)
var states := {"repair_radio": "locked"}

func start_quest(id: String) -> void:
    if states.get(id) == "locked":
        states[id] = "active"
        quest_updated.emit(id)

func report_event(event_id: String) -> void:
    if event_id == "radio_part_collected" \
    and states["repair_radio"] == "active":
        states["repair_radio"] = "ready"
        quest_updated.emit("repair_radio")

Test: Collect the part before and after accepting the quest. Decide intentionally whether both orders work. Remix: Add an optional objective that changes the reward.

13CutscenesCoordinate cameras, animation, dialogue, control, and a safe exit.TIME → FOCUS

Direct attention, then return control.

Use AnimationPlayer for a short timeline and method tracks for events. Disable player input—not the whole process—switch cameras, play the sequence, then restore everything from one cleanup function. A skip button should call the same cleanup.

intro_cutscene.tscnIntroCutscene · NodeAnimationPlayer · timelineCutsceneCamera · Camera3DDialogueLayer · CanvasLayerSkipButton · Button
cutscene.gd
func play_intro() -> void:
    player.input_enabled = false
    cutscene_camera.current = true
    animation_player.play("intro")
    await animation_player.animation_finished
    finish_cutscene()

func finish_cutscene() -> void:
    animation_player.stop()
    player_camera.current = true
    player.input_enabled = true
    QuestLog.report_event("intro_seen")

Test: Finish and skip the scene. In both cases, movement, camera, UI, and quest state must recover. Remix: Trigger subtitles with AnimationPlayer call-method keys.

14Crafting & recipesCheck ingredients, change inventory once, then communicate the result.RULE → TRANSFORM

A recipe is a data transformation.

Store recipe inputs and output as data. First validate every ingredient; only then remove inputs and add the output. This prevents half-finished crafts when an ingredient is missing.

2 × BERRY+1 × WATER→RESTORE TONIC
crafting.gd
func can_craft(recipe: Dictionary) -> bool:
    for id in recipe.inputs:
        if Inventory.items.get(id, 0) < recipe.inputs[id]:
            return false
    return true

func craft(recipe: Dictionary) -> bool:
    if not can_craft(recipe): return false
    for id in recipe.inputs:
        Inventory.remove_item(id, recipe.inputs[id])
    Inventory.add_item(recipe.output_id, recipe.output_amount)
    return true

Test: Try exact, extra, and insufficient ingredients. No failed attempt may remove an item. Remix: Unlock a recipe as a quest reward.

PLAN

Interactive project planner

Choose a game shape, then control the scope.

A genre does not require every familiar feature. Pick the smallest system set that can prove your idea is fun.

BUILD FIRST

Story adventure

    Scope lock
    TEACH

    Suggested pacing

    Build, test, explain, extend.

    5–10 min · Launch

    Play or inspect the system students are about to build. Name the player-facing purpose.

    10–15 min · Model

    Trace the node tree and data owner, then read the smallest useful code example together.

    25–35 min · Build

    Students follow checkpoints and run the game after every successful change.

    10 min · Remix

    Students change one variable or rule, test it, and explain the resulting behavior.

    Assessment thread: At every checkpoint, students should identify the node responsible, the data it owns, the event it responds to, and the visible evidence that it works.
    SHIP

    Final definition of done

    Signal Run is complete when…

    The final questionCan a new player understand what changed, why it mattered, and what they can do next?