Can MiMo-V2.6-Pro-UltraSpeed write working Godot 4 code? 14 of 15 on the first try

How the test works

MiMo-V2.6-Pro-UltraSpeed 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:
	velocity.y += GRAVITY * delta
	move_and_slide()
	if is_on_floor():
		velocity = Vector2.ZERO

A score label: pass

extends Label

## Score label that displays "Score: <total>" and accumulates points
## via the add(points) method.

var _score: int = 0


func _ready() -> void:
	_score = 0
	text = "Score: 0"


func add(points: int) -> void:
	_score += points
	text = "Score: " + str(_score)

Save and load a dictionary as JSON: pass

extends RefCounted
## Simple JSON based save-game helper.
##
## All functions are static, so the script can be used without instantiating it:
##
##     SaveGame.save_data({"score": 42}, "user://save.json")
##     var data: Dictionary = SaveGame.load_data("user://save.json")


## Writes [param data] to the file at [param path] as pretty printed JSON.
## The parent directory is created when it does not exist yet.
## Problems are reported with [method push_error] instead of breaking execution.
static func save_data(data: Dictionary, path: String) -> void:
	var directory := path.get_base_dir()
	if not directory.is_empty() and not DirAccess.dir_exists_absolute(directory):
		var dir_error := DirAccess.make_dir_recursive_absolute(directory)
		if dir_error != OK:
			push_error("save_game: unable to create directory \"%s\" for \"%s\" (error %d)." % [directory, path, dir_error])
			return

	var file := FileAccess.open(path, FileAccess.WRITE)
	if file == null:
		push_error("save_game: unable to open \"%s\" for writing (error %d)." % [path, FileAccess.get_open_error()])
		return

	file.store_string(JSON.stringify(data, "\t"))
	file.close()


## Reads the JSON object stored in the file at [param path] and returns it.
## Returns an empty [Dictionary] when the file is missing, unreadable or invalid.
static func load_data(path: String) -> Dictionary:
	if not FileAccess.file_exists(path):
		push_error("save_game: file \"%s\" does not exist." % path)
		return {}

	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("save_game: unable to open \"%s\" for reading (error %d)." % [path, FileAccess.get_open_error()])
		return {}

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

	var json := JSON.new()
	if json.parse(text) != OK:
		push_error("save_game: invalid JSON in \"%s\" (line %d): %s" % [path, json.get_error_line(), json.get_error_message()])
		return {}

	var value: Variant = json.data
	if typeof(value) != TYPE_DICTIONARY:
		push_error("save_game: \"%s\" does not contain a JSON object." % path)
		return {}

	var result: Dictionary = value
	return result

Health with signals: pass

extends Node

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

var health: int = 100
var _dead: bool = false


func take_damage(amount: int) -> void:
	if amount <= 0 or _dead:
		return

	var old_value: int = health
	health = max(old_value - amount, 0)

	if health != old_value:
		health_changed.emit(old_value, health)

	if health == 0 and not _dead:
		_dead = true
		died.emit()

Fade out with a tween: pass

extends Node2D

signal faded

var _tween: Tween


func fade_out(duration: float) -> void:
	# Cancel any fade already in progress so calls don't fight each other.
	if _tween != null and _tween.is_valid():
		_tween.kill()
		_tween = null

	# Non-positive duration: snap straight to the end state and emit.
	if duration <= 0.0:
		modulate.a = 0.0
		faded.emit()
		return

	modulate.a = 1.0

	_tween = create_tween()
	_tween.tween_property(self, "modulate:a", 0.0, duration)
	_tween.finished.connect(_on_tween_finished)


func _on_tween_finished() -> void:
	_tween = null
	faded.emit()

Spawn on a timer, then stop: pass

extends Node

## Spawns a new child Node2D every 0.25 seconds, up to 4 children total.

var spawned_count: int = 0

@export var max_children: int = 4
@export var spawn_interval: float = 0.25

var _timer: Timer


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


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

	var child := Node2D.new()
	child.name = "Spawned%d" % (spawned_count + 1)
	add_child(child)

	spawned_count += 1

	if spawned_count >= max_children:
		_timer.stop()

