🎮 PROJECT 1: SPACE FORCE X — DISASTER STRIKES

Introduction

Space Force X: Disaster Strikes is an interactive space defense game implemented on the Basys3 FPGA development board. Players control a defensive tank positioned at the bottom of a VGA display screen to protect against waves of descending alien invaders. This intermediate-level project introduces students to complete embedded system design including Finite State Machines, real-time collision detection, synchronous hardware design patterns, and VGA display interfacing. Every pixel rendered, every collision detected, and every game state transition is a direct result of hardware logic circuits working in concert at the clock cycle level.

Project Overview

Space Force X simulates a classic top-down space defense scenario that mirrors real-world systems like air defense networks and threat detection systems. The gameplay takes place on a 640×480 pixel VGA display where time is measured in clock cycles. A player-controlled tank occupies the bottom 30 pixels of the screen. Above it, an enemy formation of aliens descends in organized rows. The objective is straightforward but demanding: destroy all alien invaders before any reach the tank’s position at Y=450 pixels. Success advances the player to progressively harder levels with increased speed and density.

The beauty of this project lies in its architectural elegance. Rather than using a high-level programming language running on a processor, Space Force X employs dedicated hardware circuits for each function. The tank position is stored in a hardware register. Alien positions are managed by arrays of flip-flops. Collision detection happens combinatorially in the same nanosecond across all entities. The rendering happens in parallel, with every pixel decision made instantly based on current entity coordinates. This parallel processing capability demonstrates why FPGAs excel at real-time systems where responsiveness cannot be delayed by software execution times.

The game implements a Mealy Finite State Machine with six distinct states: START_SCREEN (awaiting player input), PLAYING_LEVEL_1 (active gameplay on level one), PLAYING_LEVEL_2 (faster difficulty), LEVEL_ADVANCE (brief transition state), PAUSE_STATE (game frozen), and GAME_OVER (end screen). Each state has precisely defined entry conditions and exit conditions. State transitions happen synchronously on clock edges, ensuring deterministic behavior essential for reliable embedded systems. This FSM design teaches professional hardware architecture patterns used in aerospace, automotive, and industrial control applications.

What Project Does

The game begins with a START_SCREEN displaying “SPACE FORCE X” and waiting for keyboard input. The moment a player presses any key, the FSM transitions to PLAYING_LEVEL_1. The screen now displays a formation of 24 aliens arranged in 3 rows of 8, positioned at the top of the screen. Simultaneously, the tank appears at the bottom center, ready to defend. The player controls movement using arrow keys: A moves the tank left (decrements the tank_x register by 4 pixels per clock cycle), D moves right (increments tank_x by 4), and W fires a bullet upward. The tank cannot move beyond screen boundaries (X must remain between 0 and 600).

As the game progresses, aliens move downward at a constant rate controlled by a movement counter. Every 8 clock cycles, all alien Y-coordinates decrement by 2 pixels, creating the illusion of smooth descent. When the player presses W, a new bullet object is created at the current tank X position and begins moving upward at 5 pixels per cycle. The collision detection module runs combinatorially every cycle, comparing every bullet’s position against every alien’s position. The moment a bullet’s X-coordinate matches an alien’s X-coordinate (within a 10-pixel tolerance) AND the bullet’s Y-coordinate falls within the alien’s Y range (20 pixels tall), a collision is instantly detected. The alien is removed from the playfield, the bullet is destroyed, and the score increments by 100 points. Visual feedback occurs immediately—some implementations flash the hit location or change colors briefly.

The game continues until one of two end conditions occurs: (1) All aliens are destroyed, triggering LEVEL_ADVANCE—a brief 2-second pause displaying “LEVEL COMPLETE” before advancing to PLAYING_LEVEL_2 where aliens move 2× faster; or (2) Any alien reaches Y=450 (the tank position), triggering an immediate loss of life. The player begins with 3 lives. Each alien reaching the bottom costs one life. When lives reach 0, the game transitions to GAME_OVER, displaying the final score and waiting for the player to press the reset button (U) to return to START_SCREEN. The pause button (P) can freeze the game at any time, maintaining all entity positions and FSM state until pressed again.

Hardware Requirements

Total Estimated Cost: $150-250 USD. The FPGA board is reusable for all 8 projects, so it’s a one-time investment. Monitors and keyboards may already be available.

