Can Kimi K3 write working Godot 4 code? 15 of 15 on the first try

How the test works

Kimi K3 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 := 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: %d" % 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("SaveGame: could not open '%s' for writing (error %d)." % [path, FileAccess.get_open_error()])
		return
	file.store_string(JSON.stringify(data))
	file.close()


static func load_data(path: String) -> Dictionary:
	if not FileAccess.file_exists(path):
		push_warning("SaveGame: file '%s' does not exist." % 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 text := file.get_as_text()
	file.close()
	var parsed: Variant = JSON.parse_string(text)
	if parsed is Dictionary:
		return parsed
	push_error("SaveGame: '%s' does not contain a JSON object." % path)
	return {}

Health with signals: pass

extends Node

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

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


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

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

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

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

Fade out with a tween: pass

extends Node2D

## Emitted when the fade out has finished.
signal faded


## Fades the node's modulate alpha from 1 to 0 over [param duration] seconds,
## then emits [signal faded].
func fade_out(duration: float) -> void:
	var tween := create_tween()
	tween.tween_property(self, "modulate:a", 0.0, duration).from(1.0)
	tween.tween_callback(faded.emit)

Spawn on a timer, then stop: pass

extends Node

var spawned_count: int = 0

var _timer: Timer
const MAX_SPAWNS: int = 4
const SPAWN_INTERVAL: float = 0.25

func _ready() -> void:
	_timer = Timer.new()
	_timer.wait_time = SPAWN_INTERVAL
	_timer.one_shot = false
	_timer.timeout.connect(_on_timer_timeout)
	add_child(_timer)
	_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
var _timer: Timer


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 _on_timer_timeout() -> void:
	_state = State.OPEN


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

An inventory with counts: pass

extends RefCounted

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: int = _items.get(item_name, 0)
	if current < count:
		return false
	var remaining: int = current - count
	if remaining <= 0:
		_items.erase(item_name)
	else:
		_items[item_name] = remaining
	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 scene: PackedScene = load(path)
	if scene == null:
		push_error("Failed to load scene at path: %s" % path)
		return null
	var instance: Node = scene.instantiate()
	add_child(instance)
	return instance

Paint cells on a TileMapLayer: pass

extends TileMapLayer


## Sets the cells from (from_x, y) to (to_x, y) inclusive to tile
## source 0, atlas coordinates (0, 0).
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))


## Returns whether a cell has a tile.
func is_painted(cell: Vector2i) -> bool:
	return get_cell_source_id(cell) != -1

Cast a physics ray: pass

extends Node2D
## Provides line-of-sight raycasting against the 2D physics world.


## Casts a physics ray from [param from] to [param to] and returns the
## position of the first collider hit, or [param to] if nothing is hit.
## Must be called during physics processing, when the physics space is
## accessible.
func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var query := PhysicsRayQueryParameters2D.create(from, to)
	var result := get_world_2d().direct_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]:
	var path: Array[Vector2i] = []
	if size.x <= 0 or size.y <= 0:
		return path
	if not _is_in_bounds(from, size) or not _is_in_bounds(to, size):
		return path

	var wall_set := {}
	for wall in walls:
		wall_set[wall] = true
	if wall_set.has(from) or wall_set.has(to):
		return path

	# Breadth-first search: guarantees the shortest path on an unweighted grid.
	var came_from := {}
	var visited := {from: true}
	var queue: Array[Vector2i] = [from]
	var head := 0
	var found := false

	while head < queue.size():
		var current: Vector2i = queue[head]
		head += 1
		if current == to:
			found = true
			break
		for direction in DIRECTIONS:
			var next: Vector2i = current + direction
			if not _is_in_bounds(next, size):
				continue
			if wall_set.has(next) or visited.has(next):
				continue
			visited[next] = true
			came_from[next] = current
			queue.append(next)

	if not found:
		return path

	# Reconstruct the path from `to` back to `from`, then reverse it.
	var cell := to
	path.append(cell)
	while cell != from:
		cell = came_from[cell]
		path.append(cell)
	path.reverse()
	return path

func _is_in_bounds(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


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

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

	var track := anim.add_track(Animation.TYPE_VALUE)
	anim.track_set_path(track, ".:visible")
	anim.value_track_set_update_mode(track, Animation.UPDATE_DISCRETE)
	anim.track_insert_key(track, 0.0, true)
	anim.track_insert_key(track, 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: pass

extends Node

## Waits until [param sig] is emitted or [param seconds] of game time pass,
## whichever happens first.
##
## Returns [code]true[/code] if [param sig] was emitted before the time ran
## out, or [code]false[/code] if the wait timed out. The signal is expected
## to have no arguments. Must be called on a node inside the scene tree.


class _Race:
	signal finished


func wait_for(sig: Signal, seconds: float) -> bool:
	var race := _Race.new()
	# Lambdas capture locals by value, so share mutable state via a Dictionary.
	var state := {"resolved": false, "signaled": false}

	var resolve := func(signaled: bool) -> void:
		if state.resolved:
			return
		state.resolved = true
		state.signaled = signaled
		race.finished.emit()

	var on_signal: Callable = resolve.bind(true)
	sig.connect(on_signal, CONNECT_ONE_SHOT)
	get_tree().create_timer(seconds).timeout.connect(resolve.bind(false), CONNECT_ONE_SHOT)

	if not state.resolved:
		await race.finished

	# If the timeout won, drop the still-pending signal connection.
	if sig.is_connected(on_signal):
		sig.disconnect(on_signal)

	return state.signaled