Can Claude Opus 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 = Vector2(SPEED, 0.0)
	else:
		velocity = Vector2.ZERO
	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 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:
	score = 0
	_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("Could not open %s for writing: %s" % [path, error_string(FileAccess.get_open_error())])
		return
	file.store_string(JSON.stringify(data, "\t"))
	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("Could not open %s for reading: %s" % [path, error_string(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
	push_error("Save file %s does not contain a JSON object" % path)
	return {}

Health with signals: pass

extends Node

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

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


func take_damage(amount: int) -> void:
	if amount <= 0 or _is_dead:
		return
	var old_value := health
	health = max(health - amount, 0)
	if health != old_value:
		health_changed.emit(old_value, health)
	if health == 0 and not _is_dead:
		_is_dead = true
		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(func() -> void: faded.emit())

Spawn on a timer, then stop: pass

extends Node

const MAX_SPAWNS := 4
const SPAWN_INTERVAL := 0.25

var spawned_count: int = 0
var _timer: Timer


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


func _on_timer_timeout() -> void:
	if spawned_count >= MAX_SPAWNS:
		_timer.stop()
		return
	var child := Node2D.new()
	child.name = "Spawned%d" % (spawned_count + 1)
	add_child(child)
	spawned_count += 1
	if spawned_count >= MAX_SPAWNS:
		_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 _process(delta: float) -> void:
	if state == State.OPENING:
		_elapsed += delta
		if _elapsed >= OPEN_DURATION:
			state = State.OPEN


func get_state_name() -> String:
	match state:
		State.CLOSED:
			return "CLOSED"
		State.OPENING:
			return "OPENING"
		_:
			return "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:
		return false
	var current := get_count(item_name)
	if current < count:
		return false
	var remaining := current - count
	if remaining == 0:
		_items.erase(item_name)
	else:
		_items[item_name] = remaining
	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 := load(path) as PackedScene
	if scene == null:
		push_error("Could not load 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

## Casts a ray from `from` to `to` (global coordinates) and returns the first
## collision point, or `to` if nothing is hit. Call from _physics_process.
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

const DIRECTIONS: Array[Vector2i] = [
	Vector2i(0, -1),
	Vector2i(0, 1),
	Vector2i(-1, 0),
	Vector2i(1, 0),
]


## Returns the shortest 4-directional path from `from` to `to` (both included),
## avoiding wall cells. Returns an empty array if no path exists.
func find_path(size: Vector2i, walls: Array[Vector2i], from: Vector2i, to: Vector2i) -> Array[Vector2i]:
	var result: Array[Vector2i] = []
	if size.x <= 0 or size.y <= 0:
		return result
	if not _in_bounds(size, from) or not _in_bounds(size, to):
		return result

	var cell_count := size.x * size.y
	var blocked := PackedByteArray()
	blocked.resize(cell_count)
	for wall in walls:
		if _in_bounds(size, wall):
			blocked[wall.y * size.x + wall.x] = 1

	var start_index := from.y * size.x + from.x
	var goal_index := to.y * size.x + to.x
	if blocked[start_index] == 1 or blocked[goal_index] == 1:
		return result

	if start_index == goal_index:
		result.append(from)
		return result

	var came_from := PackedInt32Array()
	came_from.resize(cell_count)
	came_from.fill(-1)
	came_from[start_index] = start_index

	var queue := PackedInt32Array()
	queue.append(start_index)
	var head := 0
	var found := false

	while head < queue.size():
		var current := queue[head]
		head += 1
		var cell := Vector2i(current % size.x, current / size.x)
		for dir in DIRECTIONS:
			var next := cell + dir
			if not _in_bounds(size, next):
				continue
			var next_index := next.y * size.x + next.x
			if blocked[next_index] == 1 or came_from[next_index] != -1:
				continue
			came_from[next_index] = current
			if next_index == goal_index:
				found = true
				break
			queue.append(next_index)
		if found:
			break

	if not found:
		return result

	var index := goal_index
	while index != start_index:
		result.append(Vector2i(index % size.x, index / size.x))
		index = came_from[index]
	result.append(from)
	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 _ready() -> 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)
	# The player's root_node defaults to "..", which is this node.
	anim.track_set_path(track, NodePath(".:visible"))
	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

## Resolves once, with whichever outcome arrives first.
class _Race extends RefCounted:
	signal finished(result: bool)
	var done := false

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


## Waits until `sig` is emitted or `seconds` of game time pass.
## Returns true if the signal came first, false on timeout.
func wait_for(sig: Signal, seconds: float) -> bool:
	var race := _Race.new()
	var on_signal := func() -> void: race.resolve(true)
	sig.connect(on_signal, CONNECT_ONE_SHOT)

	var tree := get_tree() if is_inside_tree() else Engine.get_main_loop() as SceneTree
	var timer := tree.create_timer(maxf(seconds, 0.0))
	timer.timeout.connect(func() -> void: race.resolve(false))

	var result: bool = await race.finished

	if is_instance_valid(sig.get_object()) and sig.is_connected(on_signal):
		sig.disconnect(on_signal)
	return result