Input Specification

Type of Controls

Control Details

Keyboard Input Processing: The PS/2 keyboard continuously transmits scan codes to the FPGA’s PS/2 interface module. The module converts these scan codes (which represent physical key positions) into ASCII values. The input handler monitors the ASCII values and sets digital flags: key_left, key_right, key_fire, key_pause, and key_reset. These flags persist as long as keys are held down, allowing smooth continuous movement.

Debouncing: Mechanical switches bounce—they make and break contact multiple times within a few milliseconds. Without debouncing, a single button press would register as multiple rapid presses. The debounce circuit uses a simple counter: after detecting an input transition, it waits 20ms (2,000,000 clock cycles at 100 MHz) before accepting another change. If the input returns to its original state within 20ms, it’s considered noise and ignored. Only changes that persist for 20ms are considered valid inputs.

Multi-key Handling: The FPGA can detect multiple simultaneous key presses. A player can hold A to move left while pressing W to fire, and both actions execute immediately. This simultaneous input handling is one of the advantages of parallel hardware logic versus sequential software execution.

FSM Diagram

FSM State Transition Diagram

START SCREEN

PLAYING LEVEL_1

LEVEL ADVANCE

PLAYING LEVEL_2

PAUSE

GAME_OVER

any_key_press

aliens_cleared

2sec_delay_done

P_button

P_button

aliens_reach_bottom

aliens_reach_bottom

U_button (reset)

State Descriptions: START_SCREEN: Display title, wait for input | PLAYING_LEVEL_1/2: Active gameplay | LEVEL_ADVANCE: Transition state PAUSE_STATE: Game frozen | GAME_OVER: Show final score, wait for reset

FSM Transitions (Detailed List)

FSM Implementation (Verilog Code)

// ===== FSM Parameter Definition =====
parameter START_SCREEN = 3'b000;
parameter PLAYING_LEVEL_1 = 3'b001;
parameter PLAYING_LEVEL_2 = 3'b010;
parameter LEVEL_ADVANCE = 3'b011;
parameter GAME_OVER = 3'b100;
parameter PAUSE_STATE = 3'b101;

// ===== State Registers =====
reg [2:0] current_state, next_state;
reg [31:0] state_timer;
reg level_advance_done;

// ===== Sequential Logic - State Updates =====
always @(posedge clk) begin
  if (reset_button || power_on_reset)
    current_state <= START_SCREEN;
  else
    current_state <= next_state;
end

// ===== Combinational Logic - Next State Determination =====
always @(*) begin
  case (current_state)
    START_SCREEN: begin
      if (key_left || key_right || key_fire)
        next_state = PLAYING_LEVEL_1;
      else
        next_state = START_SCREEN;
    end
    
    PLAYING_LEVEL_1: begin
      if (aliens_cleared)
        next_state = LEVEL_ADVANCE;
      else if (aliens_reached_bottom || lives == 0)
        next_state = GAME_OVER;
      else if (pause_button)
        next_state = PAUSE_STATE;
      else
        next_state = PLAYING_LEVEL_1;
    end
    
    LEVEL_ADVANCE: begin
      if (state_timer > 200000000) // 2 seconds @ 100MHz
        next_state = PLAYING_LEVEL_2;
      else
        next_state = LEVEL_ADVANCE;
    end
    
    PLAYING_LEVEL_2: begin
      if (aliens_cleared)
        next_state = GAME_OVER; // Win condition
      else if (aliens_reached_bottom || lives == 0)
        next_state = GAME_OVER; // Lose condition
      else if (pause_button)
        next_state = PAUSE_STATE;
      else
        next_state = PLAYING_LEVEL_2;
    end
    
    PAUSE_STATE: begin
      if (pause_button)
        next_state = (prev_state == PLAYING_LEVEL_1) ? PLAYING_LEVEL_1 : PLAYING_LEVEL_2;
      else
        next_state = PAUSE_STATE;
    end
    
    GAME_OVER: begin
      if (reset_button)
        next_state = START_SCREEN;
      else
        next_state = GAME_OVER;
    end
    
    default: next_state = START_SCREEN;
  endcase
end

// ===== State Timer Management =====
always @(posedge clk) begin
  if (current_state != LEVEL_ADVANCE)
    state_timer <= 32'd0;
  else
    state_timer <= state_timer + 1'b1;
