What comes with each node

Godot runs it once, when the node first shows up in the game.

func _ready() -> void:
	body_entered.connect(_on_body_entered)

Godot runs it about 60 times a second. Movement goes here.

func _physics_process(delta: float) -> void:
	velocity.y += gravity * delta

Godot runs it every frame. For things that are not physics, like a countdown.

func _process(delta: float) -> void:
	time_left -= delta

Godot runs it when the player presses a key or clicks.

func _unhandled_input(event: InputEvent) -> void:
	if event.is_action_pressed("shoot"):
		shoot()

Removes the node from the game.

queue_free()

Puts a new node into the game, underneath this one.

var bullet := bullet_scene.instantiate()
add_child(bullet)

Grabs a child node by its name in the Scene dock.

@onready var sprite: Sprite2D = $Sprite2D

True if the node is in that group.

if body.is_in_group("Player"):
	queue_free()

Puts the node in a group from code.

add_to_group("creep")

Reaches the whole game. See the get_tree() section below.

get_tree().reload_current_scene()

Shown or hidden.

game_over_panel.visible = true

The same as setting visible to true or false.

pause_menu.show()

Tints the node. The last number is see-through, from 0 to 1.

modulate = Color(1, 1, 1, 0.45)

Draw order. Higher numbers draw on top.

z_index = 10

Where the mouse is in the game world.

look_at(get_global_mouse_position())

Where the node is, measured from its parent.

position.x += speed * delta

Where the node is in the whole world.

bullet.global_position = global_position

How far it is turned, in radians. rotation_degrees uses degrees.

bullet.rotation = rotation

Size. Vector2(2, 2) is twice as big.

scale = Vector2(2, 2)

Turns the node to face a point.

look_at(get_global_mouse_position())

How fast it is moving, and which way.

velocity.x = direction * speed

Moves by velocity and stops at walls and floors.

velocity = direction * speed
move_and_slide()

True if it is standing on something.

if Input.is_action_just_pressed("jump") and is_on_floor():
	velocity.y = jump_velocity

True if it is touching a wall.

if is_on_wall():
	direction = -direction

Sent when a body moves into the area, like the player (a CharacterBody2D). Coins, goals and hazards use this one.

body_entered.connect(_on_body_entered)

func _on_body_entered(body: Node2D) -> void:
	if body.is_in_group("Player"):
		queue_free()

Sent when a body leaves the area.

body_exited.connect(_on_body_exited)

Sent when another Area2D moves into this one, like a bullet hitting a target. A body does not set this off; that is body_entered.

area_entered.connect(_on_area_entered)

func _on_area_entered(area: Area2D) -> void:
	if area.is_in_group("bullets"):
		queue_free()

Sent when another Area2D leaves this one.

area_exited.connect(_on_area_exited)

Sent when the mouse does anything while pointing at the area.

input_event.connect(_on_input_event)

When true, the shape stops touching anything.

$CollisionShape2D.set_deferred("disabled", true)

The shape itself: a rectangle, circle or capsule.

var box := $CollisionShape2D.shape as RectangleShape2D

The picture it shows.

sprite.texture = preload("res://art/coin.png")

Mirrors the picture left to right.

sprite.flip_h = velocity.x < 0

Mirrors the picture top to bottom.

sprite.flip_v = abs(rotation) > PI / 2

How many frames sit side by side in a sprite sheet.

sprite.hframes = 4

Which frame of the sheet to show, starting at 0.

sprite.frame = 2

Starts an animation by name.

anim.play("walk")

Stops the animation.

anim.stop()

True while an animation is running.

if not anim.is_playing():
	anim.play("idle")

The name of the animation playing now.

if anim.current_animation != "walk":
	anim.play("walk")

Sent when an animation reaches its end.

anim.animation_finished.connect(_on_animation_finished)

How close the camera is. Vector2(2, 2) is zoomed in.

camera.zoom = Vector2(2, 2)

When true, the camera glides after the player instead of snapping.

camera.position_smoothing_enabled = true

Edges the camera will not scroll past.

camera.limit_left = 0
camera.limit_right = WORLD_WIDTH

Where the ray points, measured from the ray.

ray.target_position = Vector2(0, 40)

True if the ray is hitting something.

if not ledge_check.is_colliding():
	direction = -direction

The thing the ray is hitting.

var hit := ray.get_collider()

How many seconds it counts down from.

spawn_timer.wait_time = 1.5

When true, it goes off once. When false, it repeats.

shoot_timer.one_shot = true

Starts counting down.

spawn_timer.start()

Stops it early.

spawn_timer.stop()

Seconds left before it goes off.

timer_label.text = "Time: %.1f" % timer.time_left

True if it is not counting.

if shoot_timer.is_stopped():
	shoot()

Sent when it reaches zero.

spawn_timer.timeout.connect(_on_spawn_timeout)

The sound file it plays.

jump_sound.stream = preload("res://sounds/jump.wav")

Plays the sound from the start.

jump_sound.play()

Stops the sound.

music_player.stop()

True while the sound is playing.

if not music_player.playing:
	music_player.play()

Pauses the sound, and keeps its place.

music_player.stream_paused = true

Loudness. 0 is normal, lower numbers are quieter.

music_player.volume_db = -10.0

The words it shows.

score_label.text = "Score: " + str(score)

The words on the button.

play_button.text = "Play again"

When true, the button cannot be clicked.

buy_button.disabled = gold < price

Sent when the button is clicked.

play_button.pressed.connect(_on_play_pressed)

Swaps to another scene, like the next level.

get_tree().change_scene_to_file("res://level_2.tscn")

Starts this scene over.

get_tree().reload_current_scene()

When true, the game freezes.

get_tree().paused = true

A one-time timer, with no Timer node needed.

await get_tree().create_timer(2.0).timeout

The scene that is running now.

get_tree().current_scene.add_child(bullet)

Every node in a group.

for enemy in get_tree().get_nodes_in_group("enemies"):
	enemy.queue_free()