Creating a Snake Game

An in-depth guide to building your own Snake game in Python

Key Takeaways

Python & Pygame: Learn how to set up the Python environment using Pygame for graphics and event management.
Game Mechanics: Understand movement, collision detection, food generation, and scoring logic.
Step-by-Step Development: Follow detailed instructions and sample code to structure and develop the game.

Introduction

The classic Snake game is a timeless project that serves as an excellent introduction to game development using Python. This guide will walk you through creating a Snake game from scratch using the Pygame library. Whether you are a beginner or looking to deepen your understanding of event handling, game loops, and collision detection, this comprehensive guide provides practical insights with clear instructions and example code.

Setting Up Your Environment

Prerequisites

Before diving into coding, ensure you have the following prerequisites:

Basic knowledge of Python programming.
Pygame library installed. You can install it by executing: pip install pygame in your terminal or command prompt.
A text editor or IDE (such as Visual Studio Code, PyCharm, or Sublime Text).

The Pygame Library

Pygame is a set of Python modules designed for writing video games. It provides functionality for handling graphics, sounds, and input events, making it a robust option for building 2D games. For this project, we will use Pygame to create the game window, manage game states, and process keyboard inputs for controlling the snake.

Game Design and Mechanics

Game Structure

The Snake game operates on a grid-based system where:

The snake moves continuously in one direction until redirected by the user.
The snake's head position is tracked separately from its body segments.
When the snake eats food, it grows by adding a segment at its tail.
The game ends if the snake collides with the boundaries of the window or with itself.

Core Components

The game can be broken down into several core components:

Game Window Initialization: Setting up the display window and initializing essential variables.
Snake Representation: Managing the snake’s current position, its body as a list of coordinates, and its current movement direction.
Food Generation: Randomly placing food on the grid which the snake can consume to grow longer.
Movement and Input Handling: Capturing keyboard events to change directions while ensuring that invalid moves (like direct reversal) are prevented.
Collision Detection: Determining if the snake hits the boundaries or itself.
Game Loop: A continuous loop that updates game states, processes inputs, and redraws graphics on the screen.

Feature Comparison: Pygame vs. Turtle

While there are multiple libraries available for creating graphical applications in Python, Pygame is the preferred choice for developing this game because of its performance and control over game mechanics. Below is a comparison table highlighting some differences between Pygame and another popular option, Turtle.

Feature	Pygame	Turtle
Complexity	Suited for advanced graphics and game mechanics	Simple, beginner-friendly
Performance	Higher performance; can handle more complex games	Limited performance for complex animations
Control	Greater control over game states and event handling	Basic control mostly for educational purposes
Sound and Music	Supports full features for sound effects and background music	Very limited sound support
Community and Resources	Large community with extensive documentation	Much smaller community

Developing the Game

Step 1: Initializing Pygame and Setting Up the Screen

The first step in building the game involves setting up the Pygame environment. This includes initializing Pygame, setting up the game window, and defining essential global variables such as screen dimensions, colors, and clock settings to control the game’s frame rate.

Below is an example snippet that initializes the game window and defines fundamental variables:


# Initialize pygame
import pygame
import sys
import random

pygame.init()

# Screen dimensions and cell size
WIDTH = 600
HEIGHT = 400
CELL_SIZE = 20

# Define colors using RGB values
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GREEN = (0, 200, 0)
RED = (200, 0, 0)

# Set up the game display and clock
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Snake Game')
clock = pygame.time.Clock()
FPS = 10  # Frames per second

Step 2: Defining the Snake and Food

In this step, you'll represent the snake as a list of coordinates. The head of the snake is managed separately, with the tail following as the snake moves. Food is generated at random positions on the grid.

The following code outlines the initial definitions for the snake’s starting position and the logic to generate food randomly:


# Define the initial snake and its body segments
snake_pos = [100, 50]
snake_body = [[100, 50], [80, 50], [60, 50]]
direction = 'RIGHT'
change_to = direction

# Function to generate food at random locations
def get_random_food_position():
    x = random.randrange(0, WIDTH, CELL_SIZE)
    y = random.randrange(0, HEIGHT, CELL_SIZE)
    return [x, y]

# Initialize food position
food_pos = get_random_food_position()
food_spawn = True

Step 3: Handling User Input and Movement

A critical part of the game is processing user inputs to change the snake's direction. This involves capturing keyboard events and ensuring that any change in direction does not allow for a reversal (e.g., moving directly from left to right).

The following snippet shows how to handle key presses and update the snake’s direction accordingly:


# Main game loop: process events and update direction
for event in pygame.event.get():
    if event.type == pygame.QUIT:
        pygame.quit()
        sys.exit()
    if event.type == pygame.KEYDOWN:
        if event.key == pygame.K_UP or event.key == pygame.K_w:
            change_to = 'UP'
        elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
            change_to = 'DOWN'
        elif event.key == pygame.K_LEFT or event.key == pygame.K_a:
            change_to = 'LEFT'
        elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
            change_to = 'RIGHT'

# Prevent the snake from moving in the opposite direction immediately
if change_to == 'UP' and direction != 'DOWN':
    direction = 'UP'
elif change_to == 'DOWN' and direction != 'UP':
    direction = 'DOWN'
elif change_to == 'LEFT' and direction != 'RIGHT':
    direction = 'LEFT'
elif change_to == 'RIGHT' and direction != 'LEFT':
    direction = 'RIGHT'

Step 4: Updating the Snake's Position and Growing its Body

With each iteration of the game loop, the snake's head moves in the current direction. The snake body is updated by inserting the new head position at the beginning of the list. If the snake’s head touches the food, the snake grows; otherwise, the tail is removed so that the snake maintains its length. Here is an example of this game logic:


# Update snake's position based on its direction
if direction == 'UP':
    snake_pos[1] -= CELL_SIZE
elif direction == 'DOWN':
    snake_pos[1] += CELL_SIZE
elif direction == 'LEFT':
    snake_pos[0] -= CELL_SIZE
elif direction == 'RIGHT':
    snake_pos[0] += CELL_SIZE

# Insert new head position into the snake body list (growing the snake)
snake_body.insert(0, list(snake_pos))

# Check if snake has consumed food
if snake_pos == food_pos:
    food_spawn = False  # The food is eaten so do not remove the tail
else:
    snake_body.pop()  # Remove the tail to simulate movement

If the snake eats food, food_spawn is marked false to allow new food generation at a random location.

Step 5: Generating Food and Managing the Game Loop

The food is respawned once it is consumed by the snake. Managing the food spawn involves checking whether the food has been consumed and then creating a new food item at another random location on the grid.


# Spawn new food on the screen if needed
if not food_spawn:
    food_pos = get_random_food_position()
    food_spawn = True

# Fill the background and draw the snake and food
screen.fill(BLACK)
for pos in snake_body:
    pygame.draw.rect(screen, GREEN, pygame.Rect(pos[0], pos[1], CELL_SIZE, CELL_SIZE))
pygame.draw.rect(screen, RED, pygame.Rect(food_pos[0], food_pos[1], CELL_SIZE, CELL_SIZE))

pygame.display.update()
clock.tick(FPS)

Step 6: Collision Detection and Ending the Game

Collision detection is crucial to determine when the snake hits the boundaries or collides with itself. When this occurs, the game should display a game over message and terminate gracefully.


# Function to display Game Over message
def game_over():
    font = pygame.font.SysFont('times new roman', 50)
    GO_surface = font.render('Game Over', True, RED)
    GO_rect = GO_surface.get_rect()
    GO_rect.midtop = (WIDTH/2, HEIGHT/4)
    screen.blit(GO_surface, GO_rect)
    pygame.display.flip()
    # Delay before exiting so the player can read the message
    pygame.time.delay(2000)
    pygame.quit()
    sys.exit()

# Check for collisions with boundaries
if snake_pos[0] < 0 or snake_pos[0] >= WIDTH or snake_pos[1] < 0 or snake_pos[1] >= HEIGHT:
    game_over()

# Check for snake colliding with its own body
for block in snake_body[1:]:
    if snake_pos == block:
        game_over()

Complete Sample Code

Combining all the steps discussed above, here is a complete version of the Snake game using Python and Pygame. This code incorporates initialization, movement, food generation, and collision detection.


import pygame
import sys
import random

# Initialize pygame
pygame.init()

# Screen dimensions and cell size
WIDTH, HEIGHT = 600, 400
CELL_SIZE = 20

# Colors (RGB)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GREEN = (0, 200, 0)
RED = (200, 0, 0)

# Set up the game display and clock
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Snake Game')
clock = pygame.time.Clock()
FPS = 10

# Initial snake starting position and its body segments
snake_pos = [100, 50]
snake_body = [[100, 50], [80, 50], [60, 50]]
direction = 'RIGHT'
change_to = direction

# Function to generate food at random locations
def get_random_food_position():
    x = random.randrange(0, WIDTH, CELL_SIZE)
    y = random.randrange(0, HEIGHT, CELL_SIZE)
    return [x, y]

# Initialize food details
food_pos = get_random_food_position()
food_spawn = True

