Godot 4 mini-game: Chicken run (levels 1–5) + drag boss (level 6)

This is a small, efficient, level-based 2D game you can drop into a fresh Godot 4 project. It includes:

• Chicken levels (1–5): Two cars charge head-on. Win if the rival “chickens out” (swerves) before you. Lose if you bail first or crash.

• Boss drag level (6): Side-by-side sprint vs. the crew’s leader with a simple nitro mechanic.

• Minimal visuals (drawn shapes), simple UI, a text-and-“photo book” style story narrated by the protagonist from prison.

You can expand visuals later with sprites; the logic and flow are ready.

---

Project structure

• res://Main.tscn

• res://Main.gd

• res://LevelManager.gd

• res://Car.gd

• res://AIController.gd

• res://Track.gd

• res://UI/HUD.tscn

• res://UI/HUD.gd

• res://UI/StoryPanel.tscn

• res://UI/StoryPanel.gd

---

Input map

Project Settings → Input Map. Add actions:

• accelerate: Key W or Up

• swerve_left: Key A or Left

• swerve_right: Key D or Right

• nitro: Key Space

• continue: Key Enter or Return

---

Scenes setup

Main scene

1. Create a Node2D named Main and save as res://Main.tscn.

2. Add a Node2D child named LevelRoot.

3. Add a CanvasLayer child named UI.

4. Instance res://UI/HUD.tscn as a child of UI.

5. Instance res://UI/StoryPanel.tscn as a child of UI.

6. Attach res://Main.gd to Main.

HUD scene

1. Create a Control named HUD and save as res://UI/HUD.tscn.

2. Add Labels:• LevelLabel (top-left)

• StatusLabel (center)

• HelpLabel (bottom)

3. Attach res://UI/HUD.gd.

Story panel scene

1. Create a Control named StoryPanel and save as res://UI/StoryPanel.tscn.

2. Add:• ColorRect called Vignette (full rect, semi-black with alpha 0.6).

• TextureRect called Photo (centered placeholder; leave texture empty now).

• RichTextLabel called StoryText (width-limited, autowrap, large font).

3. Attach res://UI/StoryPanel.gd.

---

Game flow

• Story intro card before Level 1.

• Levels 1–5: chicken logic (AI “bail” threshold varies).

• Level 6: drag boss with nitro and finish line.

• Post-win epilogue card.

---

Scripts

Main.gd

extends Node2D

const TOTAL_LEVELS := 6

@onready var level_root: Node2D = $LevelRoot

@onready var hud = $UI/HUD

@onready var story = $UI/StoryPanel

var level_manager: Node

func _ready() -> void:

level_manager = LevelManager.new()

add_child(level_manager)

level_manager.level_completed.connect(_on_level_completed)

level_manager.level_failed.connect(_on_level_failed)

_show_story_intro()

await story.closed

_start_level(1)

func _start_level(level_num: int) -> void:

hud.set_level(level_num)

hud.set_status("")

level_root.free_children()

var level_scene := level_manager.make_level_scene(level_num)

level_root.add_child(level_scene)

level_manager.start_level(level_num, level_scene, hud)

func _on_level_completed(level_num: int) -> void:

hud.set_status("Win! Press Enter to continue")

await _wait_continue()

if level_num < TOTAL_LEVELS:

_maybe_show_story_between(level_num)

await story.closed

_start_level(level_num + 1)

else:

_show_story_outro()

await story.closed

hud.set_status("You finished the game. Press Enter to restart.")

await _wait_continue()

_show_story_intro()

await story.closed

_start_level(1)

func _on_level_failed(level_num: int, reason: String) -> void:

hud.set_status("%s Press Enter to retry" % reason)

await _wait_continue()

_start_level(level_num)

func _maybe_show_story_between(level_num: int) -> void:

# Story beats between levels

