Nodes, scenes & signals

 root (Window)
 ├─ EventBus            autoload, added first, in list order
 ├─ Music               autoload scene
 └─ Main                current scene (main.tscn)
    ├─ World
    │  ├─ Player        instance of player.tscn
    │  │  ├─ Sprite2D
    │  │  └─ CollisionShape2D
    │  └─ Enemies       enemies added at runtime
    └─ HUD (CanvasLayer)
       └─ HealthBar     unique name: %HealthBar

 instantiate()          for each node in the scene file:
   _init()                constructor; no parent, no tree
   (exported / saved properties assigned, setters run)
   children attached      still outside the tree
 
 add_child(scene_root)  enters the tree:
   _enter_tree()          TOP-DOWN   Main, World, Player,
                                     Sprite2D, ..., HUD
   _ready()               BOTTOM-UP  Sprite2D, Player, World,
                                     ..., HUD, Main
                          once per node (request_ready()
                          to run it again on re-entry)
 
 every frame (main loop):
   input callbacks        _input, _unhandled_input ...
   _physics_process(dt)   0..n times, fixed rate (60 Hz)
   _process(dt)           once, variable dt
   (tree order within each pass; process_priority first)
   draw
 
 queue_free()           at the end of the frame:
   _exit_tree()           BOTTOM-UP  children before parents
   NOTIFICATION_PREDELETE then memory freed

func _notification(what: int) -> void:
    match what:
        NOTIFICATION_PREDELETE:
            print("about to be freed")
        NOTIFICATION_WM_CLOSE_REQUEST:
            save_game()            # window close button
            get_tree().quit()
        NOTIFICATION_APPLICATION_FOCUS_OUT:
            get_tree().paused = true
        NOTIFICATION_PAUSED, NOTIFICATION_UNPAUSED:
            pass

@onready var sprite: Sprite2D = $Sprite2D
@onready var gun := $Arm/Gun as Gun           # typed cast
@onready var bar: ProgressBar = %HealthBar    # unique name
@onready var label := $"UI/Score Label"       # spaces: quote
 
func _ready() -> void:
    var p := get_node("Arm/Gun")        # same as $Arm/Gun
    var up := get_node("../Sibling")    # relative
    var abs_node := get_node("/root/Main/World")
    var maybe := get_node_or_null("Shield")  # no error
    if has_node("Shield"):
        pass
    var btn := find_child("StartButton", true, false)
    var all_buttons := find_children("*", "Button")
    var parent := get_parent()
    var kids := get_children()

const BULLET := preload("res://weapons/bullet.tscn")
@export var enemy_scene: PackedScene   # set in inspector
 
func shoot() -> void:
    var b := BULLET.instantiate() as Bullet
    b.direction = Vector2.RIGHT.rotated(global_rotation)
    b.global_position = $Muzzle.global_position
    get_tree().current_scene.add_child(b)  # not a child
                                           # of the gun
 
func spawn(at: Vector2) -> Enemy:
    var e: Enemy = enemy_scene.instantiate()
    e.position = at                # set before add_child
    $Enemies.add_child(e)          # _ready runs here
    return e

# Inside physics callbacks (body_entered etc.) the physics
# state is locked; defer structural and shape changes.
func _on_body_entered(body: Node2D) -> void:
    $CollisionShape2D.set_deferred("disabled", true)
    var drop := LOOT.instantiate()
    drop.position = position
    get_parent().add_child.call_deferred(drop)
    queue_free()

[gd_scene format=3 uid="uid://b6x3coinexample"]
 
[ext_resource type="Script" path="res://coin.gd" id="1_s"]
 
[sub_resource type="CircleShape2D" id="Circle_1"]
radius = 8.0
 
[node name="Coin" type="Area2D"]
script = ExtResource("1_s")
 
[node name="Shape" type="CollisionShape2D" parent="."]
shape = SubResource("Circle_1")

func _ready() -> void:
    add_to_group("enemies")        # or Node dock > Groups
    add_to_group("saveable", true) # persistent: saved
 
func _on_bomb_exploded() -> void:
    get_tree().call_group("enemies", "take_damage", 50)
    for e in get_tree().get_nodes_in_group("enemies"):
        if e.global_position.distance_to(pos) < 200.0:
            e.queue_free()
    var player := get_tree() \
        .get_first_node_in_group("player")
    print(is_in_group("enemies"))

signal health_changed(current: int, max: int)
signal died
 
func _ready() -> void:
    health_changed.connect(_on_health_changed)
    $Timer.timeout.connect(_spawn)
    # bind appends extra args after the signal's own args
    for i in $Slots.get_child_count():
        var b: Button = $Slots.get_child(i)
        b.pressed.connect(_on_slot_pressed.bind(i))
    died.connect(_on_died, CONNECT_ONE_SHOT)
    # unbind(1) drops the signal's argument
    $Check.toggled.connect(_refresh.unbind(1))
 
func damage(n: int) -> void:
    hp -= n
    health_changed.emit(hp, max_hp)
 
func _on_slot_pressed(index: int) -> void:
    print("slot ", index)

