【Godot】A Thorough Guide to Scenes and Nodes

Overview

When starting game development with Godot Engine, the most important concepts everyone should learn first are "Scene" and "Node." Understanding the relationship between these two is the key to mastering Godot.

---

What is a Node? - The "Components" That Build Your Game

A node is the basic building block of games in Godot—a "component." Each node has specific functionality.

• Sprite2D: Displays an image
• AudioStreamPlayer: Plays audio
• CollisionShape2D: Defines physical collision bounds (hitbox)
• Button: A clickable UI button
• Camera2D: A camera for 2D games

These are just a few examples—Godot provides hundreds of specialized nodes. By combining these "components," you build all objects and systems in your game.

---

What is a Scene? - A "Blueprint" of Assembled Components

A scene is these nodes combined in a hierarchical tree structure. It consists of one "root node" and multiple "child nodes" connected to it. This collection of nodes forms a "scene," representing all elements in your game: characters, stages, UI screens, and more.

Concrete Example: A "Player" Scene in a 2D Game

For example, when creating a "Player" scene, you might combine nodes like this:

CharacterBody2D (root node: manages physics behavior and movement)
├── Sprite2D (child node: displays player appearance)
├── CollisionShape2D (child node: defines collision shape)
└── Camera2D (child node: camera that follows the player)

This is how multiple nodes (components) combine into one cohesive unit called a "scene." Created scenes are saved as files with the .tscn extension.

---

Scene Instancing - "Nesting" Scenes

Godot's true power lies in "scene instancing"—the ability to reuse created scenes as components (nodes) in other scenes. This isn't simple copy-paste; it maintains a reference to the original scene (blueprint).

Concrete Example: Placing a "Player" in a "Stage" Scene

Let's place the "Player" scene (player.tscn) we created earlier into another scene called "Stage1."

Node2D (Stage1 root)
├── TileMap (terrain and background)
├── Player (instance of player.tscn)
├── Enemy1 (instance of enemy.tscn)
└── Enemy2 (instance of enemy.tscn)

Benefits of Instancing

• Reusability: A "Player" scene created once can easily be reused in "Stage2," "Boss Battle," and various other places.
• Maintainability: To change the player's movement speed, edit player.tscn once and the modification reflects across all player instances.
• Encapsulation: The "Stage1" scene doesn't need to know about the player's internal node structure.

---

Common Mistakes and Best Practices

Common Mistake	Best Practice
Giant monolithic scenes	Split into small, specialized scenes. Actively create scenes for reusable units like players, enemies, bullets, UI elements, and combine them to build larger scenes.
Depending on fragile node paths	Maintain loose coupling with signals and method calls. Paths that depend on structure like get_node('../../Player/Camera2D') are extremely fragile to changes.
Excessive polling in _process	Think event-driven. Handle input with _input() or _unhandled_input(), detect physical collisions with body signals—make code execute only when needed.
Overusing get_node()	Cache node references with @onready. Holding node references before _ready is called keeps code clean.

Performance-Conscious Scene Design

As projects grow larger, performance becomes an undeniable concern.

• Node Count: The number of nodes in a scene, especially those processing every frame, directly affects CPU load.
• get_node() Call Cost: Avoid calling get_node() inside loops like _process. @onready is the simplest solution to this problem.
• Physics Calculation Cost: Be careful not to apply physics bodies to decorative objects that don't need collision detection.

---

Practical Code Examples

1. Caching Node References with @onready

# PlayerAnimation.gd
@onready var sprite: Sprite2D = $Sprite2D
@onready var anim_player: AnimationPlayer = $AnimationPlayer

func _physics_process(delta):
    var velocity = get_parent().velocity
    if velocity.length() > 0:
        anim_player.play("run")
    else:
        anim_player.play("idle")

    if velocity.x != 0:
        sprite.flip_h = velocity.x < 0

2. Dynamic Scene Instancing

# Player.gd
const BULLET_SCENE = preload("res://bullet.tscn")

@onready var muzzle = $Muzzle

func _process(delta):
    if Input.is_action_just_pressed("shoot"):
        var bullet = BULLET_SCENE.instantiate()
        # Add bullet as child of main scene (not player)
        get_tree().current_scene.add_child(bullet)
        bullet.global_position = muzzle.global_position

Use preload to load the scene file, then call instantiate() at the needed timing.

Summary

• Node: The smallest building block of games—a "component." Each has specific functionality.
• Scene: A "blueprint" with nodes assembled in a tree structure. Composes concrete game elements like characters and stages.
• Instancing: Reusing created scenes as "components" in other scenes.

Game development in Godot follows this flow: combine "nodes" to create "scenes," then combine those "scenes" to build larger "scenes (the entire game)."