Can Fugu Max write working Godot 4 code? 13 of 15 on the first try

How the test works

Fugu 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 = Vector2(SPEED, 0.0)
	else:
		velocity = Vector2.ZERO

	move_and_slide()

Fall with gravity and land on the floor: pass

extends CharacterBody2D

# Ball: falls under gravity and stops when it lands on the floor.
# The scene provides the collision shape.

const GRAVITY := 980.0  # pixels per second squared

var _landed := false


func _physics_process(delta: float) -> void:
	if _landed:
		return

	# Apply gravity to build up downward speed.
	velocity.y += GRAVITY * delta

	move_and_slide()

	# Stop once we're resting on the floor.
	if is_on_floor():
		velocity = Vector2.ZERO
		_landed = true

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

# save_game.gd
# A small utility for saving and loading dictionaries as JSON files.
# Usage:
#   SaveGame.save_data({"gold": 100}, "user://save.json")
#   var data: Dictionary = SaveGame.load_data("user://save.json")

extends RefCounted
class_name SaveGame


## Writes the given dictionary to `path` as a JSON file.
static func save_data(data: Dictionary, path: String) -> void:
	var file := FileAccess.open(path, FileAccess.WRITE)
	if file == null:
		push_error("SaveGame: could not open '%s' for writing (error %d)." % [path, FileAccess.get_open_error()])
		return

	var json_text := JSON.stringify(data, "\t")
	file.store_string(json_text)
	file.close()


## Reads a dictionary previously written by `save_data`.
## Returns an empty Dictionary if the file is missing or invalid.
static func load_data(path: String) -> Dictionary:
	if not FileAccess.file_exists(path):
		push_warning("SaveGame: no save file at '%s'." % path)
		return {}

	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("SaveGame: could not open '%s' for reading (error %d)." % [path, FileAccess.get_open_error()])
		return {}

	var json_text := file.get_as_text()
	file.close()

	var parsed = JSON.parse_string(json_text)
	if typeof(parsed) != TYPE_DICTIONARY:
		push_error("SaveGame: file at '%s' does not contain a valid JSON object." % path)
		return {}

	return parsed

Health with signals: pass

extends Node
## Health component for Godot 4.
##
## Attach to any node to give it damage handling.

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 health <= 0:
		return

	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

## Fades this node's modulate alpha from 1 to 0 over a duration,
## then emits the "faded" signal.

signal faded

var _tween: Tween


func fade_out(duration: float) -> void:
	if _tween != null and _tween.is_valid():
		_tween.kill()

	modulate.a = 1.0

	_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

## Spawns a new Node2D child every 0.25 seconds, stopping after 4 children.

const SPAWN_INTERVAL := 0.25
const MAX_SPAWNS := 4

var spawned_count: int = 0

var _timer: Timer


func _ready() -> void:
	_timer = Timer.new()
	_timer.wait_time = SPAWN_INTERVAL
	_timer.one_shot = false
	_timer.autostart = false
	add_child(_timer)
	_timer.timeout.connect(_on_timer_timeout)
	_timer.start()


func _on_timer_timeout() -> void:
	if spawned_count >= MAX_SPAWNS:
		_timer.stop()
		return

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

	if spawned_count >= MAX_SPAWNS:
		_timer.stop()

A door with states: pass

extends Node

enum State { CLOSED, OPENING, OPEN }

var _state: State = State.CLOSED


func interact() -> void:
	if _state == State.CLOSED:
		_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
## A simple inventory that tracks item counts by name.


var _items: Dictionary = {}


## Adds the given count of an item to the inventory.
func add_item(item_name: String, count: int) -> void:
	if count < 0:
		push_warning("Inventory: tried to add a negative count (%d) for '%s'." % [count, item_name])
		return
	if count == 0:
		return
	if _items.has(item_name):
		_items[item_name] += count
	else:
		_items[item_name] = count


## Removes the given count of an item, but only if there are enough.
## Returns true if the removal happened, otherwise false.
func remove_item(item_name: String, count: int) -> bool:
	if count < 0:
		push_warning("Inventory: tried to remove a negative count (%d) for '%s'." % [count, item_name])
		return false
	if count == 0:
		return true
	if get_count(item_name) < count:
		return false
	_items[item_name] -= count
	if _items[item_name] <= 0:
		_items.erase(item_name)
	return true


