I tried text-based development with Godot, a game engine well-suited for collaborative development with LLMs

I report on my experience implementing a simple ping pong game using Godot 4.x, which is gaining attention as a game engine well-suited for collaborative development with LLMs. I verified a development approach that minimizes GUI operations through text-based scene files and Python-like GDScript.

越井琢巳 (Koshii Takumi)

2025.07.16

This page has been translated by machine translation. View original

Introduction

In this article, we will implement a simple ping-pong game using Godot 4.x, which is gaining attention as a game engine suitable for collaborative development with LLMs. This is a 2D game where the player controls the paddle at the bottom and plays against the CPU.

Game demonstration image

What is Godot

Godot is an open-source cross-platform game engine. It is one of the major game development tools alongside Unity and Unreal Engine, and it employs GDScript, its own Python-like scripting language. It is characterized by its lightweight engine size and fast startup.

Why Godot is suitable for collaborative development with LLMs

Godot's scene files (.tscn) are written in a human-readable format, making them easy for LLMs to understand and generate.

Example

[node name="Player" type="CharacterBody2D" parent="."]
position = Vector2(180, 650)
script = ExtResource("2_1hdqx")

Additionally, GDScript has a Python-like syntax, which is a language pattern many LLMs excel at. Development using only a text editor is possible, as in this case, allowing you to build an interactive development environment with LLMs.

Target audience

Developers interested in game development using LLMs
Those who want to learn the basics of Godot

References

Implementation

First, I downloaded and launched Godot from the official site and created a new project.

Create new project

For this project, I chose Compatibility as the renderer, which is said to be "the fastest for rendering simple scenes."

Renderer selection

After creating the project, a folder is created. I communicated the operational image of the game I wanted to create to the LLM and created the following files in the folder. For this development, I used Claude Sonnet 4 as the LLM.

Main.tscn

[gd_scene load_steps=9 format=3 uid="uid://bvxqy8qkqwqxr"]

[ext_resource type="Script" path="res://Main.gd" id="1_0hdqx"]
[ext_resource type="Script" path="res://Player.gd" id="2_1hdqx"]
[ext_resource type="Script" path="res://CPU.gd" id="3_2hdqx"]
[ext_resource type="Script" path="res://Ball.gd" id="4_3hdqx"]

[sub_resource type="RectangleShape2D" id="RectangleShape2D_1"]
size = Vector2(80, 10)

[sub_resource type="RectangleShape2D" id="RectangleShape2D_2"]
size = Vector2(80, 10)

[sub_resource type="RectangleShape2D" id="RectangleShape2D_3"]
size = Vector2(16, 16)

[sub_resource type="RectangleShape2D" id="RectangleShape2D_4"]
size = Vector2(20, 720)

[sub_resource type="RectangleShape2D" id="RectangleShape2D_5"]
size = Vector2(360, 20)

[node name="Main" type="Node2D"]
script = ExtResource("1_0hdqx")

[node name="Player" type="CharacterBody2D" parent="."]
position = Vector2(180, 650)
script = ExtResource("2_1hdqx")

[node name="CollisionShape2D" type="CollisionShape2D" parent="Player"]
shape = SubResource("RectangleShape2D_1")

[node name="ColorRect" type="ColorRect" parent="Player"]
offset_left = -40.0
offset_top = -5.0
offset_right = 40.0
offset_bottom = 5.0
color = Color(1, 1, 1, 1)

[node name="CPU" type="CharacterBody2D" parent="."]
position = Vector2(180, 70)
script = ExtResource("3_2hdqx")

[node name="CollisionShape2D" type="CollisionShape2D" parent="CPU"]
shape = SubResource("RectangleShape2D_2")

[node name="ColorRect" type="ColorRect" parent="CPU"]
offset_left = -40.0
offset_top = -5.0
offset_right = 40.0
offset_bottom = 5.0
color = Color(1, 1, 1, 1)

[node name="Ball" type="CharacterBody2D" parent="."]
position = Vector2(180, 360)
script = ExtResource("4_3hdqx")

[node name="CollisionShape2D" type="CollisionShape2D" parent="Ball"]
shape = SubResource("RectangleShape2D_3")

[node name="ColorRect" type="ColorRect" parent="Ball"]
offset_left = -8.0
offset_top = -8.0
offset_right = 8.0
offset_bottom = 8.0
color = Color(1, 1, 1, 1)

[node name="Walls" type="StaticBody2D" parent="."]

[node name="LeftWall" type="CollisionShape2D" parent="Walls"]
position = Vector2(-10, 360)
shape = SubResource("RectangleShape2D_4")

[node name="RightWall" type="CollisionShape2D" parent="Walls"]
position = Vector2(370, 360)
shape = SubResource("RectangleShape2D_4")

[node name="TopWall" type="CollisionShape2D" parent="Walls"]
position = Vector2(180, -10)
shape = SubResource("RectangleShape2D_5")

[node name="BottomWall" type="CollisionShape2D" parent="Walls"]
position = Vector2(180, 730)
shape = SubResource("RectangleShape2D_5")

Main.gd

extends Node2D