extends Node
# Registered as autoload "EventBus"
 
signal coin_collected(value: int)
signal player_died
signal level_finished(next_level: String)

# Anywhere:
EventBus.coin_collected.emit(10)
EventBus.player_died.connect(_on_player_died)
var bus := get_node("/root/EventBus")   # explicit path

get_tree().change_scene_to_file("res://levels/level_2.tscn")
 
const MENU := preload("res://ui/menu.tscn")
get_tree().change_scene_to_packed(MENU)
 
get_tree().reload_current_scene()
get_tree().quit()          # optional exit code

# Timer node: repeating, pausable, editable in the inspector
@onready var spawn_timer: Timer = $SpawnTimer
 
func _ready() -> void:
    spawn_timer.wait_time = 2.0
    spawn_timer.one_shot = false
    spawn_timer.timeout.connect(_spawn)
    spawn_timer.start()     # start(5.0) overrides wait_time
    print(spawn_timer.time_left)

func toggle_pause() -> void:
    get_tree().paused = not get_tree().paused
 
# On the pause menu (or set it in the inspector):
func _ready() -> void:
    process_mode = Node.PROCESS_MODE_WHEN_PAUSED

class_name EnemyStats
extends Resource
 
@export var display_name := "Slime"
@export var max_hp := 10
@export_range(0.0, 400.0) var speed := 60.0
@export var sprite: Texture2D
@export var drops: Array[ItemData] = []
 
# Every _init parameter needs a default, or the editor
# cannot create the resource.
func _init(p_hp := 10) -> void:
    max_hp = p_hp

extends CharacterBody2D
 
@export var stats: EnemyStats   # drag slime.tres here
var hp: int
 
func _ready() -> void:
    hp = stats.max_hp           # copy mutable state out
    $Sprite2D.texture = stats.sprite

class_name HealthComponent
extends Node
 
signal changed(current: int, maximum: int)
signal depleted
 
@export var maximum := 10
@onready var current := maximum
 
func damage(amount: int) -> void:
    if current <= 0:
        return
    current = maxi(current - amount, 0)
    changed.emit(current, maximum)
    if current == 0:
        depleted.emit()

# The owner wires components together
@onready var health: HealthComponent = $HealthComponent
 
func _ready() -> void:
    health.depleted.connect(queue_free)
    health.changed.connect(%HealthBar.set_value.unbind(1))

extends Node2D
 
@export var scene: PackedScene
@export var interval := 1.5
@export var max_alive := 10
@export var area := Rect2(-200, -200, 400, 400)
 
func _ready() -> void:
    var t := Timer.new()
    t.wait_time = interval
    t.timeout.connect(_spawn)
    add_child(t)
    t.start()
 
func _spawn() -> void:
    if get_tree().get_nodes_in_group("spawned").size() \
            >= max_alive:
        return
    var n: Node2D = scene.instantiate()
    n.position = area.position + Vector2(
        randf() * area.size.x, randf() * area.size.y)
    n.add_to_group("spawned")
    add_child(n)

class_name StateMachine
extends Node
 
@export var initial: State
var current: State
 
func _ready() -> void:
    for child in get_children():
        if child is State:
            child.machine = self
    current = initial
    current.enter()
 
func _physics_process(delta: float) -> void:
    current.physics_update(delta)
 
func transition(to: StringName) -> void:
    var next := get_node_or_null(NodePath(to)) as State
    if next == null or next == current:
        return
    current.exit()
    current = next
    current.enter()

class_name State
extends Node
 
var machine: StateMachine
@onready var actor: CharacterBody2D = owner  # scene root
 
func enter() -> void: pass
func exit() -> void: pass
func physics_update(_delta: float) -> void: pass

extends CanvasLayer
 
@onready var rect: ColorRect = $ColorRect
 
func _ready() -> void:
    layer = 100
    process_mode = Node.PROCESS_MODE_ALWAYS
    rect.modulate.a = 0.0
 
func go(path: String, time := 0.3) -> void:
    var t := create_tween()
    t.tween_property(rect, "modulate:a", 1.0, time)
    await t.finished
    get_tree().change_scene_to_file(path)
    await get_tree().process_frame   # new scene added
    t = create_tween()
    t.tween_property(rect, "modulate:a", 0.0, time)
 
# Transition.go("res://levels/level_2.tscn")

extends Control
 
func _ready() -> void:
    process_mode = Node.PROCESS_MODE_ALWAYS
    hide()
 
func _unhandled_input(event: InputEvent) -> void:
    if event.is_action_pressed("ui_cancel"):
        var paused := not get_tree().paused
        get_tree().paused = paused
        visible = paused
        get_viewport().set_input_as_handled()

extends Node
 
const DIR := "res://data/items/"
var by_id: Dictionary[StringName, ItemData] = {}
 
func _ready() -> void:
    # list_directory also sees remapped files in exports
    for file in ResourceLoader.list_directory(DIR):
        if not file.ends_with(".tres"):
            continue
        var item := load(DIR + file) as ItemData
        if item:
            by_id[item.id] = item
 
func get_item(id: StringName) -> ItemData:
    return by_id.get(id)