var beats := {

1: {

"text": "[b]Cell Block D, Night 1[/b]\nI used to love engines. Then their crew turned my street into shrapnel. My daughter caught the worst of it.\nSo I learned a new kind of prayer: hold the line, don’t blink.",

"photo": null

},

2: {

"text": "[b]The First Rumor[/b]\nThey said chicken weeds out the cowards. Truth? It just measures who’s willing to lose more.",

"photo": null

},

3: {

"text": "[b]Ghosts on Asphalt[/b]\nI can still hear her laugh in the rear seat. Then metal. Glass. Silence.",

"photo": null

},

4: {

"text": "[b]Names and Knuckles[/b]\nEvery racer knew the crew. Nobody would say it. Fear is loud in the throat but quiet on the lips.",

"photo": null

},

5: {

"text": "[b]Their Leader[/b]\nHe shows up only when the road smells like blood and bragging. One more round and I’ll drag him out.",

"photo": null

}

}

if beats.has(level_num):

story.show_card(beats[level_num].text, beats[level_num].photo)

func _show_story_intro() -> void:

story.show_card("[b]A Narrow Room[/b]\nBars slice the light into thin confessions. I press my forehead to the paint and remember how the road taught me about fear.\nThey raced through my block and left her small shoes under a smoking fender. I don’t forgive. I don’t forget.\nSo I drove the only race that measures a man’s spine: chicken.", null)

func _show_story_outro() -> void:

story.show_card("[b]After[/b]\nThe boss folded at the line. No cheers. Just sirens and the hollow click of cuffs.\nPeople think the winner is the one who doesn’t blink. Prison taught me different.\nWinning is going home. I’ll keep driving this memory until the door finally opens.", null)

func _wait_continue() -> void:

await get_tree().process_frame

while true:

if Input.is_action_just_pressed("continue"):

return

await get_tree().process_frame

# Utility: free all children

func Node.free_children() -> void:

for c in get_children():

c.queue_free()

LevelManager.gd

extends Node

class_name LevelManager

signal level_completed(level_num: int)

signal level_failed(level_num: int, reason: String)

# Level configurations

var levels := [

{}, # placeholder for 0 index

{"type":"chicken", "ai_nerves": 0.45, "speed": 420.0}, # L1 - easier AI bails early

{"type":"chicken", "ai_nerves": 0.52, "speed": 450.0}, # L2

{"type":"chicken", "ai_nerves": 0.60, "speed": 480.0}, # L3

{"type":"chicken", "ai_nerves": 0.68, "speed": 520.0}, # L4

{"type":"chicken", "ai_nerves": 0.75, "speed": 560.0}, # L5 - toughest chicken

{"type":"drag", "boss_grip": 1.12, "track_len": 2200.0, "player_speed": 620.0, "boss_speed": 610.0}

]

func make_level_scene(level_num: int) -> Node2D:

var cfg = levels[level_num]

var root := Node2D.new()

root.name = "Level_%d" % level_num

# Add track

var track := Track.new()

track.level_type = cfg.type

root.add_child(track)

if cfg.type == "chicken":

_build_chicken(root)

else:

_build_drag(root)

return root

func start_level(level_num: int, scene: Node2D, hud: Node) -> void:

var cfg = levels[level_num]

if cfg.type == "chicken":

_start_chicken(level_num, scene, hud, cfg)

else:

_start_drag(level_num, scene, hud, cfg)

# ---------- Chicken levels ----------

func _build_chicken(root: Node2D) -> void:

var player := Car.new()

player.name = "Player"

player.color = Color(0.2, 0.8, 1.0)

player.position = Vector2(200, 540) # bottom going up

player.heading = Vector2(0, -1)

root.add_child(player)

var rival := Car.new()

rival.name = "Rival"

rival.color = Color(1.0, 0.3, 0.3)

rival.position = Vector2(200, 140) # top going down

rival.heading = Vector2(0, 1)

root.add_child(rival)