# Game settings
const SCREEN_WIDTH = 360
const SCREEN_HEIGHT = 720

# Score
var player_score = 0
var cpu_score = 0

# Game object references
@onready var player = $Player
@onready var cpu = $CPU
@onready var ball = $Ball

func _ready():
	# Set screen size
	get_window().size = Vector2i(SCREEN_WIDTH, SCREEN_HEIGHT)
	get_window().position = Vector2i(100, 100)  # Adjust window position

	# Connect ball's score update signal
	ball.goal_scored.connect(_on_goal_scored)

	print("Pingpong game started!")
	print("Use A/D or Left/Right arrows to move your paddle")

func _on_goal_scored(scorer):
	if scorer == "player":
		player_score += 1
		print("Player scores! Score: Player ", player_score, " - CPU ", cpu_score)
	elif scorer == "cpu":
		cpu_score += 1
		print("CPU scores! Score: Player ", player_score, " - CPU ", cpu_score)

	# Game end check (first to 5 points)
	if player_score >= 5:
		print("Player wins!")
		_reset_game()
	elif cpu_score >= 5:
		print("CPU wins!")
		_reset_game()

func _reset_game():
	# Reset score
	player_score = 0
	cpu_score = 0

	# Reset ball position
	ball.reset_position()

	print("Game reset! New game started.")

func _input(event):
	# Exit game with ESC key
	if event.is_action_pressed("ui_cancel"):
		get_tree().quit()

Player.gd

extends CharacterBody2D

# Paddle settings
const SPEED = 300.0
const PADDLE_WIDTH = 80.0
const SCREEN_WIDTH = 360

# Collision shape settings
@onready var collision_shape = $CollisionShape2D

func _ready():
	# Set paddle collision shape
	var shape = RectangleShape2D.new()
	shape.size = Vector2(PADDLE_WIDTH, 10)
	collision_shape.shape = shape

func _physics_process(delta):
	# Get input
	var input_direction = 0

	# Process keyboard input
	if Input.is_action_pressed("ui_left") or Input.is_action_pressed("move_left"):
		input_direction = -1
	elif Input.is_action_pressed("ui_right") or Input.is_action_pressed("move_right"):
		input_direction = 1

	# Set velocity
	velocity.x = input_direction * SPEED
	velocity.y = 0  # Restrict movement on Y axis

	# Execute movement
	move_and_slide()

	# Restrict at screen boundaries
	_clamp_to_screen()

func _clamp_to_screen():
	# Restrict paddle from going off-screen
	var half_width = PADDLE_WIDTH / 2
	position.x = clamp(position.x, half_width, SCREEN_WIDTH - half_width)

# Input map settings (apart from actions automatically created in project settings)
func _input(event):
	# Movement with A/D keys (additional input options)
	pass

CPU.gd

extends CharacterBody2D

# CPU paddle settings
const SPEED = 200.0  # Set a bit slower than player
const PADDLE_WIDTH = 80.0
const SCREEN_WIDTH = 360
const REACTION_ZONE = 360.0  # React when ball is above this Y coordinate

# AI settings
const PREDICTION_FACTOR = 0.8  # Response level to ball's predicted movement
const DEAD_ZONE = 10.0  # Don't move paddle within this range

# Game object references
@onready var collision_shape = $CollisionShape2D
var ball_node: CharacterBody2D

func _ready():
	# Set paddle collision shape
	var shape = RectangleShape2D.new()
	shape.size = Vector2(PADDLE_WIDTH, 10)
	collision_shape.shape = shape

	# Get reference to ball node
	ball_node = get_parent().get_node("Ball")

func _physics_process(delta):
	if not ball_node:
		return

	# Get ball position and velocity
	var ball_position = ball_node.global_position
	var ball_velocity = ball_node.velocity

	# Only react when ball is moving toward CPU
	if ball_position.y < REACTION_ZONE and ball_velocity.y < 0:
		_move_towards_ball(ball_position, ball_velocity, delta)
	else:
		# Return to center when ball is far
		_move_to_center(delta)

	# Execute movement
	move_and_slide()

	# Restrict at screen boundaries
	_clamp_to_screen()

func _move_towards_ball(ball_pos: Vector2, ball_vel: Vector2, delta: float):
	# Calculate predicted ball position
	var time_to_reach = abs((position.y - ball_pos.y) / ball_vel.y) if ball_vel.y != 0 else 0
	var predicted_x = ball_pos.x + ball_vel.x * time_to_reach * PREDICTION_FACTOR

	# Calculate difference between paddle center and predicted ball position
	var target_x = predicted_x
	var distance = target_x - position.x

	# Don't move within dead zone
	if abs(distance) < DEAD_ZONE:
		velocity.x = 0
		return

	# Move toward target
	var direction = sign(distance)
	velocity.x = direction * SPEED
	velocity.y = 0

func _move_to_center(delta: float):
	# Move toward center of screen
	var center_x = SCREEN_WIDTH / 2
	var distance = center_x - position.x

	if abs(distance) < DEAD_ZONE:
		velocity.x = 0
		return

	var direction = sign(distance)
	velocity.x = direction * SPEED * 0.5  # Return to center a bit slower
	velocity.y = 0

