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

How the test works

GPT-5.6 Luna 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

	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 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_label()


func add(points: int) -> void:
	score += points
	_update_label()


func _update_label() -> 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 parsed: Variant = JSON.parse_string(file.get_as_text())
	if parsed is Dictionary:
		return parsed

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

	if health != old_health:
		health_changed.emit(old_health, 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)
	await tween.finished
	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.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()
	child.name = "SpawnedNode%d" % (spawned_count + 1)
	add_child(child)
	spawned_count += 1

	if spawned_count >= 4:
		timer.stop()

A door with states: pass

extends Node

enum DoorState {
	CLOSED,
	OPENING,
	OPEN
}

const OPENING_DURATION := 0.5

var state: int = DoorState.CLOSED
var opening_time_remaining := 0.0


func interact() -> void:
	if state == DoorState.CLOSED:
		state = DoorState.OPENING
		opening_time_remaining = OPENING_DURATION


func _process(delta: float) -> void:
	if state == DoorState.OPENING:
		opening_time_remaining -= delta
		if opening_time_remaining <= 0.0:
			opening_time_remaining = 0.0
			state = DoorState.OPEN


func get_state_name() -> String:
	match state:
		DoorState.CLOSED:
			return "CLOSED"
		DoorState.OPENING:
			return "OPENING"
		DoorState.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] = get_count(item_name) + count


func remove_item(item_name: String, count: int) -> bool:
	if get_count(item_name) < count:
		return false

	_items[item_name] = get_count(item_name) - 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 := load(path) as PackedScene
	if scene == null:
		push_error("Failed to load level scene: " + 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(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


func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var query := PhysicsRayQueryParameters2D.create(from, to)
	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 from.x < 0 or from.x >= size.x or from.y < 0 or from.y >= size.y:
		return []

	if to.x < 0 or to.x >= size.x or to.y < 0 or to.y >= size.y:
		return []

	var wall_set: Dictionary = {}
	for wall in walls:
		wall_set[wall] = true

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

	if from == to:
		return [from]

	var directions: Array[Vector2i] = [
		Vector2i.UP,
		Vector2i.DOWN,
		Vector2i.LEFT,
		Vector2i.RIGHT
	]

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

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

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

			if next.x < 0 or next.x >= size.x or next.y < 0 or next.y >= size.y:
				continue

			if wall_set.has(next) or visited.has(next):
				continue

			visited[next] = true
			came_from[next] = current

			if next == to:
				var path: Array[Vector2i] = [to]
				var step: Vector2i = to

				while step != from:
					step = came_from[step]
					path.push_front(step)

				return path

			queue.append(next)

	return []

Build and play an animation in code: pass

extends Node2D


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

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

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

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

	animation_player.play("blink")

Wait for a signal or a timeout: pass

extends Node


class _WaitState extends RefCounted:
	signal finished

	var result: bool = false
	var _completed: bool = false
	var _source: Signal
	var _timer: SceneTreeTimer

	func _init(source: Signal, tree: SceneTree, seconds: float) -> void:
		_source = source
		_timer = tree.create_timer(maxf(seconds, 0.0))
		_source.connect(_on_source)
		_timer.timeout.connect(_on_timeout)

	func _on_source() -> void:
		_complete(true)

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

	func _complete(value: bool) -> void:
		if _completed:
			return

		_completed = true
		result = value

		if _source.is_connected(_on_source):
			_source.disconnect(_on_source)
		if _timer.timeout.is_connected(_on_timeout):
			_timer.timeout.disconnect(_on_timeout)

		finished.emit()


func wait_for(sig: Signal, seconds: float) -> bool:
	var state := _WaitState.new(sig, get_tree(), seconds)
	await state.finished
	return state.result