A door with states: pass

extends Node
## A door with three states: CLOSED, OPENING and OPEN.
## The door starts CLOSED. Calling interact() on a CLOSED door starts the
## OPENING state, which lasts 0.5 seconds of game time before becoming OPEN.

enum State { CLOSED, OPENING, OPEN }

const OPEN_DURATION := 0.5

var _state: State = State.CLOSED
var _elapsed := 0.0


func interact() -> void:
	if _state == State.CLOSED:
		_state = State.OPENING
		_elapsed = 0.0


func get_state_name() -> String:
	match _state:
		State.CLOSED:
			return "CLOSED"
		State.OPENING:
			return "OPENING"
		State.OPEN:
			return "OPEN"
	return "CLOSED"


func _process(delta: float) -> void:
	if _state != State.OPENING:
		return

	_elapsed += delta
	if _elapsed >= OPEN_DURATION:
		_state = State.OPEN
		_elapsed = 0.0

An inventory with counts: pass

extends RefCounted
## A simple stackable inventory stored in memory.
##
## Items are tracked by name; each entry holds the number of units owned.
## Items that were never added report a count of 0.

var _items: Dictionary = {}


## Adds `count` units of `item_name`. Non-positive counts are ignored.
func add_item(item_name: String, count: int) -> void:
	if count <= 0:
		return
	_items[item_name] = int(_items.get(item_name, 0)) + count


## Removes `count` units of `item_name` if and only if at least that many are
## owned. Returns true when the items were removed, false otherwise.
func remove_item(item_name: String, count: int) -> bool:
	if count <= 0:
		return false
	var owned: int = int(_items.get(item_name, 0))
	if owned < count:
		return false
	var remaining: int = owned - count
	if remaining > 0:
		_items[item_name] = remaining
	else:
		_items.erase(item_name)
	return true


## Returns how many units of `item_name` are owned; 0 if never added.
func get_count(item_name: String) -> int:
	return int(_items.get(item_name, 0))

Load a level scene from a path: pass

extends Node
## LevelLoader: loads a level scene from a resource path, instantiates it,
## adds it as a child of this node and returns the instance.

func load_level(path: String) -> Node:
	if path.is_empty():
		push_error("LevelLoader: cannot load a level from an empty path.")
		return null

	var resource: Resource = load(path)
	if resource == null:
		push_error("LevelLoader: failed to load resource at path '%s'." % path)
		return null

	if not (resource is PackedScene):
		push_error(
			"LevelLoader: resource at path '%s' is not a PackedScene (got %s)."
			% [path, resource.get_class()]
		)
		return null

	var packed_scene := resource as PackedScene
	var instance := packed_scene.instantiate()
	if instance == null:
		push_error("LevelLoader: failed to instantiate scene at path '%s'." % path)
		return null

	add_child(instance)
	return instance

Paint cells on a TileMapLayer: pass

extends TileMapLayer


## Paints every cell of the row [param y] between [param from_x] and [param to_x]
## (both inclusive) with tile source 0 and atlas coordinates (0, 0).
## The order of the horizontal bounds does not matter.
func paint_row(y: int, from_x: int, to_x: int) -> void:
	var start_x: int = mini(from_x, to_x)
	var end_x: int = maxi(from_x, to_x)

	for x in range(start_x, end_x + 1):
		set_cell(Vector2i(x, y), 0, Vector2i(0, 0), 0)


## Returns true if [param cell] currently holds a tile, false otherwise.
func is_painted(cell: Vector2i) -> bool:
	return get_cell_source_id(cell) != -1

Cast a physics ray: pass

extends Node2D
## Casts physics rays through the 2D world to find the first blocking point.


## Returns the point where a ray from [from] toward [to] first hits a collider.
## If nothing is hit, returns [to] unchanged.
func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var space_state: PhysicsDirectSpaceState2D = get_world_2d().direct_space_state
	if space_state == null:
		return to

	var query := PhysicsRayQueryParameters2D.create(from, to)
	query.collide_with_bodies = true
	query.collide_with_areas = false
	query.hit_from_inside = false

	var result: Dictionary = space_state.intersect_ray(query)
	if result.is_empty():
		return to

	return result["position"] as Vector2