## Returns how many of an item the inventory holds; 0 if it was never added.
func get_count(item_name: String) -> int:
	return _items.get(item_name, 0)

Load a level scene from a path: pass

extends Node

## Loads the scene at [param path], instantiates it, adds the instance as a
## child of this node and returns it. Returns null if the scene can't be loaded.
func load_level(path: String) -> Node:
	var packed_scene := ResourceLoader.load(path) as PackedScene
	if packed_scene == null:
		push_error("LevelLoader: could not load a PackedScene from '%s'." % path)
		return null

	var level := packed_scene.instantiate()
	add_child(level)
	return level

Paint cells on a TileMapLayer: pass

extends TileMapLayer
## GridPainter: paints straight rows of tiles onto a TileMapLayer.


## Paints every cell in the row `y` from `from_x` to `to_x` (inclusive) with
## the tile from source 0 at atlas coordinates (0, 0).
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(0, 0))


## Returns true if the cell `cell` currently has a tile assigned to it.
func is_painted(cell: Vector2i) -> bool:
	return get_cell_source_id(cell) != -1

Cast a physics ray: pass after one fix

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

SCRIPT ERROR: Parse Error: Function "get_rid()" not found in base self.
   at: GDScript::reload (res://line_of_sight.gd:13)
   GDScript backtrace (most recent call first):
       [0] _ready (res://bench_check.gd:4)
ERROR: Failed to load script "res://line_of_sight.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 'first_hit' in base 'Node2D'.
   at: _ready (res://bench_check.gd:21)
   GDScript backtrace (most recent call first):
       [0] _ready (res://bench_check.gd:21)

A path on a grid around walls: pass

class_name PathFinder
extends RefCounted
## Finds the shortest path of grid cells between two cells on a rectangular grid,
## avoiding wall cells and moving only up, down, left or right.


const NEIGHBOR_OFFSETS: Array[Vector2i] = [
	Vector2i.UP,
	Vector2i.DOWN,
	Vector2i.LEFT,
	Vector2i.RIGHT,
]


## Returns the shortest path from `from` to `to` (both included) on a grid of
## `size` cells, never entering a wall cell, moving in 4 directions.
## Returns an empty array if no path exists or the arguments are invalid.
func find_path(
	size: Vector2i,
	walls: Array[Vector2i],
	from: Vector2i,
	to: Vector2i
) -> Array[Vector2i]:
	var path: Array[Vector2i] = []

	# Validate arguments: grid size, endpoints inside the grid,
	# and endpoints not inside walls.
	if size.x <= 0 or size.y <= 0:
		return path
	if not _is_inside(from, size) or not _is_inside(to, size):
		return path
	if _is_wall(from, walls) or _is_wall(to, walls):
		return path

	if from == to:
		path.append(from)
		return path

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

	# Breadth-first search, which guarantees the shortest path
	# on an unweighted grid.
	var queue: Array[Vector2i] = [from]
	var queue_index := 0
	var came_from: Dictionary = {}  # Vector2i -> Vector2i (previous cell)
	came_from[from] = from  # Sentinel: marks `from` as visited.

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

		for offset in NEIGHBOR_OFFSETS:
			var neighbor: Vector2i = cell + offset
			if not _is_inside(neighbor, size):
				continue
			if wall_set.has(neighbor):
				continue
			if came_from.has(neighbor):
				continue

			came_from[neighbor] = cell
			if neighbor == to:
				return _reconstruct_path(came_from, from, to)
			queue.append(neighbor)

	# `to` was never reached.
	return path


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


func _is_wall(cell: Vector2i, walls: Array[Vector2i]) -> bool:
	for wall in walls:
		if wall == cell:
			return true
	return false


func _reconstruct_path(
	came_from: Dictionary,
	from: Vector2i,
	to: Vector2i
) -> Array[Vector2i]:
	var path: Array[Vector2i] = []
	var cell := to
	while cell != from:
		path.append(cell)
		cell = came_from[cell]
	path.append(from)
	path.reverse()
	return path

Build and play an animation in code: pass

extends Node2D


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

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

	var track_idx := anim.add_track(Animation.TYPE_VALUE)
	anim.track_set_path(track_idx, ":visible")
	anim.track_insert_key(track_idx, 0.0, true)
	anim.track_insert_key(track_idx, 0.5, false)

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

	player.play("blink")

Wait for a signal or a timeout: fail

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