Learning GDScript Programming

GDScript is the scripting language of Godot Engine. It runs on the Node system, which is the fundamental building block of Godot games. Every game element is a Node.

Basic Script Structure

extends CharacterBody2D

const SPEED = 300.0
var velocity = Vector2.ZERO

func _physics_process(delta):
    var direction = Input.get_axis("ui_left", "ui_right")
    velocity.x = direction * SPEED
    move_and_slide()

Core Concepts

• extends - Inherit from a Godot Node class
• _ready() - Called when node enters the scene tree
• _process(delta) - Called every frame for game logic
• _physics_process(delta) - Called at fixed timestep for physics

Getting Child Nodes

func _ready():
    var sprite = get_node("Sprite2D")
    var collision = $CollisionShape2D  # Shorthand syntax
    var parent = get_parent()
    var root = get_tree().root

Node Paths & References

@onready var sprite = $Sprite2D  # Resolved after _ready()
var player = get_node("/root/Level/Player")

Key Takeaway: Everything in Godot is a node. Master node paths and you'll master Godot.

Signals are Godot's event system. They allow objects to communicate without tight coupling. This is the most powerful feature for building scalable game architectures.

Declaring & Emitting Signals

extends Node

signal health_changed(new_health)
signal player_died
signal item_collected(item_name)

var health = 100:
    set(value):
        health = max(0, value)
        health_changed.emit(health)
        if health == 0:
            player_died.emit()

Connecting Signals in Code

func _ready():
    var player = get_node("/root/Player")
    player.health_changed.connect(_on_player_health_changed)
    player.player_died.connect(_on_player_died)

func _on_player_health_changed(new_health):
    print("Health is now: ", new_health)
    update_health_bar(new_health)

func _on_player_died():
    print("Game Over!")
    get_tree().reload_current_scene()

Common Mistake: Memory Leaks

func _exit_tree():
    # Always disconnect signals when node is freed
    var player = get_node_or_null("/root/Player")
    if player:
        player.health_changed.disconnect(_on_player_health_changed)

Key Takeaway: Signals decouple your code. Use them for all communication between game systems.

GDScript provides intuitive control flow with if/else, loops, and powerful pattern matching with match statements.

# If/else
var health = 50
if health > 75:
    print("Healthy")
elif health > 25:
    print("Wounded")
else:
    print("Critical")

# For loops
for i in range(5):
    print(i)

for item in ["sword", "shield", "potion"]:
    print(item)

# While loops
var count = 0
while count < 3:
    print(count)
    count += 1

# Match statement (pattern matching)
var direction = "north"
match direction:
    "north":
        print("Going up")
    "south":
        print("Going down")
    "east", "west":
        print("Going sideways")
    _:
        print("Unknown direction")

Godot provides built-in physics nodes for realistic movement and collision detection in 2D and 3D games.

extends CharacterBody2D

var speed = 200
var jump_velocity = -400
var gravity = 980

func _physics_process(delta):
    # Apply gravity
    if not is_on_floor():
        velocity.y += gravity * delta
    
    # Handle jump
    if Input.is_action_just_pressed("jump") and is_on_floor():
        velocity.y = jump_velocity
    
    # Handle movement
    var direction = Input.get_axis("move_left", "move_right")
    velocity.x = direction * speed
    
    move_and_slide()

# Collision detection with Area2D
func _on_Area2D_body_entered(body):
    if body.is_in_group("enemies"):
        print("Hit enemy!")
        body.take_damage(10)

# Raycasting
func check_line_of_sight(target_pos):
    var space_state = get_world_2d().direct_space_state
    var query = PhysicsRayQueryParameters2D.create(global_position, target_pos)
    var result = space_state.intersect_ray(query)
    return result.size() > 0

Animate sprites and properties using AnimationPlayer for complex sequences and Tweens for smooth interpolations.

extends Sprite2D

@onready var animation_player = $AnimationPlayer