A path on a grid around walls: pass

extends RefCounted
## Grid path finder (4-directional movement, unit cost per step).
##
## find_path() returns the shortest path from `from` to `to`, both included,
## using only up / down / left / right moves on a grid of `size` cells.
## It never enters a wall cell. If no valid path exists (or any argument is
## invalid), an empty array is returned.

const _RIGHT := Vector2i(1, 0)
const _DOWN := Vector2i(0, 1)
const _LEFT := Vector2i(-1, 0)
const _UP := Vector2i(0, -1)

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


## Returns the shortest path of grid cells from `from` to `to` (both included),
## on a grid of `size` cells, never entering a cell listed in `walls`,
## moving only up, down, left or right. Empty if there is no such path.
func find_path(
		size: Vector2i,
		walls: Array[Vector2i],
		from: Vector2i,
		to: Vector2i
	) -> Array[Vector2i]:
	var path: Array[Vector2i] = []

	# Invalid grid.
	if size.x <= 0 or size.y <= 0:
		return path

	# Out of bounds endpoints.
	if not _is_inside(from, size) or not _is_inside(to, size):
		return path

	# Endpoint on a wall.
	var wall_set := {}
	for i in walls.size():
		var wall: Vector2i = walls[i]
		wall_set[wall] = true
	if wall_set.has(from) or wall_set.has(to):
		return path

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

	# Breadth-first search: the first time we reach a cell it is through a
	# shortest path, since every step costs 1.
	var came_from := {}  # Vector2i -> Vector2i (parent cell in the BFS tree)
	var queue: Array[Vector2i] = []
	var head := 0

	came_from[from] = from
	queue.append(from)

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

		if current == to:
			reached = true
			break

		for offset_index in _OFFSETS.size():
			var next: Vector2i = current + _OFFSETS[offset_index]

			if not _is_inside(next, size):
				continue
			if wall_set.has(next):
				continue
			if came_from.has(next):
				continue

			came_from[next] = current
			queue.append(next)

	if not reached:
		return path

	# Walk back from `to` to `from`, then reverse to get the path in order.
	var reversed_path: Array[Vector2i] = []
	var node: Vector2i = to
	while node != from:
		reversed_path.append(node)
		node = Vector2i(came_from[node])
	reversed_path.append(from)

	for i in range(reversed_path.size() - 1, -1, -1):
		path.append(reversed_path[i])

	return path


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

Build and play an animation in code: pass

extends Node2D
## Makes this node blink: visible for the first half of each second,
## hidden for the second half, looping forever.

const BLINK_ANIMATION_NAME := "blink"


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

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

	# Track path is relative to the AnimationPlayer's parent (this node).
	var track_index := animation.add_track(Animation.TYPE_VALUE)
	animation.track_set_path(track_index, NodePath(".:visible"))
	animation.value_track_set_update_mode(track_index, Animation.UPDATE_DISCRETE)
	animation.track_insert_key(track_index, 0.0, true)   # visible: 0.0s - 0.5s
	animation.track_insert_key(track_index, 0.5, false)  # hidden:  0.5s - 1.0s

	# An empty library name means the animation is played as "blink".
	var library := AnimationLibrary.new()
	library.add_animation(BLINK_ANIMATION_NAME, animation)
	animation_player.add_animation_library("", library)

	visible = true
	animation_player.play(BLINK_ANIMATION_NAME)

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: Parse Error: Assignment is not allowed inside an expression.
   at: GDScript::reload (res://waiter.gd:76)
   GDScript backtrace (most recent call first):
       [0] _ready (res://bench_check.gd:4)
ERROR: Failed to load script "res://waiter.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 'wait_for' in base 'Node'.
   at: _ready (res://bench_check.gd:13)
   GDScript backtrace (most recent call first):
       [0] _ready (res://bench_check.gd:13)