Can GLM 5.2 write working Godot 4 code? 14 of 15 on the first try

How the test works

GLM 5.2 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: 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: " + 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 == null:
		push_error("Could not open file for writing at path: " + path + " - Error: " + str(FileAccess.get_open_error()))
		return
	
	var json_string := JSON.stringify(data, "    ")
	file.store_string(json_string)
	file.close()

static func load_data(path: String) -> Dictionary:
	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Could not open file for reading at path: " + path + " - Error: " + str(FileAccess.get_open_error()))
		return {}
	
	var json_string := file.get_as_text()
	file.close()
	
	var parsed = JSON.parse_string(json_string)
	if typeof(parsed) != TYPE_DICTIONARY:
		push_error("Failed to parse JSON or JSON is not a Dictionary at path: " + path)
		return {}
	
	return parsed

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 or _has_died:
		return

	var old_health := health
	health = max(0, health - amount)

	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)
	tween.tween_callback(func(): 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:
	if spawned_count >= 4:
		_spawn_timer.stop()
		return
	
	var new_child := Node2D.new()
	add_child(new_child)
	spawned_count += 1

A door with states: pass

extends Node

enum State { CLOSED, OPENING, OPEN }

var _state: State = State.CLOSED
var _timer: Timer = null

func _ready() -> void:
	_timer = Timer.new()
	_timer.wait_time = 0.5
	_timer.one_shot = true
	_timer.timeout.connect(_on_timer_timeout)
	add_child(_timer)

func interact() -> void:
	if _state == State.CLOSED:
		_state = State.OPENING
		_timer.start()

func get_state_name() -> String:
	return State.keys()[_state]

func _on_timer_timeout() -> void:
	if _state == State.OPENING:
		_state = State.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] = _items.get(item_name, 0) + count

func remove_item(item_name: String, count: int) -> bool:
	if count <= 0:
		return true
	var current_count = _items.get(item_name, 0)
	if current_count < count:
		return false
	var new_count = 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 _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("Failed to load level scene at path: " + path)
		return null
	
	var instance := packed_scene.instantiate()
	add_child(instance)
	return instance

Paint cells on a TileMapLayer: pass

extends TileMapLayer

func paint_row(y: int, from_x: int, to_x: int) -> void:
	var start_x: int = min(from_x, to_x)
	var end_x: int = max(from_x, to_x)
	for x in range(start_x, end_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 world_2d := get_world_2d()
	if not world_2d:
		return to
	
	var space_state := world_2d.direct_space_state
	var query := PhysicsRayQueryParameters2D.create(from, to)
	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

## Finds the shortest path of grid cells from `from` to `to` (both included)
## on a grid of `size` cells, avoiding wall cells.
## Movement is limited to up, down, left, right (4-directional).
func find_path(size: Vector2i, walls: Array[Vector2i], from: Vector2i, to: Vector2i) -> Array[Vector2i]:
	var path: Array[Vector2i] = []

	# Bounds check.
	if from.x < 0 or from.y < 0 or from.x >= size.x or from.y >= size.y:
		return path
	if to.x < 0 or to.y < 0 or to.x >= size.x or to.y >= size.y:
		return path

	# Wall set for fast lookup.
	var wall_set: Dictionary = {}
	for w in walls:
		if w.x >= 0 and w.y >= 0 and w.x < size.x and w.y < size.y:
			wall_set[w] = true

	# If start or end is a wall, no path.
	if wall_set.has(from) or wall_set.has(to):
		return path

	# Trivial case.
	if from == to:
		path.append(from)
		return path

	var directions: Array[Vector2i] = [
		Vector2i(0, -1), # up
		Vector2i(0, 1),  # down
		Vector2i(-1, 0), # left
		Vector2i(1, 0),  # right
	]

	# BFS.
	var visited: Dictionary = {}
	visited[from] = true

	var came_from: Dictionary = {}

	var queue: Array[Vector2i] = [from]

	while not queue.is_empty():
		var current: Vector2i = queue.pop_front()

		for d in directions:
			var next: Vector2i = current + d

			if next.x < 0 or next.y < 0 or next.x >= size.x or next.y >= size.y:
				continue
			if wall_set.has(next):
				continue
			if visited.has(next):
				continue

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

			if next == to:
				# Reconstruct path.
				var c: Vector2i = next
				while c != from:
					path.push_front(c)
					c = came_from[c]
				path.push_front(from)
				return path

			queue.push_back(next)

	return path

Build and play an animation in code: pass

extends Node2D

func _ready() -> void:
	# Create the AnimationPlayer and add it as a child
	var anim_player := AnimationPlayer.new()
	add_child(anim_player)
	
	# Create the Animation resource
	var anim := Animation.new()
	
	# Add a value track for the 'visible' property of this Node2D
	var track_idx := anim.add_track(Animation.TYPE_VALUE)
	anim.track_set_path(track_idx, ".:visible")
	
	# Insert keys: visible at 0.0s, hidden at 0.5s, visible again at 1.0s for seamless looping
	anim.track_insert_key(track_idx, 0.0, true)
	anim.track_insert_key(track_idx, 0.5, false)
	anim.track_insert_key(track_idx, 1.0, true)
	
	# Set animation length and loop mode
	anim.length = 1.0
	anim.loop_mode = Animation.LOOP_LINEAR
	
	# Create an AnimationLibrary to hold the animation
	var lib := AnimationLibrary.new()
	lib.add_animation("blink", anim)
	
	# Add the library to the AnimationPlayer (using the default empty name "")
	anim_player.add_animation_library("", lib)
	
	# Play the animation
	anim_player.play("blink")

Wait for a signal or a timeout: pass after one fix

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

SCRIPT ERROR: Invalid access to property or key 'resolved' on a base object of type 'Object'.
   at: wait_for (res://waiter.gd:28)
   GDScript backtrace (most recent call first):
       [0] wait_for (res://waiter.gd:28)
       [1] _ready (res://bench_check.gd:13)
SCRIPT ERROR: Invalid access to property or key 'resolved' on a base object of type 'Object'.
   at: wait_for (res://waiter.gd:28)
   GDScript backtrace (most recent call first):
       [0] wait_for (res://waiter.gd:28)
       [1] _ready (res://bench_check.gd:17)
BENCH FAIL: returned false for a signal 0.2 s away with a 1 s timeout
WARNING: 2 ObjectDB instances were leaked at exit (run with `--verbose` for details).
   at: cleanup (core/object/object.cpp:2536)