func _clamp_to_screen():
	# Restrict paddle from going off-screen
	var half_width = PADDLE_WIDTH / 2
	position.x = clamp(position.x, half_width, SCREEN_WIDTH - half_width)

Ball.gd

extends CharacterBody2D

# Ball settings
const INITIAL_SPEED = 250.0
const MAX_SPEED = 400.0
const SPEED_INCREMENT = 20.0  # Speed increases with each paddle hit
const BALL_SIZE = 16.0

# Screen settings
const SCREEN_WIDTH = 360
const SCREEN_HEIGHT = 720

# Game state
var current_speed = INITIAL_SPEED
var is_serving = true

# Signal
signal goal_scored(scorer)

# Game object references
@onready var collision_shape = $CollisionShape2D

func _ready():
	# Set ball collision shape
	var shape = RectangleShape2D.new()
	shape.size = Vector2(BALL_SIZE, BALL_SIZE)
	collision_shape.shape = shape

	# Initial serve
	_serve()

func _physics_process(delta):
	if is_serving:
		return

	# Execute movement
	var collision = move_and_slide()

	# Handle collision
	if get_slide_collision_count() > 0:
		_handle_collision()

	# Check for goals
	_check_goals()

func _serve():
	# Initial setup for serve
	is_serving = true
	current_speed = INITIAL_SPEED
	position = Vector2(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)

	# Serve in random direction (either up or down)
	var angle = randf_range(-PI/4, PI/4)  # Range from -45 to 45 degrees
	if randf() > 0.5:
		angle += PI  # 50% chance of going downward

	velocity = Vector2(cos(angle), sin(angle)) * current_speed
	is_serving = false

	print("Ball served with velocity: ", velocity)

func _handle_collision():
	var collision = get_slide_collision(0)
	var collider = collision.get_collider()

	if collider:
		var collision_normal = collision.get_normal()

		# Collision with paddle
		if collider.name == "Player" or collider.name == "CPU":
			_handle_paddle_collision(collider, collision_normal)

		# Collision with wall
		elif collider.name == "Walls":
			_handle_wall_collision(collision_normal)

func _handle_paddle_collision(paddle, normal: Vector2):
	# Calculate relative position from paddle center to ball
	var paddle_center = paddle.global_position.x
	var ball_center = global_position.x
	var relative_intersect = (ball_center - paddle_center) / 40.0  # Normalize by paddle half-width

	# Calculate reflection angle (adjust angle based on relative position)
	var bounce_angle = relative_intersect * PI/3  # Maximum 60 degrees angle

	# Increase speed
	current_speed = min(current_speed + SPEED_INCREMENT, MAX_SPEED)

	# Set new velocity vector
	if paddle.name == "Player":
		# Player paddle (bottom to top)
		velocity = Vector2(sin(bounce_angle), -cos(bounce_angle)) * current_speed
	else:
		# CPU paddle (top to bottom)
		velocity = Vector2(sin(bounce_angle), cos(bounce_angle)) * current_speed

	print("Paddle hit! New speed: ", current_speed)

func _handle_wall_collision(normal: Vector2):
	# Reflection off wall (left and right walls only)
	if abs(normal.x) > 0.5:  # Left or right wall
		velocity.x = -velocity.x
		print("Wall bounce!")

func _check_goals():
	# Upper goal (player scores)
	if position.y < -20:
		goal_scored.emit("player")
		_serve()

	# Lower goal (CPU scores)
	elif position.y > SCREEN_HEIGHT + 20:
		goal_scored.emit("cpu")
		_serve()

func reset_position():
	# Reset position when game is reset
	_serve()

# Display velocity for debugging
func _input(event):
	if event.is_action_pressed("ui_accept"):  # Space key
		print("Ball position: ", position, " Velocity: ", velocity, " Speed: ", current_speed)

I also modified project.godot as follows:

project.godot

; Engine configuration file.
; It's best edited using the editor UI and not directly,
; since the parameters that go here are not all obvious.
;
; Format:
;   [section] ; section goes between []
;   param=value ; assign values to parameters

config_version=5

[application]

config/name="simple-pong"
run/main_scene="res://Main.tscn"

[display]

window/size/viewport_width=360
window/size/viewport_height=720
window/size/resizable=false

[input]

move_left={
"deadzone": 0.5,
"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":65,"key_label":0,"unicode":97,"echo":false,"script":null)
]
}
move_right={
"deadzone": 0.5,
"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":100,"echo":false,"script":null)
]
}

[rendering]

renderer/rendering_method="gl_compatibility"
renderer/rendering_method.mobile="gl_compatibility"

Testing and Fixing

After completing the implementation, I started the game in the Godot editor by pressing the F5 key.

simple-pingpong initial implementation

There were the following issues with the operation:

CPU advances every time it hits the ball
Ball gets stuck against the wall and doesn't move away
Game doesn't end even when you lose
Ball speed is too slow

After iterative dialogue with the LLM and several code revisions, I resolved the above issues.

simple-pingpong after fixes

Corrected Code