Can GPT-6 Luna write working Godot 4 code? 15 of 15 on the first try

How the test works

GPT-6 Luna in Flockbay

Move a CharacterBody2D with an input action: pass

extends CharacterBody2D

const SPEED := 200.0

func _physics_process(_delta: float) -> void:
	velocity = Vector2(SPEED, 0.0) if Input.is_action_pressed("ui_right") else 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 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:
		return

	file.store_string(JSON.stringify(data))


static func load_data(path: String) -> Dictionary:
	if not FileAccess.file_exists(path):
		return {}

	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		return {}

	var json := JSON.new()
	if json.parse(file.get_as_text()) != OK:
		return {}

	if json.data is Dictionary:
		return json.data

	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:
	var old_value := health
	health = maxi(health - maxi(amount, 0), 0)

	if health == old_value:
		return

	health_changed.emit(old_value, health)

	if health == 0:
		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)
	await tween.finished
	faded.emit()

Spawn on a timer, then stop: pass

extends Node

var spawned_count: int = 0
var spawn_timer: Timer


func _ready() -> void:
	spawn_timer = Timer.new()
	spawn_timer.wait_time = 0.25
	spawn_timer.timeout.connect(_on_spawn_timer_timeout)
	add_child(spawn_timer)
	spawn_timer.start()


func _on_spawn_timer_timeout() -> void:
	var child := Node2D.new()
	add_child(child)
	spawned_count += 1

	if spawned_count >= 4:
		spawn_timer.stop()

A door with states: pass

extends Node

enum State { CLOSED, OPENING, OPEN }

const OPENING_DURATION := 0.5

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


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

	_state = State.OPENING
	_opening_elapsed = 0.0


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

	_opening_elapsed += delta
	if _opening_elapsed >= OPENING_DURATION:
		_state = State.OPEN


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

	return ""

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

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

	var level := packed_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:
	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), 0, Vector2i.ZERO)


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 query := PhysicsRayQueryParameters2D.create(from, to)
	query.collide_with_areas = true

	var result := get_world_2d().direct_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 size.x <= 0 or size.y <= 0:
		return []
	if not _is_in_bounds(from, size) or not _is_in_bounds(to, size):
		return []
	if walls.has(from) or walls.has(to):
		return []

	var queue: Array[Vector2i] = [from]
	var previous: Dictionary = {}
	var visited: Dictionary = {from: true}
	var directions: Array[Vector2i] = [
		Vector2i.UP,
		Vector2i.DOWN,
		Vector2i.LEFT,
		Vector2i.RIGHT,
	]
	var head := 0

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

		if current == to:
			break

		for direction in directions:
			var neighbor := current + direction
			if not _is_in_bounds(neighbor, size):
				continue
			if walls.has(neighbor) or visited.has(neighbor):
				continue

			visited[neighbor] = true
			previous[neighbor] = current
			queue.append(neighbor)

	if not visited.has(to):
		return []

	var path: Array[Vector2i] = []
	var current := to
	while current != from:
		path.push_front(current)
		current = previous[current]
	path.push_front(from)
	return path


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

Build and play an animation in code: pass

extends Node2D

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

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

	var visibility_track := blink.add_track(Animation.TYPE_VALUE)
	blink.track_set_path(visibility_track, NodePath(".:visible"))
	blink.value_track_set_update_mode(visibility_track, Animation.UPDATE_DISCRETE)
	blink.track_insert_key(visibility_track, 0.0, true)
	blink.track_insert_key(visibility_track, 0.5, false)

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

	animation_player.play("blink")
	animation_player.advance(0.0)

Wait for a signal or a timeout: pass

extends Node

class _WaitRace extends RefCounted:
	signal finished(signal_won: bool)

	var completed := false

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

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

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


func wait_for(sig: Signal, seconds: float) -> bool:
	var race := _WaitRace.new()
	var signal_callback := Callable(race, "_on_signal")
	var timer := get_tree().create_timer(maxf(seconds, 0.0))
	var timeout_callback := Callable(race, "_on_timeout")

	sig.connect(signal_callback, CONNECT_ONE_SHOT)
	timer.timeout.connect(timeout_callback, CONNECT_ONE_SHOT)

	var signal_won: bool = await race.finished

	if sig.is_connected(signal_callback):
		sig.disconnect(signal_callback)

	return signal_won