end

Output Specification

VGA Display Details

Display Information Breakdown

SCORE: 1500

LEVEL: 1

LIVES: 3

Tank: BLUE | Aliens: PINK | Bullets: WHITE | Background: BLACK

Color Palette: Tank = RGB (0000_1111_1111) Blue, Aliens = RGB (1111_0000_1111) Pink/Magenta, Bullets = RGB (1111_1111_1111) White, Background = RGB (0000_0000_0000) Black

Sensor Integration

Space Force X uses digital keyboard input only—no analog sensors are integrated. The PS/2 keyboard interface is fully digital, receiving scan codes as serial data over a synchronous clock line. Future enhancements could integrate analog joystick input through ADC (Analog-to-Digital Converter) modules, but the baseline project uses only the keyboard for simplicity and to focus on core game logic.

Game Flow Diagram

DISPLAY START SCREEN

WAIT FOR INPUT

INIT LEVEL (Aliens, Tank)

MAIN GAME LOOP Process Input | Update Positions Check Collisions | Render Display

Repeat Every Frame

Aliens Cleared?

YES

LEVEL_ADVANCE

collision = (|bullet_x - alien_x| < 10) AND (bullet_y >= alien_y) AND (bullet_y <= alien_y + 20)

if (key_left AND tank_x > 0) then tank_x <= tank_x - 4
if (key_right AND tank_x < 600) then tank_x <= tank_x + 4

// ===== MAIN GAME LOOP (executes every clock cycle) =====

if (current_state == PLAYING_LEVEL_1 OR current_state == PLAYING_LEVEL_2) then
  
  // ===== INPUT PROCESSING =====
  if (key_left AND tank_x > 0) then
    tank_x <= tank_x - 4
  else if (key_right AND tank_x < 600) then
    tank_x <= tank_x + 4
  end if
  
  if (key_fire AND bullet_count < MAX_BULLETS) then
    create_bullet(tank_x, 420)
    bullet_count <= bullet_count + 1
  end if
  
  // ===== POSITION UPDATES =====
  for each active_bullet do
    bullet.y <= bullet.y - BULLET_SPEED
    if (bullet.y < 0) then
      destroy_bullet()
    end if
  end for
  
  // Alien movement (every 8 cycles)
  alien_move_counter <= alien_move_counter + 1
  if (alien_move_counter == 8) then
    for each active_alien do
      alien.y <= alien.y + ALIEN_SPEED
    end for
    alien_move_counter <= 0
  end if
  
  // ===== COLLISION DETECTION (Combinational) =====
  for each bullet in bullets do
    for each alien in aliens do
      if (collision_detected(bullet, alien)) then
        mark_bullet_for_removal(bullet)
        mark_alien_for_removal(alien)
        score <= score + 100
      end if
    end for
  end for
  
  // Remove marked entities
  remove_all_marked_bullets()
  remove_all_marked_aliens()
  
  // ===== WIN/LOSE CONDITION CHECKS =====
  if (aliens_cleared) then
    FSM_state <= LEVEL_ADVANCE
  end if
  
  if (aliens_reached_bottom) then
    lives <= lives - 1
    if (lives == 0) then
      FSM_state <= GAME_OVER
    else
      reset_level()
    end if
  end if
  
end if

// ===== DISPLAY RENDERING (Combinational - no clock) =====

assign pixel_color = (is_in_score_bar) ? render_score_text :
                     (is_in_tank) ? BLUE :
                     (is_in_bullet) ? WHITE :
                     (is_in_alien) ? PINK :
                     BLACK;

// ===== Detailed Pixel Decision Logic =====

wire is_in_tank = (pixel_x >= tank_x) AND (pixel_x <= tank_x + 40) AND
                  (pixel_y >= 450) AND (pixel_y <= 480);

wire is_in_bullet = distance(pixel_x, pixel_y, bullet_x, bullet_y) < 2;

wire is_in_alien = distance(pixel_x, pixel_y, alien_x, alien_y) < 15;

// ===== Color Definitions =====
parameter BLUE = 12'b0000_1111_1111;
parameter PINK = 12'b1111_0000_1111;
parameter WHITE = 12'b1111_1111_1111;
parameter BLACK = 12'b0000_0000_0000;
parameter GREEN_TEXT = 12'b0000_1111_0000;