func _start_chicken(level_num: int, scene: Node2D, hud: Node, cfg: Dictionary) -> void:

var player: Car = scene.get_node("Player")

var rival: Car = scene.get_node("Rival")

player.mode = "chicken"

rival.mode = "chicken"

player.speed = cfg.speed

rival.speed = cfg.speed

var ai := AIController.new()

ai.control_rival_chicken(rival, player, cfg.ai_nerves)

hud.set_help("Hold W/Up to accelerate. A/D to swerve. Don’t bail first. Press Enter to continue dialogs.")

# Monitor outcome

_watch_chicken(level_num, player, rival)

func _watch_chicken(level_num: int, player: Car, rival: Car) -> void:

await get_tree().process_frame

var crashed := false

var someone_bailed := false

player.reset_state()

rival.reset_state()

while true:

# Collision check (approximate head-on proximity)

if player.lane == 0 and rival.lane == 0:

if player.position.distance_to(rival.position) < 56.0:

crashed = true

break

# Bail check

if player.bailed and rival.bailed:

# Later bail wins (hold longer)

if player.bail_time > rival.bail_time:

emit_signal("level_completed", level_num)

elif rival.bail_time > player.bail_time:

emit_signal("level_failed", level_num, "You bailed first.")

else:

emit_signal("level_failed", level_num, "Tie goes to the rival.")

return

elif player.bailed and not someone_bailed:

someone_bailed = true

elif rival.bailed and not someone_bailed:

someone_bailed = true

# If both passed each other safely without bailing on same lane, treat as victory of nerve

if player.position.y < 140 - 60 and rival.position.y > 540 + 60:

# They both crossed; if neither bailed, call it a win of steel nerves

if not player.bailed and not rival.bailed:

emit_signal("level_completed", level_num)

else:

# If only rival bailed, player wins; if only player bailed, player loses

if rival.bailed and not player.bailed:

emit_signal("level_completed", level_num)

elif player.bailed and not rival.bailed:

emit_signal("level_failed", level_num, "You bailed.")

else:

emit_signal("level_failed", level_num, "Unresolved pass.")

return

await get_tree().process_frame

if crashed:

emit_signal("level_failed", level_num, "You crashed.")

# ---------- Drag boss level ----------

func _build_drag(root: Node2D) -> void:

var player := Car.new()

player.name = "Player"

player.color = Color(0.2, 0.8, 1.0)

player.position = Vector2(160, 540)

player.heading = Vector2(0, -1)

root.add_child(player)

var boss := Car.new()

boss.name = "Boss"

boss.color = Color(1.0, 0.8, 0.2)

boss.position = Vector2(240, 540)

boss.heading = Vector2(0, -1)

root.add_child(boss)

func _start_drag(level_num: int, scene: Node2D, hud: Node, cfg: Dictionary) -> void:

var player: Car = scene.get_node("Player")

var boss: Car = scene.get_node("Boss")

player.mode = "drag"

boss.mode = "drag"

player.speed = cfg.player_speed

boss.speed = cfg.boss_speed * cfg.boss_grip

player.reset_state()

boss.reset_state()

hud.set_help("Drag Race: Hold W/Up to launch. Space for nitro burst. First past the finish wins.")

var finish_y := -cfg.track_len

# Simple AI: delayed perfect launch, timed nitro

var ai := AIController.new()

ai.control_boss_drag(boss, player, finish_y)

# Countdown

await _countdown(hud)

player.control_enabled = true

boss.control_enabled = true

# Run and detect finish

while true:

if player.position.y <= finish_y and boss.position.y <= finish_y:

emit_signal("level_failed", level_num, "Photo finish… but the boss keeps the crown.")

return

elif player.position.y <= finish_y:

emit_signal("level_completed", level_num)

return

elif boss.position.y <= finish_y:

emit_signal("level_failed", level_num, "Boss won the line.")

return

await get_tree().process_frame

func _countdown(hud: Node) -> void:

for t in [3,2,1]:

hud.set_status("Ready… %d" % t)

await get_tree().create_timer(0.8).timeout

hud.set_status("GO!")

await get_tree().create_timer(0.4).timeout

hud.set_status("")

Car.gd

extends Node2D

class_name Car

# Visuals

var color: Color = Color.WHITE

# Movement

var speed: float = 480.0

var heading: Vector2 = Vector2(0, -1)

var lane: int = 0 # -1 left, 0 center, 1 right for chicken; for drag, lanes are fixed columns

var mode: String = "chicken" # or "drag"

# State

var bailed: bool = false

var bail_time: float = 0.0

var control_enabled: bool = false

# Drag nitro

var nitro: float = 1.0 # one full burst

var nitro_active: bool = false

var nitro_timer: float = 0.0

func _ready() -> void:

set_process(true)

func reset_state() -> void:

bailed = false

bail_time = 0.0

control_enabled = false

nitro = 1.0

nitro_active = false

nitro_timer = 0.0

lane = 0

func _process(delta: float) -> void:

if mode == "chicken":

_update_chicken(delta)

else:

_update_drag(delta)

update()

func _update_chicken(delta: float) -> void:

# Always move along heading

position += heading * speed * delta

if not control_enabled:

# Let AI manipulate directly when disabled; player control becomes enabled by LevelManager if needed

control_enabled = true

if name == "Player" and control_enabled:

# Player input: A/D to swerve, W to commit forward (cosmetic here)

if not bailed:

if Input.is_action_just_pressed("swerve_left"):

_bail(-1)

elif Input.is_action_just_pressed("swerve_right"):

_bail(1)

def _bail(side: int) -> void:

bailed = true

bail_time = Time.get_unix_time_from_system()

lane = clamp(side, -1, 1)

# Swerve visually by shifting x

position.x = 200 + lane * 80

func _update_drag(delta: float) -> void:

var v := speed

if control_enabled:

if name == "Player":

if Input.is_action_pressed("accelerate"):

# Forward acceleration

pass # constant speed model

if Input.is_action_just_pressed("nitro") and nitro > 0.0 and not nitro_active:

nitro_active = true

nitro_timer = 0.8

nitro -= 1.0

if nitro_active:

v *= 1.35

nitro_timer -= delta

if nitro_timer <= 0.0:

nitro_active = false

position += heading * v * delta

func _draw() -> void:

# Simple car rectangle

var size := Vector2(36, 64)

draw_rect(Rect2(-size/2, size), color)

AIController.gd

extends Node

class_name AIController

func control_rival_chicken(rival: Car, player: Car, nerves: float) -> void:

# nerves: 0..1, higher means holds longer

rival.control_enabled = true

# Random jitter to avoid deterministic outcome

var jitter := randf_range(-0.07, 0.07)

var threshold := clamp(nerves + jitter, 0.2, 0.9)

_run(async func():

while true:

# Distance ratio to initial gap (~400)

var gap := max(1.0, player.position.distance_to(rival.position))

var approach_ratio := clamp(1.0 - (gap / 480.0), 0.0, 1.0)

# Bail if approach ratio exceeds threshold and rival hasn't bailed

if not rival.bailed and approach_ratio >= threshold:

rival._bail(sign(randf() - 0.5)) # pick random side

return

await get_tree().process_frame

)

func control_boss_drag(boss: Car, player: Car, finish_y: float) -> void:

boss.control_enabled = false # We drive it by script

_run(async func():

# Staged launch

await get_tree().create_timer(0.25 + randf()*0.1).timeout

boss.control_enabled = true

# Use nitro at mid-track

var used := false

while true:

if not used and boss.position.y < (finish_y * 0.5):

boss.nitro_active = true

boss.nitro_timer = 0.8

used = true

await get_tree().process_frame

)

# Small helper to run async blocks without clutter

