Snake Game with Tkinter

Introduction

The classic Snake Game is a simple yet popular game where a snake moves around the screen, eats food, and grows in length. The player must avoid crashing into walls or the snake’s own body. This game is perfect for learning:

• GUI programming (using Tkinter)
• Basic game loops
• Keyboard event handling
• Collision detection
• Simple animation

We’ll build a basic version using Python’s Tkinter library.

How it Works

We use Tkinter’s Canvas widget to draw the game grid.

• The snake is a list of square “segments.”
• The snake moves automatically in a direction, controlled by arrow keys.

• Food randomly appears on the grid.

• If the snake eats food:

1. The snake grows longer.
2. The score increases.

• If the snake collides with:

1. The wall
2. Itself
3. → the game ends.

Code

Below is a fully working Snake Game in Tkinter:

import tkinter as tk
import random

# --------------------------
# Game configuration
# --------------------------

GAME_WIDTH = 600
GAME_HEIGHT = 600
SPEED = 100           # Lower is faster
SPACE_SIZE = 20       # Size of each segment
BODY_PARTS = 3
SNAKE_COLOR = "#00FF00"
FOOD_COLOR = "#FF0000"
BACKGROUND_COLOR = "#000000"

# --------------------------
# Snake class
# --------------------------

class Snake:
    def __init__(self):
        self.body_size = BODY_PARTS
        self.coordinates = []
        self.squares = []

        for i in range(0, BODY_PARTS):
            self.coordinates.append([0, 0])

        for x, y in self.coordinates:
            square = canvas.create_rectangle(x, y, x + SPACE_SIZE, y + SPACE_SIZE,
                                             fill=SNAKE_COLOR, tag="snake")
            self.squares.append(square)

# --------------------------
# Food class
# --------------------------

class Food:
    def __init__(self):
        x = random.randint(0, (GAME_WIDTH // SPACE_SIZE) - 1) * SPACE_SIZE
        y = random.randint(0, (GAME_HEIGHT // SPACE_SIZE) - 1) * SPACE_SIZE
        self.coordinates = [x, y]

        canvas.create_oval(x, y, x + SPACE_SIZE, y + SPACE_SIZE,
                           fill=FOOD_COLOR, tag="food")

# --------------------------
# Functions
# --------------------------

def next_turn(snake, food):
    x, y = snake.coordinates[0]

    if direction == "up":
        y -= SPACE_SIZE
    elif direction == "down":
        y += SPACE_SIZE
    elif direction == "left":
        x -= SPACE_SIZE
    elif direction == "right":
        x += SPACE_SIZE

    # Add new head segment
    snake.coordinates.insert(0, (x, y))

    square = canvas.create_rectangle(x, y, x + SPACE_SIZE, y + SPACE_SIZE,
                                     fill=SNAKE_COLOR)
    snake.squares.insert(0, square)

    if x == food.coordinates[0] and y == food.coordinates[1]:
        global score
        score += 1

        label.config(text="Score:{}".format(score))

        canvas.delete("food")
        food = Food()

    else:
        # Remove the tail segment
        del snake.coordinates[-1]
        canvas.delete(snake.squares[-1])
        del snake.squares[-1]

    if check_collisions(snake):
        game_over()
    else:
        window.after(SPEED, next_turn, snake, food)

def change_direction(new_direction):
    global direction

    if new_direction == 'left' and direction != 'right':
        direction = new_direction
    elif new_direction == 'right' and direction != 'left':
        direction = new_direction
    elif new_direction == 'up' and direction != 'down':
        direction = new_direction
    elif new_direction == 'down' and direction != 'up':
        direction = new_direction

def check_collisions(snake):
    x, y = snake.coordinates[0]

    # Check walls
    if x < 0 or x >= GAME_WIDTH:
        return True
    if y < 0 or y >= GAME_HEIGHT:
        return True

    # Check self collision
    for body_part in snake.coordinates[1:]:
        if x == body_part[0] and y == body_part[1]:
            return True

    return False

def game_over():
    canvas.delete(tk.ALL)
    canvas.create_text(canvas.winfo_width() / 2,
                       canvas.winfo_height() / 2,
                       font=('consolas', 40),
                       text="GAME OVER",
                       fill="red",
                       tag="gameover")

# --------------------------
# Main Program
# --------------------------

window = tk.Tk()
window.title("Snake Game")
window.resizable(False, False)

score = 0
direction = 'down'

label = tk.Label(window, text="Score:{}".format(score), font=('consolas', 20))
label.pack()

canvas = tk.Canvas(window, bg=BACKGROUND_COLOR,
                   height=GAME_HEIGHT, width=GAME_WIDTH)
canvas.pack()

window.update()

# Center the window on the screen
window_width = window.winfo_width()
window_height = window.winfo_height()
screen_width = window.winfo_screenwidth()
screen_height = window.winfo_screenheight()

x = int((screen_width/2) - (window_width/2))
y = int((screen_height/2) - (window_height/2))

window.geometry(f"{window_width}x{window_height}+{x}+{y}")

snake = Snake()
food = Food()

window.bind('<Left>', lambda event: change_direction('left'))
window.bind('<Right>', lambda event: change_direction('right'))
window.bind('<Up>', lambda event: change_direction('up'))
window.bind('<Down>', lambda event: change_direction('down'))

next_turn(snake, food)

window.mainloop()

Conclusion

The Snake Game project is a great way to learn Python’s Tkinter library and fundamental programming concepts like:

• GUI design
• Event handling (keyboard input)
• Animation using the game loop
• Collision detection
• Working with classes and objects

Even though it’s a simple game, it introduces important ideas used in larger applications and games. You can expand this project further by:

• Adding levels or obstacles
• Creating a high-score system
• Changing graphics or themes
• Improving game speed and difficulty
• Adding sound effects

Building games like Snake is not only fun but also sharpens your coding and problem-solving skills. Keep experimenting and enhancing your project!

Happy coding! 🚀