Can GPT-6.1 Sol write working Godot 4 code? 15 of 15 on the first try

How the test works

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: %d" % score

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("Failed to open file for saving: %s" % path)
		return
	file.store_string(JSON.stringify(data))
	file.close()


static func load_data(path: String) -> Dictionary:
	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Failed to open file for loading: %s" % path)
		return {}
	var contents := file.get_as_text()
	file.close()
	var json := JSON.new()
	if json.parse(contents) != OK:
		push_error("Failed to parse JSON in file: %s" % path)
		return {}
	if not (json.data is Dictionary):
		push_error("JSON in file is not a Dictionary: %s" % path)
		return {}
	return json.data

Health with signals: pass

extends Node

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

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

func take_damage(amount: int) -> void:
	var old_value: int = health
	health = maxi(0, health - maxi(0, amount))
	if health != old_value:
		health_changed.emit(old_value, health)
		if health == 0 and not _has_died:
			_has_died = true
			died.emit()

Fade out with a tween: pass

extends Node2D

signal faded


func fade_out(duration: float) -> void:
	modulate.a = 1.0
	var tween := create_tween()
	tween.tween_property(self, "modulate:a", 0.0, duration)
	tween.finished.connect(func() -> void: 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.timeout.connect(_on_spawn_timer_timeout)
	add_child(spawn_timer)
	spawn_timer.start()


func _on_spawn_timer_timeout() -> void:
	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


func interact() -> void:
	if state != State.CLOSED:
		return
	state = State.OPENING
	await get_tree().create_timer(0.5, false).timeout
	state = State.OPEN


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

An inventory with counts: pass

extends RefCounted

var _items: Dictionary = {}


func add_item(item_name: String, count: int) -> void:
	if count > 0:
		_items[item_name] = get_count(item_name) + count


func remove_item(item_name: String, count: int) -> bool:
	if count < 0 or get_count(item_name) < count:
		return false
	if count > 0:
		_items[item_name] = get_count(item_name) - count
	return true


func get_count(item_name: String) -> int:
	return int(_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)
	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(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


func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var query := PhysicsRayQueryParameters2D.create(from, to)
	var hit := get_world_2d().direct_space_state.intersect_ray(query)
	if hit.is_empty():
		return to
	return hit["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 size.x <= 0 or size.y <= 0:
		return path
	if not _in_bounds(from, size) or not _in_bounds(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 queue: Array[Vector2i] = [from]
	var parents: Dictionary = {from: from}
	var head: int = 0
	var directions: Array[Vector2i] = [Vector2i.UP, Vector2i.DOWN, Vector2i.LEFT, Vector2i.RIGHT]
	while head < queue.size():
		var cell: Vector2i = queue[head]
		head += 1
		if cell == to:
			var cursor: Vector2i = to
			while cursor != from:
				path.append(cursor)
				cursor = parents[cursor]
			path.append(from)
			path.reverse()
			return path
		for direction in directions:
			var neighbor: Vector2i = cell + direction
			if not _in_bounds(neighbor, size) or blocked.has(neighbor) or parents.has(neighbor):
				continue
			parents[neighbor] = cell
			queue.append(neighbor)
	return path


func _in_bounds(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()
	add_child(player)
	player.root_node = NodePath("..")

	var animation := Animation.new()
	animation.length = 1.0
	animation.loop_mode = Animation.LOOP_LINEAR
	var track := animation.add_track(Animation.TYPE_VALUE)
	animation.track_set_path(track, NodePath(".:visible"))
	animation.value_track_set_update_mode(track, Animation.UPDATE_DISCRETE)
	animation.track_insert_key(track, 0.0, true)
	animation.track_insert_key(track, 0.5, false)

	var library := AnimationLibrary.new()
	library.add_animation("blink", animation)
	player.add_animation_library("", library)
	visible = true
	player.play("blink")

Wait for a signal or a timeout: pass

extends Node


class WaitRace:
	extends RefCounted
	signal finished(signal_won: bool)
	var settled := false

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


func wait_for(sig: Signal, seconds: float) -> bool:
	var race := WaitRace.new()
	var on_signal := func() -> void: race.settle(true)
	var on_timeout := func() -> void: race.settle(false)
	var timer := get_tree().create_timer(maxf(seconds, 0.0), false)
	sig.connect(on_signal, CONNECT_ONE_SHOT)
	timer.timeout.connect(on_timeout, CONNECT_ONE_SHOT)
	var signal_won: bool = await race.finished
	if sig.is_connected(on_signal):
		sig.disconnect(on_signal)
	if timer.timeout.is_connected(on_timeout):
		timer.timeout.disconnect(on_timeout)
	return signal_won