Can Claude Sonnet 5.5 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

const SPEED := 200.0


func _physics_process(_delta: float) -> void:
	if Input.is_action_pressed("ui_right"):
		velocity.x = SPEED
	else:
		velocity.x = 0.0
	velocity.y = 0.0
	move_and_slide()

Fall with gravity and land on the floor: pass

extends CharacterBody2D

const GRAVITY := 980.0


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

A score label: pass

extends Label

var score: int = 0


func _ready() -> void:
	_update_text()


func add(points: int) -> void:
	score += points
	_update_text()


func _update_text() -> void:
	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("save_data: cannot open '%s' for writing (error %d)" % [path, FileAccess.get_open_error()])
		return
	file.store_string(JSON.stringify(data))
	file.close()


static func load_data(path: String) -> Dictionary:
	if not FileAccess.file_exists(path):
		return {}
	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("load_data: cannot open '%s' for reading (error %d)" % [path, FileAccess.get_open_error()])
		return {}
	var text := file.get_as_text()
	file.close()
	var parsed: Variant = JSON.parse_string(text)
	if parsed is Dictionary:
		return parsed
	return {}

Health with signals: pass

extends Node

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

var health: int = 100


func take_damage(amount: int) -> void:
	if health <= 0 or amount <= 0:
		return
	var old_value := health
	health = maxi(health - amount, 0)
	health_changed.emit(old_value, health)
	if health == 0:
		died.emit()

Fade out with a tween: pass

extends Node2D

signal faded

var _tween: Tween


func fade_out(duration: float) -> void:
	if _tween and _tween.is_valid():
		_tween.kill()
	modulate.a = 1.0
	_tween = create_tween()
	_tween.tween_property(self, "modulate:a", 0.0, duration)
	_tween.finished.connect(_on_tween_finished)


func _on_tween_finished() -> void:
	faded.emit()

Spawn on a timer, then stop: pass

extends Node

const MAX_CHILDREN := 4

var spawned_count := 0

var _timer: Timer


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


func _on_timer_timeout() -> void:
	if spawned_count >= MAX_CHILDREN:
		_timer.stop()
		return
	add_child(Node2D.new())
	spawned_count += 1
	if spawned_count >= MAX_CHILDREN:
		_timer.stop()

A door with states: pass

extends Node

enum State { CLOSED, OPENING, OPEN }

const OPEN_DURATION := 0.5

var _state: State = State.CLOSED
var _elapsed := 0.0


func interact() -> void:
	if _state == State.CLOSED:
		_state = State.OPENING
		_elapsed = 0.0


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


func _process(delta: float) -> void:
	if _state == State.OPENING:
		_elapsed += delta
		if _elapsed >= OPEN_DURATION:
			_state = State.OPEN

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] = 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
	var remaining: int = get_count(item_name) - count
	if remaining == 0:
		_items.erase(item_name)
	else:
		_items[item_name] = remaining
	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 := load(path) as PackedScene
	if scene == null:
		push_error("Could not load level scene: %s" % path)
		return null
	var level := scene.instantiate()
	add_child(level)
	return level

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


func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var space_state := get_world_2d().direct_space_state
	var query := PhysicsRayQueryParameters2D.create(from, to)
	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 result: Array[Vector2i] = []
	if not _in_bounds(size, from) or not _in_bounds(size, to):
		return result

	var blocked := {}
	for w in walls:
		blocked[w] = true
	if blocked.has(from) or blocked.has(to):
		return result

	var came_from := {from: from}
	var queue: Array[Vector2i] = [from]
	var head := 0
	var dirs: Array[Vector2i] = [Vector2i.UP, Vector2i.DOWN, Vector2i.LEFT, Vector2i.RIGHT]

	while head < queue.size():
		var current: Vector2i = queue[head]
		head += 1
		if current == to:
			break
		for d in dirs:
			var next: Vector2i = current + d
			if not _in_bounds(size, next) or blocked.has(next) or came_from.has(next):
				continue
			came_from[next] = current
			queue.append(next)

	if not came_from.has(to):
		return result

	var cell := to
	result.append(cell)
	while cell != from:
		cell = came_from[cell]
		result.append(cell)
	result.reverse()
	return result


func _in_bounds(size: Vector2i, cell: 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 _enter_tree() -> void:
	var player := AnimationPlayer.new()
	player.name = "AnimationPlayer"
	add_child(player)

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

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

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

	player.play("blink")

Wait for a signal or a timeout: pass

extends Node


class _Waiter extends RefCounted:
	signal finished(result: bool)
	var done := false

	func on_signal() -> void:
		_finish(true)

	func on_timeout() -> void:
		_finish(false)

	func _finish(result: bool) -> void:
		if done:
			return
		done = true
		finished.emit(result)


## Waits until `sig` is emitted or `seconds` of game time pass, whichever comes first.
## Returns true if the signal came first, false on timeout.
func wait_for(sig: Signal, seconds: float) -> bool:
	var waiter := _Waiter.new()
	var timer := get_tree().create_timer(seconds)
	sig.connect(waiter.on_signal)
	timer.timeout.connect(waiter.on_timeout)

	var result: bool = await waiter.finished

	if sig.is_connected(waiter.on_signal):
		sig.disconnect(waiter.on_signal)
	if timer.timeout.is_connected(waiter.on_timeout):
		timer.timeout.disconnect(waiter.on_timeout)
	return result