Can Qwen3.7 Max write working Godot 4 code? 13 of 15 on the first try

How the test works

Qwen3.7 Max 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

var gravity := 980.0

func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity.y += gravity * delta
    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: " + str(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:
		file.store_string(JSON.stringify(data))
		file.close()

static func load_data(path: String) -> Dictionary:
	if not FileAccess.file_exists(path):
		return {}
		
	var file = FileAccess.open(path, FileAccess.READ)
	if file:
		var json_string = file.get_as_text()
		file.close()
		
		var json = JSON.new()
		var error = json.parse(json_string)
		if error == OK and 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:
	if amount <= 0:
		return
		
	var old_value: int = health
	health = max(0, health - amount)
	
	if health != old_value:
		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)
	tween.finished.connect(_on_tween_finished)

func _on_tween_finished() -> void:
	faded.emit()

Spawn on a timer, then stop: pass

extends Node

var spawned_count: int = 0

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

func _on_timer_timeout() -> void:
	if spawned_count >= 4:
		return
	var node := Node2D.new()
	add_child(node)
	spawned_count += 1
	if spawned_count >= 4:
		var timer := get_child(0) as Timer
		if timer:
			timer.stop()

A door with states: pass

extends Node

enum State { CLOSED, OPENING, OPEN }

var current_state: State = State.CLOSED
var _opening_time: float = 0.0

func _process(delta: float) -> void:
	if current_state == State.OPENING:
		_opening_time += delta
		if _opening_time >= 0.5:
			current_state = State.OPEN

func interact() -> void:
	if current_state == State.CLOSED:
		current_state = State.OPENING
		_opening_time = 0.0

func get_state_name() -> String:
	match current_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 items.has(item_name):
		items[item_name] += count
	else:
		items[item_name] = count

func remove_item(item_name: String, count: int) -> bool:
	var current_count := get_count(item_name)
	if current_count >= count:
		items[item_name] = current_count - count
		if items[item_name] == 0:
			items.erase(item_name)
		return true
	return false

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 packed_scene := load(path) as PackedScene
	if packed_scene:
		var instance := packed_scene.instantiate()
		add_child(instance)
		return instance
	
	push_error("Failed to load scene from path: " + path)
	return null

Paint cells on a TileMapLayer: pass after one fix

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

SCRIPT ERROR: Parse Error: The variable type is being inferred from a Variant value, so it will be typed as Variant. (Warning treated as error.)
   at: GDScript::reload (res://grid_painter.gd:4)
   GDScript backtrace (most recent call first):
       [0] _ready (res://bench_check.gd:4)
SCRIPT ERROR: Parse Error: The variable type is being inferred from a Variant value, so it will be typed as Variant. (Warning treated as error.)
   at: GDScript::reload (res://grid_painter.gd:5)
   GDScript backtrace (most recent call first):
       [0] _ready (res://bench_check.gd:4)
ERROR: Failed to load script "res://grid_painter.gd" with error "Parse error".
   at: load (modules/gdscript/gdscript_resource_format.cpp:46)
   GDScript backtrace (most recent call first):
       [0] _ready (res://bench_check.gd:4)
SCRIPT ERROR: Invalid call. Nonexistent function 'paint_row' in base 'TileMapLayer'.
   at: _ready (res://bench_check.gd:18)
   GDScript backtrace (most recent call first):
       [0] _ready (res://bench_check.gd:18)

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)
	var result := space_state.intersect_ray(query)
	
	if not result.is_empty():
		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]:
	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 := {}
	for w in walls:
		wall_set[w] = true

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

	var queue: Array[Vector2i] = [from]
	var head := 0
	var came_from := {}
	came_from[from] = from

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

	var found := false

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

		if current == to:
			found = true
			break

		for dir in directions:
			var next_pos: Vector2i = current + dir

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

			if wall_set.has(next_pos):
				continue

			if came_from.has(next_pos):
				continue

			came_from[next_pos] = current
			queue.push_back(next_pos)

	if not found and from != to:
		return []

	var path: Array[Vector2i] = []
	var curr: Vector2i = to
	while true:
		path.push_back(curr)
		if curr == from:
			break
		curr = came_from[curr]

	path.reverse()
	return path

Build and play an animation in code: fail

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

WARNING: AnimationMixer: 'blink', couldn't resolve track:  'visible'. This warning can be disabled in Project Settings.
   at: _update_caches (scene/animation/animation_mixer.cpp:725)
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

class _Promise:
	signal finished(result: bool)
	var _done := false
	
	func resolve(res: bool) -> void:
		if not _done:
			_done = true
			finished.emit(res)

func wait_for(sig: Signal, seconds: float) -> bool:
	var promise := _Promise.new()
	
	var on_sig := func() -> void:
		promise.resolve(true)
		
	var on_time := func() -> void:
		promise.resolve(false)
		
	sig.connect(on_sig, CONNECT_ONE_SHOT)
	var timer := get_tree().create_timer(seconds)
	timer.timeout.connect(on_time, CONNECT_ONE_SHOT)
	
	var result = await promise.finished
	
	if sig.is_connected(on_sig):
		sig.disconnect(on_sig)
	if timer.timeout.is_connected(on_time):
		timer.timeout.disconnect(on_time)
		
	return result if result is bool else false