# Function to display a Game Over message and terminate the game
def game_over():
    font = pygame.font.SysFont('times new roman', 50)
    GO_surface = font.render('Game Over', True, RED)
    GO_rect = GO_surface.get_rect()
    GO_rect.midtop = (WIDTH/2, HEIGHT/4)
    screen.blit(GO_surface, GO_rect)
    pygame.display.flip()
    pygame.time.delay(2000)
    pygame.quit()
    sys.exit()

# Main game loop
while True:
    # Event handling
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_UP or event.key == pygame.K_w:
                change_to = 'UP'
            elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
                change_to = 'DOWN'
            elif event.key == pygame.K_LEFT or event.key == pygame.K_a:
                change_to = 'LEFT'
            elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
                change_to = 'RIGHT'
    
    # Validate direction changes (avoid 180 degree turns)
    if change_to == 'UP' and direction != 'DOWN':
        direction = 'UP'
    elif change_to == 'DOWN' and direction != 'UP':
        direction = 'DOWN'
    elif change_to == 'LEFT' and direction != 'RIGHT':
        direction = 'LEFT'
    elif change_to == 'RIGHT' and direction != 'LEFT':
        direction = 'RIGHT'
    
    # Update snake position based on the current direction
    if direction == 'UP':
        snake_pos[1] -= CELL_SIZE
    elif direction == 'DOWN':
        snake_pos[1] += CELL_SIZE
    elif direction == 'LEFT':
        snake_pos[0] -= CELL_SIZE
    elif direction == 'RIGHT':
        snake_pos[0] += CELL_SIZE
    
    # Grow snake by adding new head position
    snake_body.insert(0, list(snake_pos))
    if snake_pos == food_pos:
        food_spawn = False
    else:
        snake_body.pop()
    
    # Spawn new food if necessary
    if not food_spawn:
        food_pos = get_random_food_position()
        food_spawn = True
    
    # Fill screen background
    screen.fill(BLACK)
    
    # Draw snake on the screen
    for pos in snake_body:
        pygame.draw.rect(screen, GREEN, pygame.Rect(pos[0], pos[1], CELL_SIZE, CELL_SIZE))
    
    # Draw food on the screen
    pygame.draw.rect(screen, RED, pygame.Rect(food_pos[0], food_pos[1], CELL_SIZE, CELL_SIZE))
    
    # Collision Detection: Check if snake hits boundaries
    if snake_pos[0] < 0 or snake_pos[0] >= WIDTH or snake_pos[1] < 0 or snake_pos[1] >= HEIGHT:
        game_over()
    
    # Collision Detection: Check if snake collides with itself
    for block in snake_body[1:]:
        if snake_pos == block:
            game_over()
    
    # Update display and control frame rate
    pygame.display.update()
    clock.tick(FPS)

Enhancements and Further Considerations

Adding Scoring and Levels

A common extension is implementing a scoring system. Each time the snake eats food, the score can be incremented, which might eventually lead to an increase in speed or the introduction of obstacles. Display the score using pygame’s text rendering features.

For instance, after the food consumption check within your game loop, you can maintain a score variable and update it:


score = 0

# When snake eats food, update the score
if snake_pos == food_pos:
    score += 10  # Increase score by a predetermined value

Then, use the pygame.font module to render the score on the screen.

Sound Effects and Music

Incorporating sound effects can greatly enhance the gaming experience. Pygame supports sound playback through its mixer module. Load sound files for events like food consumption, game over, or even background music.

Example:


pygame.mixer.init()
# Load sound files
eat_sound = pygame.mixer.Sound('eat.wav')
game_over_sound = pygame.mixer.Sound('game_over.wav')

# Play sound when food is consumed
if snake_pos == food_pos:
    pygame.mixer.Sound.play(eat_sound)

Increasing Challenge with Obstacles

For a more advanced version, consider adding obstacles that appear as the game progresses. These obstacles can provide additional challenge as the snake navigates the screen. Use similar logic to generate random positions for obstacles and check for collision with the snake.

Refactoring Code for Scalability

As your game grows in complexity, it might be beneficial to refactor your code using object-oriented programming principles. Create classes for the Snake, Food, and possibly a GameManager to handle overall game states. This makes your code easier to maintain and extend.

Conclusion

Building a Snake game in Python using the Pygame library is an excellent project that introduces you to the fundamentals of game development, including event handling, animation, collision detection, and sound integration. You started by setting up your environment and Pygame, then moved to defining game logic such as snake movement, food generation, score management, and collision detection. With this comprehensive guide and the complete sample code provided, you now have a solid foundation to create and extend your own Snake game.

References

How to add levels and obstacles in snake game

Integrating sound effects in Pygame Snake game

Refactoring snake game using OOP in Python

Last updated February 19, 2025