Can Claude Haiku 5.5 write working Godot 4 code? 14 of 15 on the first try

How the test works

Claude Haiku 5.5 in Flockbay

Move a CharacterBody2D with an input action: pass

extends CharacterBody2D

const SPEED: float = 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 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("save_game: could not 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):
		push_warning("save_game: file '%s' does not exist" % path)
		return {}
	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("save_game: could not open '%s' for reading (error %d)" % [path, FileAccess.get_open_error()])
		return {}
	var text := file.get_as_text()
	file.close()
	var parsed = JSON.parse_string(text)
	if typeof(parsed) != TYPE_DICTIONARY:
		push_error("save_game: '%s' does not contain a valid JSON dictionary" % path)
		return {}
	return parsed

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 amount <= 0 or health <= 0:
		return

	var old_value := health
	health = maxi(health - amount, 0)

	if health != old_value:
		health_changed.emit(old_value, health)

	if old_value > 0 and health == 0:
		died.emit()

Fade out with a tween: pass

extends Node2D

signal faded

func fade_out(duration: float) -> void:
	var tween := create_tween()
	tween.tween_property(self, "modulate:a", 0.0, duration).from(1.0)
	tween.finished.connect(func() -> void: faded.emit())

Spawn on a timer, then stop: pass

extends Node

const MAX_SPAWNS: int = 4
const SPAWN_INTERVAL: float = 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 node := Node2D.new()
	node.name = "Spawned_%d" % (spawned_count + 1)
	add_child(node)
	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: float = 0.5

var state: State = State.CLOSED
var _elapsed: float = 0.0


func _ready() -> void:
	set_process(false)


func _process(delta: float) -> void:
	if state != State.OPENING:
		set_process(false)
		return

	_elapsed += delta
	if _elapsed >= OPEN_DURATION:
		_elapsed = 0.0
		state = State.OPEN
		set_process(false)


func interact() -> void:
	if state != State.CLOSED:
		return

	state = State.OPENING
	_elapsed = 0.0
	set_process(true)


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] = get_count(item_name) + count


func remove_item(item_name: String, count: int) -> bool:
	if count <= 0:
		return false
	var current: int = get_count(item_name)
	if current < count:
		return false
	var remaining: int = current - 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("LevelLoader: failed to load scene at '%s'" % path)
		return null

	var instance := scene.instantiate()
	if instance == null:
		push_error("LevelLoader: failed to instantiate scene at '%s'" % path)
		return null

	add_child(instance)
	return instance

Paint cells on a TileMapLayer: pass

extends TileMapLayer

const PAINT_SOURCE_ID: int = 0
const PAINT_ATLAS_COORDS: Vector2i = Vector2i(0, 0)


## Paints cells from (from_x, y) to (to_x, y), inclusive, with source 0 and atlas (0, 0).
## If from_x is greater than to_x, the range is still painted.
func paint_row(y: int, from_x: int, to_x: int) -> void:
	var start_x: int = mini(from_x, to_x)
	var end_x: int = maxi(from_x, to_x)
	for x in range(start_x, end_x + 1):
		set_cell(Vector2i(x, y), PAINT_SOURCE_ID, PAINT_ATLAS_COORDS)


## Returns true if the cell currently has a tile.
func is_painted(cell: Vector2i) -> bool:
	return get_cell_source_id(cell) != -1

Cast a physics ray: pass

extends Node2D


# Casts a physics ray from `from` to `to` through the 2D world.
# Returns the point of the first collider hit, or `to` if nothing is hit.
# Must be called during physics processing (_physics_process), since
# direct_space_state is only valid during the physics step.
func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var world := get_world_2d()
	if world == null:
		return to

	var space_state := world.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

# Returns the shortest 4-directional path of grid cells from `from` to `to`
# (both included) on a grid of `size` cells, never entering a wall cell.
# Returns an empty array if no path exists or the endpoints are invalid.
@warning_ignore("integer_division")
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 blocked := {}
	for w in walls:
		blocked[w] = true

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

	if from == to:
		result.append(from)
		return result

	var total := size.x * size.y
	var parent := PackedInt32Array()
	parent.resize(total)
	parent.fill(-1)

	var start_i := _idx(size, from)
	var goal_i := _idx(size, to)
	parent[start_i] = start_i

	var queue := PackedInt32Array([start_i])
	var head := 0
	var found := false
	var dirs: Array[Vector2i] = [
		Vector2i(1, 0),
		Vector2i(-1, 0),
		Vector2i(0, 1),
		Vector2i(0, -1),
	]

	while head < queue.size() and not found:
		var cur := queue[head]
		head += 1
		var cp := Vector2i(cur % size.x, cur / size.x)

		for d in dirs:
			var np: Vector2i = cp + d
			if not _in_bounds(size, np) or blocked.has(np):
				continue
			var ni := _idx(size, np)
			if parent[ni] != -1:
				continue
			parent[ni] = cur
			if ni == goal_i:
				found = true
				break
			queue.append(ni)

	if not found:
		return result

	var idx := goal_i
	while idx != start_i:
		result.push_front(Vector2i(idx % size.x, idx / size.x))
		idx = parent[idx]
	result.push_front(from)

	return result


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


func _idx(size: Vector2i, p: Vector2i) -> int:
	return p.y * size.x + p.x

Build and play an animation in code: pass after one fix

Godot Engine v4.7.2.stable.mono.official.ed1daf0bf - https://godotengine.org

SCRIPT ERROR: Invalid call. Nonexistent function 'track_set_update_mode' in base 'Animation'.
   at: _ready (res://blinker.gd:21)
   GDScript backtrace (most recent call first):
       [0] _ready (res://blinker.gd:21)
       [1] _ready (res://bench_check.gd:10)
BENCH FAIL: visible at 0.25, 0.75, 1.25 and 1.75 s was [true, true, true, true], expected [true, false, true, false]

Wait for a signal or a timeout: pass

extends Node


## Waits until `sig` is emitted or `seconds` of game time pass, whichever comes first.
## Returns true if the signal was emitted first, false if the timeout came first.
func wait_for(sig: Signal, seconds: float) -> bool:
	# A Dictionary is shared by reference with the lambdas, so they can update it.
	var state := {"done": false, "signal_first": false}

	var timer := get_tree().create_timer(seconds)

	var on_signal := func() -> void:
		if state["done"]:
			return
		state["done"] = true
		state["signal_first"] = true

	var on_timeout := func() -> void:
		if state["done"]:
			return
		state["done"] = true

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

	while not state["done"]:
		await get_tree().process_frame

	# Clean up whichever connection did not fire.
	if sig.is_connected(on_signal):
		sig.disconnect(on_signal)
	if timer.timeout.is_connected(on_timeout):
		timer.timeout.disconnect(on_timeout)

	return state["signal_first"]