Can Pareto 26.10 write working Godot 4 code? 15 of 15 on the first try

How the test works

Pareto 26.10 in Flockbay

Move a CharacterBody2D with an input action: pass

extends CharacterBody2D


func _physics_process(_delta: float) -> void:
	velocity = Vector2(200.0, 0.0) if Input.is_action_pressed("ui_right") else Vector2.ZERO
	move_and_slide()

Fall with gravity and land on the floor: pass

extends CharacterBody2D

const GRAVITY: float = 980.0


func _physics_process(delta: float) -> void:
	if is_on_floor():
		velocity.y = 0.0
	else:
		velocity.y += GRAVITY * delta

	move_and_slide()

A score label: pass

extends Label

var score: int = 0

func _ready() -> void:
	text = "Score: 0"

func add(points: int) -> void:
	score += points
	text = "Score: %d" % score

Save and load a dictionary as JSON: pass

extends RefCounted


static func save_data(data: Dictionary, path: String) -> void:
	var file := FileAccess.open(path, FileAccess.WRITE)
	if file == null:
		push_error("Cannot open '%s' for writing: %s" % [
			path, error_string(FileAccess.get_open_error())
		])
		return

	file.store_string(JSON.stringify(data))
	file.flush()
	var write_error := file.get_error()
	file.close()

	if write_error != OK:
		push_error("Cannot save '%s': %s" % [path, error_string(write_error)])


static func load_data(path: String) -> Dictionary:
	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Cannot open '%s' for reading: %s" % [
			path, error_string(FileAccess.get_open_error())
		])
		return {}

	var text := file.get_as_text()
	var read_error := file.get_error()
	file.close()

	if read_error != OK and read_error != ERR_FILE_EOF:
		push_error("Cannot read '%s': %s" % [path, error_string(read_error)])
		return {}

	var json := JSON.new()
	if json.parse(text) != OK:
		push_error("Invalid JSON in '%s' at line %d: %s" % [
			path, json.get_error_line(), json.get_error_message()
		])
		return {}

	var data: Variant = json.data
	if not data is Dictionary:
		push_error("Expected a JSON dictionary in '%s'." % path)
		return {}

	return data

Health with signals: pass

extends Node

signal health_changed(old_value: int, new_value: int)
signal died

var health: int = 100
var _dead: bool = false

func take_damage(amount: int) -> void:
	if _dead:
		return
	var new_health = max(health - amount, 0)
	if new_health != health:
		health_changed.emit(health, new_health)
		health = new_health
		if health == 0:
			_dead = true
			died.emit()

Fade out with a tween: pass

extends Node2D

signal faded

var _fade_tween: Tween


func fade_out(duration: float) -> void:
	if _fade_tween and _fade_tween.is_valid():
		_fade_tween.kill()

	modulate.a = 1.0
	_fade_tween = create_tween()
	_fade_tween.tween_property(self, "modulate:a", 0.0, maxf(duration, 0.0))
	_fade_tween.finished.connect(faded.emit)

Spawn on a timer, then stop: pass

extends Node

var spawned_count: int = 0
var spawn_timer: Timer


func _ready() -> void:
	spawn_timer = Timer.new()
	spawn_timer.wait_time = 0.25
	spawn_timer.one_shot = false
	spawn_timer.timeout.connect(_on_spawn_timer_timeout)
	add_child(spawn_timer)
	spawn_timer.start()


func _on_spawn_timer_timeout() -> void:
	if spawned_count >= 4:
		spawn_timer.stop()
		return

	add_child(Node2D.new())
	spawned_count += 1

	if spawned_count >= 4:
		spawn_timer.stop()

A door with states: pass

extends Node

enum State { CLOSED, OPENING, OPEN }

var state: State = State.CLOSED
var open_time: float = 0.5
var timer: float = 0.0

func _process(delta: float) -> void:
    if state == State.OPENING:
        timer += delta
        if timer >= open_time:
            state = State.OPEN

func interact() -> void:
    if state == State.CLOSED:
        state = State.OPENING
        timer = 0.0

func get_state_name() -> String:
    match state:
        State.CLOSED:
            return "CLOSED"
        State.OPENING:
            return "OPENING"
        State.OPEN:
            return "OPEN"
    return "UNKNOWN"

An inventory with counts: pass

extends RefCounted

var items: Dictionary = {}

func add_item(item_name: String, count: int) -> void:
	if count <= 0:
		return
	items[item_name] = items.get(item_name, 0) + count

func remove_item(item_name: String, count: int) -> bool:
	if count <= 0:
		return false
	if not items.has(item_name):
		return false
	if items[item_name] < count:
		return false
	items[item_name] -= count
	if items[item_name] == 0:
		items.erase(item_name)
	return true

func get_count(item_name: String) -> int:
	return items.get(item_name, 0)

Load a level scene from a path: pass

