Can Ember-1 write working Godot 4 code? 15 of 15 on the first try

How the test works

Ember-1 in Flockbay

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
	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("Could not open file for writing: %s (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_error("File does not exist: %s" % path)
		return {}
	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Could not open file for reading: %s (error %d)" % [path, FileAccess.get_open_error()])
		return {}
	var text := file.get_as_text()
	file.close()
	var json := JSON.new()
	var error := json.parse(text)
	if error != OK:
		push_error("Could not parse JSON in %s: %s at line %d" % [path, json.get_error_message(), json.get_error_line()])
		return {}
	if json.data is Dictionary:
		return json.data
	push_error("JSON root is not a Dictionary: %s" % path)
	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 amount <= 0:
		return
	var old_value := health
	health = maxi(health - amount, 0)
	if health != old_value:
		health_changed.emit(old_value, health)
		if health == 0:
			died.emit()

Fade out with a tween: pass

extends Node2D

## Emitted when the fade-out tween has finished.
signal faded

## Fades the node's modulate alpha from 1 to 0 over [param duration] seconds,
## then emits [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.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 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).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:
	_items[item_name] = _items.get(item_name, 0) + count

func remove_item(item_name: String, count: int) -> bool:
	var current: int = _items.get(item_name, 0)
	if current < count:
		return false
	_items[item_name] = current - count
	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: PackedScene = load(path)
	if scene == null:
		push_error("Failed to load scene at path: %s" % path)
		return null
	var instance: Node = scene.instantiate()
	add_child(instance)
	return instance

Paint cells on a TileMapLayer: pass

extends TileMapLayer


## Sets all cells from (from_x, y) to (to_x, y) inclusive
## to tile source 0, atlas coordinates (0, 0).
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), 0, Vector2i(0, 0))


## Returns whether the given cell 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` and returns the position of the
## first collider hit, or `to` if nothing was hit.
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:
		return result.position
	return to

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 not _is_inside(from, size) or not _is_inside(to, size):
		return path

	var wall_set := {}
	for wall in walls:
		wall_set[wall] = true
	if wall_set.has(from) or wall_set.has(to):
		return path

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

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

	# Breadth-first search guarantees the shortest path on an unweighted grid.
	var visited := {from: true}
	var came_from := {}
	var queue: Array[Vector2i] = [from]
	var head := 0
	while head < queue.size():
		var current: Vector2i = queue[head]
		head += 1
		if current == to:
			break
		for direction in directions:
			var next: Vector2i = current + direction
			if not _is_inside(next, size):
				continue
			if wall_set.has(next) or visited.has(next):
				continue
			visited[next] = true
			came_from[next] = current
			queue.append(next)

	if not visited.has(to):
		return path

	var step := to
	while true:
		path.push_front(step)
		if step == from:
			break
		step = came_from[step]
	return path


func _is_inside(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)

	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)

	player.play("blink")

Wait for a signal or a timeout: pass

extends Node
## Utility for awaiting a signal with a timeout.


## Waits until [param sig] is emitted or [param seconds] of game time pass,
## whichever comes first. Returns [code]true[/code] if the signal came first,
## [code]false[/code] if the timeout elapsed. The signal must have no arguments.
func wait_for(sig: Signal, seconds: float) -> bool:
	var timer := get_tree().create_timer(seconds)
	var state := {"fired": false}
	var on_sig := func() -> void: state.fired = true
	sig.connect(on_sig, CONNECT_ONE_SHOT)
	while not state.fired and timer.time_left > 0.0:
		await get_tree().process_frame
	if sig.is_connected(on_sig):
		sig.disconnect(on_sig)
	return state.fired