Build
Space Invaders
From Scratch

Before building anything visible, create a script that remembers the score, lives, and wave number. This is called GameState.

# GameState.gd — type this exactly
extends Node

# var creates a variable — a box that holds a number
var score: int = 0
var lives: int = 3
var wave:  int = 1
var hi_score: int = 0

• FileSystem panel → right-click res:// → New Script → name it GameState.gd → type the code above
• Press Ctrl+S to save
• Project → Project Settings → Autoload tab → add GameState.gd → click Add

The player ship moves left/right and fires bullets. It's built from three nodes stacked together.

• Scene → New Scene → add Area2D root → rename it "Player"
• Add Sprite2D child → add CollisionShape2D child → set shape to RectangleShape2D
• Save as Player.tscn → attach a new script Player.gd

# Player.gd
extends Area2D
const SPEED = 180.0
const SCREEN_W = 480.0
var can_shoot = true

func _process(delta):
    var dir = int(Input.is_action_pressed("ui_right")) - int(Input.is_action_pressed("ui_left"))
    position.x = clamp(position.x + dir * SPEED * delta, 20, SCREEN_W - 20)
    if Input.is_action_just_pressed("ui_accept") and can_shoot:
        shoot()

Both the player and the aliens fire bullets. Build one bullet scene and reuse it for both — just change the direction.

# Bullet.gd
extends Area2D
# -1.0 = flies UP (player)  +1.0 = flies DOWN (enemy)
@export var direction: float = -1.0
@export var speed: float = 400.0
@export var is_enemy: bool = false

func _process(delta):
    position.y += speed * direction * delta
    # Delete bullet when it leaves the screen
    if position.y < -20 or position.y > 650:
        queue_free()

Build a single alien scene. Later, the AlienGrid script will create 55 copies of it automatically.

# Alien.gd
extends Area2D
signal alien_killed(points, pos)
# 0=squid(10pts)  1=crab(20pts)  2=ufo-row(30pts)
@export var alien_type: int = 0
@export var points: int = 10

func _ready():
    add_to_group("aliens")
    match alien_type:
        0: $AnimatedSprite2D.play("a")
        1: $AnimatedSprite2D.play("b")
        2: $AnimatedSprite2D.play("c")

func die():
    alien_killed.emit(points, global_position)
    queue_free()

The most complex script in the game. Take your time — read each section before typing it. AlienGrid does three jobs:

• Fills the screen with 55 aliens (11 columns × 5 rows)
• Marches them sideways, drops them down when they hit an edge
• Picks a random alien at the bottom of each column to shoot at the player

# AlienGrid.gd — variables section
extends Node2D
signal all_dead
signal reached_bottom
signal enemy_bullet_fired(pos)

const COLS = 11
const ROWS = 5
const SPACING_X = 36
const SPACING_Y = 32
const ROW_POINTS = [30, 20, 20, 10, 10]
var _dir: float = 1.0
var _step_interval: float = 0.8
const AlienScene = preload("res://Alien.tscn")

Four destructible shields the player can hide behind. Both player and alien bullets chip chunks out of them.

• Create a new scene → StaticBody2D root → rename "Barrier"
• Add a Sprite2D child (your shield image) and a CollisionShape2D
• Attach Barrier.gd — the script tracks health and destroys the node when it hits zero
• Save as Barrier.tscn

Also create an Explosion scene — an AnimatedSprite2D that plays a short animation then deletes itself with queue_free().

# Barrier.gd — simplified
extends StaticBody2D
var health = 4

func take_hit():
    health -= 1
    # Update sprite to show damage
    $Sprite2D.frame = 4 - health
    if health <= 0:
        queue_free()

Every game needs pictures. This chapter covers drawing your pixel art sprites and wiring them into the scenes.

Sprites you need to draw:

• Player ship — facing up, roughly 32×24px
• 3 alien types × 2 walk frames each — squid, crab, ufo-row
• Explosion — 3–4 frames of pixel burst
• Barrier — 5 damage states (full → destroyed)
• Player bullet — thin vertical sprite
• Enemy bullet — 2 frames for zigzag animation

The Main scene brings everything together — it creates the player, alien grid, and barriers, and connects all the signals.

• Scene → New Scene → Node2D root → rename "Main"
• Add AlienGrid as a child node (attach AlienGrid.gd to it)
• Add Player (instance Player.tscn) → position at bottom centre
• Add 4 Barrier instances → spread evenly across the screen
• Add a CanvasLayer → add Labels for score, hi-score, and lives HUD

# Main.gd — signal connections in _ready()
func _ready():
    $AlienGrid.all_dead.connect(_on_wave_clear)
    $AlienGrid.reached_bottom.connect(_on_game_over)
    $AlienGrid.enemy_bullet_fired.connect(_on_enemy_shoot)
    $Player.player_shot.connect(_on_player_shoot)

This is the moment you've been working toward. Set Main.tscn as the main scene and press F5.

• Project → Project Settings → Application → Run → set Main Scene to Main.tscn
• Press F5 to run the game
• Move with arrow keys, shoot with Space

Common fixes:

• Aliens not moving → Check AlienGrid.gd is attached to the AlienGrid node
• Player invisible → Sprite2D has no texture assigned
• Can't shoot → Check Player.gd signal is connected in Main._ready()
• Score not updating → GameState Autoload not registered in Project Settings

Your game works. Now make it yours. Here are challenges to push further.

• Add a UFO that flies across the top row occasionally for bonus points
• Add sound effects — laser shoot, alien death, player death, wave clear
• Make aliens speed up faster as their numbers drop — tweak _step_interval
• Add a High Score that saves to disk using FileAccess
• Draw custom alien sprites to replace the placeholders
• Add a main menu scene with a Play button and instructions
• Export to HTML5 and upload to itch.io — share your game!