extends Node


func load_level(path: String) -> Node:
	var scene: PackedScene = load(path)
	if scene == null:
		push_error("Failed to load scene: " + path)
		return null
	
	var instance: Node = scene.instantiate()
	add_child(instance)
	return instance

Paint cells on a TileMapLayer: pass

extends TileMapLayer


func paint_row(y: int, from_x: int, to_x: int) -> void:
	for x in range(mini(from_x, to_x), maxi(from_x, to_x) + 1):
		set_cell(Vector2i(x, y), 0, Vector2i(0, 0))


func is_painted(cell: Vector2i) -> bool:
	return get_cell_source_id(cell) != -1

Cast a physics ray: pass

extends Node2D
## Provides line-of-sight raycasting for a Node2D.
## Casts a ray from `from` to `to` and returns the first collision point,
## or `to` if no collision occurs.

## Returns the collision point of the first body hit, or `to` if nothing is hit.
func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var space_state := get_world_2d().direct_space_state
	var query := PhysicsRayQueryParameters2D.create(from, to)
	# Exclude this node from the raycast to avoid self-intersection.
	query.exclude = [self]
	var result := space_state.intersect_ray(query)
	if result.is_empty():
		return to
	return result.position

A path on a grid around walls: pass

extends RefCounted


func find_path(
	size: Vector2i,
	walls: Array[Vector2i],
	from: Vector2i,
	to: Vector2i
) -> Array[Vector2i]:
	var path: Array[Vector2i] = []

	if not _is_inside(from, size) or not _is_inside(to, size):
		return path

	var blocked: Dictionary = {}
	for wall in walls:
		blocked[wall] = true

	if blocked.has(from) or blocked.has(to):
		return path

	var directions: Array[Vector2i] = [
		Vector2i(0, -1),
		Vector2i(0, 1),
		Vector2i(-1, 0),
		Vector2i(1, 0),
	]

	# Breadth-first search finds a shortest path on this unweighted grid.
	# The parent map also records which cells have already been visited.
	var parents: Dictionary = {}
	parents[from] = from

	var queue: Array[Vector2i] = [from]
	var head: int = 0

	while head < queue.size():
		var current: Vector2i = queue[head]
		head += 1

		if current == to:
			var cell: Vector2i = to
			while cell != from:
				path.append(cell)
				cell = parents[cell]
			path.append(from)
			path.reverse()
			return path

		for direction in directions:
			var neighbor: Vector2i = current + direction
			if not _is_inside(neighbor, size):
				continue
			if blocked.has(neighbor) or parents.has(neighbor):
				continue

			parents[neighbor] = current
			queue.append(neighbor)

	# No route exists.
	return path


func _is_inside(cell: Vector2i, size: Vector2i) -> bool:
	return (
		cell.x >= 0
		and cell.y >= 0
		and cell.x < size.x
		and cell.y < size.y
	)

Build and play an animation in code: pass

extends Node2D


func _ready() -> void:
	var player := AnimationPlayer.new()
	player.name = "AnimationPlayer"
	add_child(player)
	player.root_node = NodePath("..")

	var blink := Animation.new()
	blink.length = 1.0
	blink.loop_mode = Animation.LOOP_LINEAR

	var track := blink.add_track(Animation.TYPE_VALUE)
	blink.track_set_path(track, NodePath(".:visible"))
	blink.value_track_set_update_mode(track, Animation.UPDATE_DISCRETE)
	blink.track_insert_key(track, 0.0, true)
	blink.track_insert_key(track, 0.5, false)

	var library := AnimationLibrary.new()
	library.add_animation("blink", blink)
	player.add_animation_library("", library)

	player.play("blink")
	player.advance(0.0)

Wait for a signal or a timeout: pass

extends Node


class _WaitRace:
	extends RefCounted

	signal finished(signal_won: bool)

	var settled: bool = false

	func resolve(signal_won: bool) -> void:
		if settled:
			return
		settled = true
		finished.emit(signal_won)


func wait_for(sig: Signal, seconds: float) -> bool:
	if seconds <= 0.0:
		return false

	var race := _WaitRace.new()
	# Respect both SceneTree pausing and Engine.time_scale.
	var timer := get_tree().create_timer(seconds, false, false, false)
	var on_signal: Callable = race.resolve.bind(true)
	var on_timeout: Callable = race.resolve.bind(false)

	sig.connect(on_signal, CONNECT_ONE_SHOT)
	timer.timeout.connect(on_timeout, CONNECT_ONE_SHOT)

	var signal_won: bool = await race.finished

	# Remove any remaining connections, including the losing callback.
	if is_instance_valid(sig.get_object()) and sig.is_connected(on_signal):
		sig.disconnect(on_signal)
	if timer.timeout.is_connected(on_timeout):
		timer.timeout.disconnect(on_timeout)

	return signal_won