func _ready():
    # Play animation from AnimationPlayer
    animation_player.play("walk")

# Tween for smooth property animation
func fade_out():
    var tween = create_tween()
    tween.tween_property(self, "modulate:a", 0.0, 1.0)
    tween.tween_callback(queue_free)

func move_to_position(target_pos):
    var tween = create_tween()
    tween.set_trans(Tween.TRANS_CUBIC)
    tween.set_ease(Tween.EASE_IN_OUT)
    tween.tween_property(self, "position", target_pos, 2.0)

# Chain multiple tweens
func bounce_effect():
    var tween = create_tween()
    tween.tween_property(self, "scale", Vector2(1.2, 1.2), 0.2)
    tween.tween_property(self, "scale", Vector2(1.0, 1.0), 0.2)

# Sprite sheet animation
func animate_sprite():
    var tween = create_tween().set_loops()
    for frame in range(4):
        tween.tween_callback(func(): $Sprite.frame = frame)
        tween.tween_interval(0.1)

Godot's UI system uses Control nodes with flexible layout containers for responsive interfaces.

extends Control

@onready var label = $VBoxContainer/Label
@onready var button = $VBoxContainer/Button
@onready var progress_bar = $VBoxContainer/ProgressBar

func _ready():
    # Connect button signal
    button.pressed.connect(_on_button_pressed)
    
    # Set initial values
    label.text = "Welcome!"
    progress_bar.value = 50

func _on_button_pressed():
    label.text = "Button clicked!"
    
    # Animate progress bar
    var tween = create_tween()
    tween.tween_property(progress_bar, "value", 100, 1.0)

# Dynamic UI creation
func create_menu_buttons(items: Array):
    var container = $VBoxContainer
    for item in items:
        var btn = Button.new()
        btn.text = item
        btn.pressed.connect(_on_menu_item_selected.bind(item))
        container.add_child(btn)

func _on_menu_item_selected(item: String):
    print("Selected: ", item)

Resources are reusable data containers. Autoloads create global singletons accessible from anywhere.

# Custom Resource (ItemData.gd)
class_name ItemData
extends Resource

@export var item_name: String
@export var icon: Texture2D
@export var value: int

# Preload resources
const SWORD = preload("res://items/sword.tres")
const POTION = preload("res://items/potion.tres")

func _ready():
    print(SWORD.item_name)  # Access preloaded data

# Autoload singleton (GameManager.gd)
# Add to Project Settings > Autoload
extends Node

var score := 0
var player_name := ""
var current_level := 1

signal score_changed(new_score)

func add_score(points: int):
    score += points
    score_changed.emit(score)

func save_game():
    var save_data = {
        "score": score,
        "level": current_level,
        "name": player_name
    }
    # Save logic here

# Access from anywhere:
# GameManager.add_score(100)

Master advanced GDScript features including Callables, lambdas, and asynchronous patterns for sophisticated game logic.

extends Node

# Callables (function references)
func _ready():
    var my_callable = Callable(self, "my_function")
    my_callable.call()
    
    # Lambda functions
    var double = func(x): return x * 2
    print(double.call(5))  # 10
    
    # Higher-order functions
    var numbers = [1, 2, 3, 4, 5]
    var squared = numbers.map(func(x): return x * x)
    print(squared)  # [1, 4, 9, 16, 25]

func my_function():
    print("Called!")

# Async patterns with await
func attack_sequence():
    print("Wind up")
    await get_tree().create_timer(0.5).timeout
    print("Strike!")
    await get_tree().create_timer(0.3).timeout
    print("Recovery")

# Coroutine pattern
func fade_and_destroy():
    while modulate.a > 0:
        modulate.a -= 0.01
        await get_tree().process_frame
    queue_free()

# Custom signals with parameters
signal enemy_died(enemy_type: String, position: Vector2)

func _on_enemy_killed():
    enemy_died.emit("goblin", global_position)