func _run(block: Callable) -> void:

var co := Callable(self, "_co_runner")

co.call_deferred(block)

func _co_runner(block: Callable) -> void:

await block.call()

Track.gd

extends Node2D

class_name Track

var level_type: String = "chicken"

func _draw() -> void:

# Road

var road_rect := Rect2(Vector2(120, -2400), Vector2(160, 3000))

draw_rect(road_rect, Color(0.12,0.12,0.12))

# Lane markers

for y in range(-2400, 1200, 80):

draw_rect(Rect2(Vector2(198, y), Vector2(4, 40)), Color(1,1,1,0.6))

# Sidewalks

draw_rect(Rect2(Vector2(80, -2400), Vector2(40, 3000)), Color(0.18,0.18,0.18))

draw_rect(Rect2(Vector2(280, -2400), Vector2(40, 3000)), Color(0.18,0.18,0.18))

# Finish line for drag

if level_type == "drag":

draw_rect(Rect2(Vector2(120, -2200), Vector2(160, 14)), Color(1,1,1))

UI/HUD.gd

extends Control

@onready var level_label: Label = $LevelLabel

@onready var status_label: Label = $StatusLabel

@onready var help_label: Label = $HelpLabel

func set_level(n: int) -> void:

level_label.text = "Level %d" % n

func set_status(text: String) -> void:

status_label.text = text

func set_help(text: String) -> void:

help_label.text = text

Arrange the HUD nodes roughly:

• LevelLabel anchored top-left.

• StatusLabel centered.

• HelpLabel anchored bottom-center.

UI/StoryPanel.gd

extends Control

signal closed

@onready var vignette: ColorRect = $Vignette

@onready var photo: TextureRect = $Photo

@onready var text: RichTextLabel = $StoryText

var showing := false

func show_card(rich_text: String, tex: Texture2D) -> void:

showing = true

visible = true

modulate.a = 0.0

photo.texture = tex

text.text = rich_text

_animate_in()

await _wait_continue()

_animate_out()

visible = false

showing = false

emit_signal("closed")

func _animate_in() -> void:

var tween := create_tween().set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_OUT)

tween.tween_property(self, "modulate:a", 1.0, 0.25)

func _animate_out() -> void:

var tween := create_tween().set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN)

tween.tween_property(self, "modulate:a", 0.0, 0.2)

await tween.finished

func _wait_continue() -> void:

while true:

await get_tree().process_frame

if Input.is_action_just_pressed("continue"):

return

---

Minimal node positions and anchors

• StoryPanel: FullRect anchors/margins to fill screen. Place Photo centered (e.g., 300x180), StoryText below it with width ~70% of screen, autowrap on, BBCode enabled.

• HUD labels:• LevelLabel top-left margin (16,16).

• StatusLabel centered.

• HelpLabel bottom center, margin bottom 16.

---

Notes on mechanics

• Chicken levels:• Holding W is cosmetic for feel; the core mechanic is when you swerve.

• Rival AI uses a “nerves” threshold with slight random jitter so outcomes vary.

• Win if rival bails first or neither bails and you pass without collision. Lose if you bail first or collide.

• Drag boss:• Hold accelerate to go; Space triggers a short nitro burst. Boss launches slightly delayed, uses an optimal mid-run nitro.

• First across the finish line (y <= finish_y) wins.

---

Expandability ideas

• Replace draw_rect cars with Sprite2D nodes and real physics via CharacterBody2D if you want sliding or collisions.

• Add sound: countdown beeps, engine hum, nitro woosh.

• Add more story cards between every level with different “photos.”

• Add score, retries, and difficulty menu.

---

Quick checklist to run

• Create scenes and attach scripts as above.

• Set Main.tscn as the main scene (Project Settings → Run).

• Add input actions.

• Press Play.

If you want, I can package these scripts into a single paste-ready “one file per code block” zip listing with stronger AI behaviors or lane-based collision.