Can MiniMax M3 write working Godot 4 code? 13 of 15 on the first try

How the test works

MiniMax M3 in Flockbay

Move a CharacterBody2D with an input action: pass

extends CharacterBody2D

const SPEED = 200.0

func _physics_process(_delta):
	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 is_on_floor():
		velocity.y = 0.0
	else:
		velocity.y += GRAVITY * delta
	move_and_slide()

A score label: pass

extends Label

var score: int = 0


func _ready() -> void:
	score = 0
	text = "Score: %d" % score


func add(points: int) -> void:
	score += points
	text = "Score: %d" % score

Save and load a dictionary as JSON: pass

extends RefCounted
class_name SaveGame

static func save_data(data: Dictionary, path: String) -> void:
	var file = FileAccess.open(path, FileAccess.WRITE)
	if file == null:
		push_error("Failed to open file for writing: " + path)
		return
	var json_string = JSON.stringify(data)
	file.store_string(json_string)
	file.close()

static func load_data(path: String) -> Dictionary:
	var data: Dictionary = {}
	if not FileAccess.file_exists(path):
		push_error("File does not exist: " + path)
		return data
	var file = FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Failed to open file for reading: " + path)
		return data
	var json_string = file.get_as_text()
	file.close()
	var json = JSON.new()
	var error = json.parse(json_string)
	if error != OK:
		push_error("Failed to parse JSON at line %d: %s" % [json.get_error_line(), json.get_error_message()])
		return data
	var parsed_data = json.data
	if parsed_data is Dictionary:
		data = parsed_data
	return data

Health with signals: pass

extends Node

signal health_changed(old_value: int, new_value: int)
signal died

@export var health: int = 100

var _is_dead: bool = false

func take_damage(amount: int) -> void:
	if amount <= 0:
		return
	var old_value: int = health
	var new_value: int = max(0, health - amount)
	if new_value != old_value:
		health = new_value
		health_changed.emit(old_value, new_value)
		if health == 0 and not _is_dead:
			_is_dead = true
			died.emit()

Fade out with a tween: pass

extends Node2D

signal faded

func fade_out(duration: float) -> void:
	var tween := create_tween()
	tween.tween_property(self, "modulate:a", 0.0, duration)
	tween.finished.connect(_on_fade_finished)

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

Spawn on a timer, then stop: pass

extends Node

const SPAWN_INTERVAL: float = 0.25
const MAX_SPAWNS: int = 4

var spawned_count: int = 0

var _spawn_timer: Timer


func _ready() -> void:
	_spawn_timer = Timer.new()
	_spawn_timer.wait_time = SPAWN_INTERVAL
	_spawn_timer.one_shot = false
	_spawn_timer.autostart = true
	_spawn_timer.timeout.connect(_on_spawn_timer_timeout)
	add_child(_spawn_timer)


func _on_spawn_timer_timeout() -> void:
	if spawned_count >= MAX_SPAWNS:
		_spawn_timer.stop()
		return

	var node := Node2D.new()
	add_child(node)
	spawned_count += 1

	if spawned_count >= MAX_SPAWNS:
		_spawn_timer.stop()

A door with states: pass

extends Node

enum State {
	CLOSED,
	OPENING,
	OPEN
}

var _state: int = 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:
	if item_name.is_empty() or count <= 0:
		return
	if _items.has(item_name):
		_items[item_name] += count
	else:
		_items[item_name] = count

func remove_item(item_name: String, count: int) -> bool:
	if not _items.has(item_name):
		return false
	if _items[item_name] < count:
		return false
	_items[item_name] -= count
	if _items[item_name] <= 0:
		_items.erase(item_name)
	return true

func get_count(item_name: String) -> int:
	if not _items.has(item_name):
		return 0
	return _items[item_name]

Load a level scene from a path: pass

extends Node

func load_level(path: String) -> Node:
	var scene: PackedScene = load(path)
	var instance: Node = 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:
	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 space_state := get_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

const DIRECTIONS: Array[Vector2i] = [
	Vector2i(1, 0),
	Vector2i(-1, 0),
	Vector2i(0, 1),
	Vector2i(0, -1)
]

func find_path(size: Vector2i, walls: Array[Vector2i], from: Vector2i, to: Vector2i) -> Array[Vector2i]:
	# Validate that start and goal are inside the grid.
	if not _in_bounds(from, size) or not _in_bounds(to, size):
		return []
	
	# Build a hash set of walls for O(1) lookup.
	var wall_set: Dictionary = {}
	for wall in walls:
		wall_set[wall] = true
	
	# If start or goal sits on a wall, no path is possible.
	if wall_set.has(from) or wall_set.has(to):
		return []
	
	# Trivial case: start equals goal.
	if from == to:
		return [from]
	
	# Breadth-first search. Each cell maps to its predecessor; the start
	# uses a sentinel value so reconstruction knows when to stop.
	var queue: Array[Vector2i] = [from]
	var parent: Dictionary = {from: Vector2i(-1, -1)}
	
	while not queue.is_empty():
		var current: Vector2i = queue.pop_front()
		
		if current == to:
			return _reconstruct_path(parent, to)
		
		for dir in DIRECTIONS:
			var next: Vector2i = current + dir
			if not _in_bounds(next, size):
				continue
			if wall_set.has(next):
				continue
			if parent.has(next):
				continue
			parent[next] = current
			queue.append(next)
	
	# Goal was never reached.
	return []

func _in_bounds(cell: Vector2i, size: Vector2i) -> bool:
	return cell.x >= 0 and cell.x < size.x and cell.y >= 0 and cell.y < size.y

func _reconstruct_path(parent: Dictionary, end: Vector2i) -> Array[Vector2i]:
	var path: Array[Vector2i] = []
	var cell: Vector2i = end
	while cell != Vector2i(-1, -1):
		path.append(cell)
		cell = parent[cell]
	path.reverse()
	return path

Build and play an animation in code: fail

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

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 after one fix

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

BENCH FAIL: returned false for a signal 0.2 s away with a 1 s timeout