Can GPT-5.4 write working Godot 4 code? 14 of 15 on the first try

How the test works

GPT-5.4 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: float = 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:
	text = "Score: 0"

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

Save and load a dictionary as JSON: pass

extends RefCounted

class_name SaveGame


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 writing: %s" % path)
		return

	var json_text := JSON.stringify(data)
	file.store_string(json_text)
	file.close()


static func load_data(path: String) -> Dictionary:
	if not FileAccess.file_exists(path):
		push_error("File does not exist: %s" % path)
		return {}

	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Failed to open file for reading: %s" % path)
		return {}

	var json_text := file.get_as_text()
	file.close()

	var json := JSON.new()
	var parse_error := json.parse(json_text)
	if parse_error != OK:
		push_error("Failed to parse JSON from file: %s" % path)
		return {}

	var data = json.data
	if data is Dictionary:
		return data

	push_error("JSON root is not a Dictionary in file: %s" % path)
	return {}

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:
	if amount <= 0:
		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 _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 _timer: Timer


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


func _on_timer_timeout() -> void:
	if spawned_count >= 4:
		_timer.stop()
		return

	var child := Node2D.new()
	add_child(child)
	spawned_count += 1

	if spawned_count >= 4:
		_timer.stop()

A door with states: pass

extends Node

enum DoorState {
	CLOSED,
	OPENING,
	OPEN,
}

var _state: DoorState = DoorState.CLOSED

func interact() -> void:
	if _state != DoorState.CLOSED:
		return

	_state = DoorState.OPENING
	var timer := get_tree().create_timer(0.5)
	timer.timeout.connect(_on_open_timer_timeout)

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

func _on_open_timer_timeout() -> void:
	if _state == DoorState.OPENING:
		_state = DoorState.OPEN

An inventory with counts: pass

extends RefCounted
class_name Inventory

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_count: int = get_count(item_name)
	if current_count < count:
		return false

	var new_count: int = current_count - count
	if new_count == 0:
		_items.erase(item_name)
	else:
		_items[item_name] = new_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 packed_scene: PackedScene = load(path)
	if packed_scene == null:
		push_error("Failed to load level scene at path: %s" % path)
		return null

	var level: Node = packed_scene.instantiate()
	if level == null:
		push_error("Failed to instantiate level scene at path: %s" % path)
		return null

	add_child(level)
	return level

Paint cells on a TileMapLayer: pass

extends TileMapLayer

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


func paint_row(y: int, from_x: int, to_x: int) -> void:
	var start_x := mini(from_x, to_x)
	var end_x := 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)


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)
	query.collide_with_areas = true
	query.collide_with_bodies = true

	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]:
	if not _is_in_bounds(from, size) or not _is_in_bounds(to, size):
		return []

	var wall_set := {}
	for wall in walls:
		if _is_in_bounds(wall, size):
			wall_set[wall] = true

	if wall_set.has(from) or wall_set.has(to):
		return []

	if from == to:
		return [from]

	var queue: Array[Vector2i] = [from]
	var visited := {from: true}
	var came_from := {}

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

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

		if current == to:
			return _reconstruct_path(came_from, to)

		for direction in directions:
			var next := current + direction

			if not _is_in_bounds(next, size):
				continue
			if wall_set.has(next):
				continue
			if visited.has(next):
				continue

			visited[next] = true
			came_from[next] = current
			queue.append(next)

	return []


func _is_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


func _reconstruct_path(came_from: Dictionary, goal: Vector2i) -> Array[Vector2i]:
	var path: Array[Vector2i] = [goal]
	var current := goal

	while came_from.has(current):
		current = came_from[current]
		path.append(current)

	path.reverse()
	return path

Build and play an animation in code: pass

extends Node2D

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

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

	var track_index := animation.add_track(Animation.TYPE_VALUE)
	animation.track_set_path(track_index, NodePath(".:visible"))
	animation.track_insert_key(track_index, 0.0, true)
	animation.track_insert_key(track_index, 0.5, false)
	animation.track_insert_key(track_index, 1.0, true)

	animation_player.add_animation_library("", AnimationLibrary.new())
	animation_player.get_animation_library("").add_animation("blink", animation)
	animation_player.play("blink")

Wait for a signal or a timeout: fail

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

BENCH FAIL: returned false for a signal 0.2 s away with a 1 s timeout