Module 4: Part I Review and Cheat Sheet

13 min read

This module is a review and quick-reference for everything covered in Part I (Modules 1-3). Come back to this page whenever you need to look something up without re-reading the full modules.

#Part I in Review

You started Part I with nothing: no engine installed, no project, no code. Module 1 walked you through installing Godot, creating the Crystal Saga project, and understanding the mental model behind the engine: everything is a node, and nodes compose into scenes. You placed a Sprite2D on screen, configured the project for pixel art, and ran your first build. The Godot icon on a gray background doesn't look like much, but it's what everything else builds from: a project, a scene, a node, and a working feedback loop (edit, save, run, observe).

Module 2 gave you the language. You attached a script to that sprite and learned GDScript from the perspective of someone who already knows how to program. You wrote variables with static types, defined functions with return annotations, and discovered the virtual function system that drives Godot's game loop: _ready() for initialization, _process(delta) for per-frame logic. You wired up keyboard input through the Input Map and made the sprite move. By the end, your placeholder icon responded to arrow keys, moved at a consistent speed regardless of frame rate, and printed debug messages to the Output panel.

Module 3 shifted from "scripts that move things" to "scenes that are things." You built a Player scene from a CharacterBody2D with a Sprite2D and CollisionShape2D as children, learning why Godot favors composition over inheritance. You replaced direct position manipulation with move_and_slide(), switched from _process() to _physics_process(), and instanced the Player scene into your main scene. You also got your first taste of signals (Godot's decoupled event system) by connecting an Area2D's body_entered signal to a script function. The result: a reusable player character with physics-based movement that you can drop into any scene.

#Module 1: The Journey Begins

• Installed Godot 4.x and created the Crystal Saga project with the Compatibility renderer
• Learned Godot's core mental model: everything is a node, nodes compose into scenes, scenes save as .tscn files
• Explored the editor interface: Viewport, Scene dock, Inspector, FileSystem dock, Output panel
• Created a first scene with a Node2D root and a Sprite2D child, set a texture, positioned it, and saved
• Configured pixel art project settings: 640x360 viewport, 1280x720 window, canvas_items stretch mode, Nearest texture filtering

#Module 2: GDScript for Programmers

• Learned GDScript syntax: indentation-based blocks, static typing with : Type annotations, extends for inheritance
• Understood the virtual function lifecycle: _ready() runs once at initialization, _process(delta) runs every frame
• Used delta for frame-rate-independent movement and Input.get_axis() for clean directional input
• Discovered @export (expose variables in the Inspector) and @onready (safely cache node references after the tree is built)
• Used print() and the Output panel for basic debugging

#Module 3: Thinking in Scenes

• Built a reusable Player scene: CharacterBody2D with Sprite2D and CollisionShape2D children
• Learned the three physics body types (CharacterBody2D, RigidBody2D, StaticBody2D) and Area2D for detection zones
• Replaced _process() with _physics_process() and direct position changes with velocity + move_and_slide()
• Instanced the Player scene into the main scene, understanding how instancing hides internal structure
• Connected an Area2D body_entered signal through the editor, seeing how signals decouple node communication

#Key Concepts

#Cheat Sheet

#The Godot Editor

Keyboard shortcuts used so far:

#GDScript Essentials

Variables and types:

# Explicit type annotation (preferred)
var speed: float = 200.0
var player_name: String = "Aiden"
var health: int = 100
var is_alive: bool = true
var direction: Vector2 = Vector2.ZERO

# Type inference
var speed := 200.0          # inferred as float
var player_name := "Aiden"  # inferred as String

# Constants
const MAX_SPEED: float = 300.0

Common types:

Functions:

# With parameters and return type
func calculate_damage(attack: int, defense: int) -> int:
    return max(1, attack - defense)

# Void return
func take_damage(amount: int) -> void:
    health -= amount

# Default parameters
func heal(amount: int = 10) -> void:
    health = min(health + amount, max_health)

Control flow:

# Conditionals
if health <= 0:
    print("Dead")
elif health < 20:
    print("Critical!")
else:
    print("Fine")

# Loops
for i in range(5):
    print(i)

for item in inventory:
    print(item.name)

# Match (like switch/case)
match state:
    "idle":
        velocity = Vector2.ZERO
    "walk":
        velocity = direction * speed
    _:
        pass  # default case

Style rules:

• Tabs for indentation (never spaces)
• Double quotes for strings
• Two blank lines between functions
• Use and, or, not instead of &&, ||, !
• Private members prefixed with _ (convention, not enforced)

#Node and Scene Fundamentals

Node types introduced so far:

Scene composition pattern:

Player (CharacterBody2D)       <-- root: handles movement and collision
├── Sprite2D                   <-- displays the character image
└── CollisionShape2D           <-- defines the hitbox

Navigating the scene tree in code:

$Sprite2D                     # get child by name (shorthand for get_node("Sprite2D"))
$"Long Node Name"             # quote names with spaces
$UI/HealthBar                 # traverse a path: child "UI", then its child "HealthBar"
get_parent()                  # the node above this one
get_tree()                    # the SceneTree object
get_node("/root/Main/Player") # absolute path from root

Scene file conventions:

• .tscn: text scene file (human-readable, diffs well in git)
• .tres: text resource file
• Name folders and files in snake_case
• Scene and its primary script share a name: player.tscn + player.gd

#Signals

What signals do: Let nodes communicate without knowing about each other. A node emits a signal ("something happened"), connected nodes respond ("run this function").

Connecting in the editor:

1. Select the node that emits the signal
2. Click the Node tab (right side, next to Inspector)
3. Double-click the signal you want to connect
4. Choose the receiving node and click Connect

Godot generates a callback function in the receiver's script:

func _on_test_zone_body_entered(body: Node2D) -> void:
    print("Something entered the zone: ", body.name)

Key signal covered so far:

Signal cleanup: When a node is freed (removed from the tree and deleted), all its signal connections are automatically disconnected. No manual cleanup needed.

#Input Handling

The Input Map (Project --> Project Settings --> Input Map) maps named actions to physical keys:

Checking input in code:

# Is the key held down right now? (true every frame it's held)
Input.is_action_pressed("ui_right")

# Was the key just pressed this frame? (true for one frame only)
Input.is_action_just_pressed("ui_accept")

# Get a -1 to 1 axis value (clean way to get directional input)
Input.get_axis("ui_left", "ui_right")

Clean directional input pattern:

func _get_input_direction() -> Vector2:
    return Vector2(
        Input.get_axis("ui_left", "ui_right"),
        Input.get_axis("ui_up", "ui_down"),
    )

#CharacterBody2D Movement

Module 2 pattern: direct position manipulation (no collision):

extends Sprite2D

@export var speed: float = 200.0


func _process(delta: float) -> void:
    var direction := _get_input_direction()
    if direction != Vector2.ZERO:
        direction = direction.normalized()
    position += direction * speed * delta

Module 3 pattern: physics-based movement with collision:

extends CharacterBody2D

@export var speed: float = 200.0


func _physics_process(delta: float) -> void:
    var direction := Vector2(
        Input.get_axis("ui_left", "ui_right"),
        Input.get_axis("ui_up", "ui_down"),
    )
    if direction != Vector2.ZERO:
        direction = direction.normalized()
    velocity = direction * speed
    move_and_slide()

Key differences:

Why normalize? Without direction.normalized(), diagonal movement is approximately 41% faster than cardinal movement because the diagonal of a unit square is the square root of 2 (about 1.414). Normalizing makes the vector length exactly 1 in all directions.

Motion mode: Set CharacterBody2D's Motion Mode to Floating for top-down games. The default (Grounded) is for side-scrollers and adds floor/wall/ceiling logic you don't need.

#Project Settings Checklist

These settings were configured in Part I for pixel art rendering:

#Common Mistakes and Fixes

#Official Godot Documentation

Every class, method, and concept referenced in Part I, organized by category. Bookmark these; they're the official source of truth for anything not covered in this tutorial.

#Getting Started

• Introduction to Godot: engine overview and design philosophy
• First look at the editor: editor panels and layout
• Creating and importing projects: project creation and the Project Manager
• Nodes and Scenes: the core building blocks

#GDScript

• GDScript basics: complete language reference (syntax, types, features)
• GDScript style guide: official naming and formatting conventions
• Overridable functions: full list of virtual functions (_ready, _process, _enter_tree, etc.)

#Scripting and Architecture

• Nodes and scene instances: instancing scenes, composition, and reuse
• Scene tree: runtime hierarchy, node ordering, and groups
• Idle and physics processing: _process() vs _physics_process() and when to use each
• Instancing with signals: combining scene instancing with signal-based communication

#Input

• Input examples: input handling patterns and code samples
• InputEvent: how input events propagate through the scene tree

#Physics

• Physics introduction: body types, collision layers, and physics concepts

#Class References

• Node: base class for all nodes
• Node2D: base class for 2D nodes (has position, rotation, scale)
• Sprite2D: displays a 2D texture
• CharacterBody2D: player-controlled physics body with move_and_slide()
• RigidBody2D: physics-driven body with mass, friction, and forces
• StaticBody2D: immovable collision body
• Area2D: detection zone with body_entered / body_exited signals
• CollisionShape2D: defines collision boundaries for physics bodies and areas
• Camera2D: 2D camera that controls the viewport
• Label: displays text on screen
• AudioStreamPlayer: plays audio
• AnimatedSprite2D: plays frame-based sprite animations
• TileMapLayer: renders a grid of tiles (mentioned, used in Part II)
• Vector2: 2D vector used for positions, directions, and velocities
• Input: global singleton for checking input state
• RectangleShape2D: rectangular collision shape

#What's Next

In Part II: Building the World, we'll put these foundations to work. Module 5 introduces TileMapLayers, and you'll build the town of Willowbrook as a multi-layered tile map with ground, paths, water, and collision walls your player character can actually bump into.