GDScript Randomness Practice

Short answer: Not usually. In Godot 4, the global RNG is automatically randomized on startup.

# Godot 4: Global RNG already seeded — just use it
var damage := randi_range(8, 12)
var spawn_delay := randf_range(0.5, 2.0)
var random_dir := Vector2.from_angle(randf() * TAU)

Call randomize() only if you need to reseed intentionally (and only once). Use seed(12345) for deterministic runs.

Note: RandomNumberGenerator.new() uses a fixed seed by default. Call rng.randomize() if you want non-deterministic behavior from local instances.

var rng := RandomNumberGenerator.new()

func start_run(seed_value: int) -> void:
    rng.seed = seed_value  # Same seed = same sequence

func roll_loot() -> int:
    return rng.randi_range(1, 100)

Use seeded RNG for:

• Replays that play back identically
• Daily challenges (everyone gets the same seed)
• Debugging (reproduce exact sequences)
• Keeping loot/AI separate from cosmetic randomness
• Procedural scene instancing with repeatable layouts

Save and Restore RNG State

For checkpoints or debugging a specific roll without consuming RNG calls:

var rng := RandomNumberGenerator.new()
rng.seed = 999

var checkpoint := rng.state
var a := rng.randi()

rng.state = checkpoint
var b := rng.randi()  # b == a

Warning: Only set state to values from the state property itself — never arbitrary values.

Godot 4 provides Array.pick_random() as the straightforward way. For more array patterns like filtering and sorting, see the arrays & loops page.

var enemies := ["slime", "bat", "ghost"]
var enemy := enemies.pick_random()

Tip: Check array.size() > 0 before picking to avoid issues with empty arrays.

Quick Method: rand_weighted()

RandomNumberGenerator.rand_weighted() returns a weighted index given a PackedFloat32Array:

var rng := RandomNumberGenerator.new()
rng.seed = 12345

var items := ["gold", "potion", "rare_gem"]
var weights := PackedFloat32Array([70.0, 25.0, 5.0])

var item := items[rng.rand_weighted(weights)]

Manual Method (Full Control)

For custom logic or when you need to understand the algorithm:

var drop_table := [
    { "item": "gold", "weight": 70 },
    { "item": "potion", "weight": 25 },
    { "item": "rare_gem", "weight": 5 },
]

func pick_drop() -> String:
    var total_weight := 0
    for entry in drop_table:
        total_weight += entry["weight"]

    var roll := randi_range(1, total_weight)
    var cumulative := 0
    for entry in drop_table:
        cumulative += entry["weight"]
        if roll <= cumulative:
            return entry["item"]
    return drop_table[-1]["item"]  # Fallback

True randomness often feels streaky — you might get the same fruit three times in a row. The shuffle bag pattern fixes this by removing items after selection:

var items_backup := ["apple", "orange", "pear", "banana"]
var items_bag: Array[String] = []

func pick_fair_item() -> String:
    if items_bag.is_empty():
        items_bag = items_backup.duplicate()
        items_bag.shuffle()
    return items_bag.pop_front()

Use for: Loot that should feel "fair," wave composition, upgrade pools.

Limitation: Items can still "ping-pong" at bag boundaries (last item of one bag, first of next).

Random directions rely on vector math fundamentals—from_angle() and normalized() are the building blocks.

# Random unit vector (any direction)
var dir := Vector2.from_angle(randf() * TAU)

# Random point in a circle
func random_in_circle(radius: float) -> Vector2:
    var angle := randf() * TAU
    var dist := sqrt(randf()) * radius  # sqrt for uniform distribution
    return Vector2.from_angle(angle) * dist