Can Hy4 preview write working Godot 4 code? 15 of 15 on the first try

How the test works

Hy4 preview 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.RIGHT * SPEED
	else:
		velocity = Vector2.ZERO

	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

	move_and_slide()

	if is_on_floor():
		velocity.y = 0.0

A score label: pass

extends Label

var score := 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

extends RefCounted


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: %s" % path)
		return

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


static func load_data(path: String) -> Dictionary:
	if not FileAccess.file_exists(path):
		return {}

	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Failed to open file for reading: %s" % path)
		return {}

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

	var json := JSON.new()
	var error := json.parse(json_text)
	if error != OK:
		push_error("Failed to parse JSON file: %s" % path)
		return {}

	var loaded_data = json.data
	if loaded_data is Dictionary:
		return loaded_data

	push_error("Loaded JSON data is not a Dictionary: %s" % 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:
		return

	var damage := maxi(amount, 0)
	if damage == 0:
		return

	var old_value := health
	var new_value := maxi(health - damage, 0)

	if new_value == old_value:
		return

	health = new_value
	health_changed.emit(old_value, new_value)

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

Fade out with a tween: pass

extends Node2D

signal faded


func fade_out(duration: float) -> void:
	modulate.a = 1.0

	if duration <= 0.0:
		modulate.a = 0.0
		faded.emit()
		return

	var tween := create_tween()
	tween.tween_property(self, ^"modulate:a", 0.0, duration)
	await tween.finished
	faded.emit()

Spawn on a timer, then stop: pass

extends Node

const SPAWN_INTERVAL := 0.25
const MAX_SPAWN_COUNT := 4

var spawned_count := 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.timeout.connect(_on_spawn_timer_timeout)
	add_child(spawn_timer)
	spawn_timer.start()


func _on_spawn_timer_timeout() -> void:
	if spawned_count >= MAX_SPAWN_COUNT:
		_stop_spawning()
		return

	add_child(Node2D.new())
	spawned_count += 1

	if spawned_count >= MAX_SPAWN_COUNT:
		_stop_spawning()


func _stop_spawning() -> void:
	if spawn_timer == null:
		return

	spawn_timer.stop()
	remove_child(spawn_timer)
	spawn_timer.queue_free()
	spawn_timer = null

A door with states: pass

extends Node

enum State { CLOSED, OPENING, OPEN }

const OPEN_TIME := 0.5

var _state: State = State.CLOSED

func interact() -> void:
	if _state != State.CLOSED:
		return

	_state = State.OPENING
	await get_tree().create_timer(OPEN_TIME, false, false, false).timeout
	_state = State.OPEN

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

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] = get_count(item_name) + count

func remove_item(item_name: String, count: int) -> bool:
	if count < 0:
		return false
	
	var current_count := get_count(item_name)
	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 int(_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 PackedScene at path: %s" % path)
		return null

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

Paint cells on a TileMapLayer: pass

extends TileMapLayer


const TILE_SOURCE_ID := 0
const TILE_ATLAS_COORDS := Vector2i(0, 0)
const EMPTY_CELL_SOURCE_ID := -1


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), TILE_SOURCE_ID, TILE_ATLAS_COORDS)


func is_painted(cell: Vector2i) -> bool:
	return get_cell_source_id(cell) != EMPTY_CELL_SOURCE_ID

Cast a physics ray: pass

extends Node2D

func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var space_state := 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 = true

	var result := 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

func find_path(size: Vector2i, walls: Array[Vector2i], from: Vector2i, to: Vector2i) -> Array[Vector2i]:
	if size.x <= 0 or size.y <= 0:
		return []
	
	if from.x < 0 or from.x >= size.x or from.y < 0 or from.y >= size.y:
		return []
	if to.x < 0 or to.x >= size.x or to.y < 0 or to.y >= size.y:
		return []

	var total_cells = size.x * size.y
	var is_wall: Array[bool] = []
	is_wall.resize(total_cells)
	for i in range(total_cells):
		is_wall[i] = false

	for w in walls:
		if w.x >= 0 and w.x < size.x and w.y >= 0 and w.y < size.y:
			is_wall[w.y * size.x + w.x] = true

	if is_wall[from.y * size.x + from.x] or is_wall[to.y * size.x + to.x]:
		return []

	if from == to:
		return [from]

	var parent: Array[int] = []
	parent.resize(total_cells)
	for i in range(total_cells):
		parent[i] = -1

	var visited: Array[bool] = []
	visited.resize(total_cells)
	for i in range(total_cells):
		visited[i] = false

	var q: Array[Vector2i] = [from]
	var head = 0
	visited[from.y * size.x + from.x] = true

	var dirs = [Vector2i(1, 0), Vector2i(-1, 0), Vector2i(0, 1), Vector2i(0, -1)]

	while head < q.size():
		var curr = q[head]
		head += 1
		if curr == to:
			break
		for d in dirs:
			var nx = curr.x + d.x
			var ny = curr.y + d.y
			if nx < 0 or nx >= size.x or ny < 0 or ny >= size.y:
				continue
			var nidx = ny * size.x + nx
			if is_wall[nidx] or visited[nidx]:
				continue
			visited[nidx] = true
			parent[nidx] = curr.y * size.x + curr.x
			q.append(Vector2i(nx, ny))

	if not visited[to.y * size.x + to.x]:
		return []

	var path: Array[Vector2i] = []
	var curr_idx = to.y * size.x + to.x
	while curr_idx != -1:
		var cx = curr_idx % size.x
		var cy = curr_idx / size.x
		path.append(Vector2i(cx, cy))
		curr_idx = parent[curr_idx]

	path.reverse()
	return path

Build and play an animation in code: pass

extends Node2D

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

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

	var track := animation.add_track(Animation.TYPE_VALUE)
	animation.track_set_path(track, NodePath(".:visible"))
	animation.value_track_set_update_mode(track, Animation.UPDATE_DISCRETE)
	animation.track_insert_key(track, 0.0, true)
	animation.track_insert_key(track, 0.5, false)
	animation.track_insert_key(track, 1.0, true)

	var library := AnimationLibrary.new()
	library.add_animation("blink", animation)
	anim_player.add_animation_library("", library)

	anim_player.play("blink")

Wait for a signal or a timeout: pass

extends Node

class RaceHelper extends RefCounted:
	signal finished
	var signal_first: bool = false

func wait_for(sig: Signal, seconds: float) -> bool:
	var helper := RaceHelper.new()
	var timer := get_tree().create_timer(seconds, false)

	var on_signal := func():
		helper.signal_first = true
		helper.finished.emit()

	var on_timeout := func():
		helper.signal_first = false
		helper.finished.emit()

	sig.connect(on_signal)
	timer.timeout.connect(on_timeout)

	await helper.finished

	sig.disconnect(on_signal)
	timer.timeout.disconnect(on_timeout)

	return helper.signal_first