Snake Game in Java

Java, with its robust object-oriented programming capabilities, has been a popular choice for game development. One classic game that serves as an excellent project for Java enthusiasts is the Snake game. In this section, we will explore the intricacies of building a Snake game in Java, from the basic mechanics to advanced features and optimizations.

Introduction to the Snake Game

The Snake game is a simple yet addictive classic that dates back to the arcade era. The player controls a snake that moves around the screen, consuming food items to grow longer. The primary challenge lies in avoiding collisions with the snake's own body and the boundaries of the game window. The game intensifies as the snake grows, making manoeuvring increasingly tricky.

Setting Up the Project

Before diving into the code, let's set up our project. We can use any Integrated Development Environment (IDE) for Java, such as Eclipse or IntelliJ IDEA. Ensure that you have the Java Development Kit (JDK) installed on your system.

Create a New Project: Open your IDE and create a new Java project named "SnakeGame."

Create Classes: Create two classes, SnakeGame and Snake, to represent the game itself and the snake entity, respectively.

Implementing the Snake Class

The Snake class is responsible for managing the snake's state, movement, and growth. Here's a basic outline to get started:

public class Snake {
    private LinkedList<Point> body; // Snake body represented as a linked list of points
    private Direction direction; // Current direction of the snake
    // Constructor to initialize the snake
    public Snake() {
        // Initialize the snake with a default size and position
        body = new LinkedList<>();
        body.add(new Point(5, 5)); // Initial head position
        direction = Direction.RIGHT; // Initial direction
    }
    // Enum representing possible directions
    public enum Direction {
        UP, DOWN, LEFT, RIGHT
    }
    // Methods for handling movement, growth, and collision
    public void move() {
        // Logic to move the snake in the current direction
    }
    public void grow() {
        // Logic to make the snake grow by adding a new segment
    }
    public boolean checkCollision() {
        // Logic to check if the snake has collided with itself or the boundaries
        return false;
    }
}

It is a basic skeleton of the Snake class. Now, let's delve into the details of implementing movement, growth, and collision detection.

Handling Snake Movement

The move() method is central to controlling the snake's movement. It involves updating the positions of the snake's body segments based on the current direction. Additionally, we need to handle the case where the snake consumes food and grows.

public void move() {
    // Get the head of the snake
    Point head = body.getFirst();
    // Update the head based on the current direction
    switch (direction) {
        case UP:
            head = new Point(head.x, head.y - 1);
            break;
        case DOWN:
            head = new Point(head.x, head.y + 1);
            break;
        case LEFT:
            head = new Point(head.x - 1, head.y);
            break;
        case RIGHT:
            head = new Point(head.x + 1, head.y);
            break;
    }
    // Add the updated head to the front of the body
    body.addFirst(head);
    // Check for collision with food and handle growth
    if (head.equals(foodPosition)) {
        grow();
        generateFood();
    } else {
        // If no collision with food, remove the last segment of the tail
        body.removeLast();
    }
}

Handling Snake Growth

The grow() method is responsible for making the snake grow by adding a new segment to its body. This is typically done when the snake consumes food.

public void grow() {
    // Logic to add a new segment to the snake's body
}

The exact implementation will depend on how you represent the snake's body. Using a linked list, as shown in the example, makes it easy to add a new segment at the front.

Collision Detection

The checkCollision() method is crucial for determining whether the snake has collided with itself or the game boundaries.

public boolean checkCollision() {
    // Logic to check for collision with itself or boundaries
    return false;
}

This method should examine the positions of the snake's head and body segments to detect collisions. Additionally, it should check if the snake has moved outside the game window.

Implementing the SnakeGame Class

Now that we have a basic implementation of the Snake class, let's move on to the SnakeGame class, which will handle the game loop, user input, and rendering.

import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.*;
public class SnakeGame extends JFrame {
    private Snake snake;
    private Point foodPosition;
    public SnakeGame() {
        // Initialize the game window
        setTitle("Snake Game");
        setSize(400, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // Initialize the snake and generate initial food position
        snake = new Snake();
        generateFood();
        // Set up key listener for user input
        addKeyListener(new KeyListener() {
            @Override
            public void keyPressed(KeyEvent e) {
                // Handle arrow key input to change the snake's direction
            }
            @Override
            public void keyTyped(KeyEvent e) {
            }
            @Override
            public void keyReleased(KeyEvent e) {
            }
        });
        // Set the game window to be focusable and visible
        setFocusable(true);
        setVisible(true);
    }
    private void generateFood() {
        // Logic to generate a random position for the food
    }
    // Game loop
    public void runGame() {
        while (true) {
            // Update the snake's state
            snake.move();
            // Check for collisions
            if (snake.checkCollision()) {
                // Game over logic
                break;
            }
            // Repaint the game window
            repaint();
            // Introduce a delay to control the speed of the game
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    // Rendering method to draw the snake and food on the game window
    @Override
    public void paint(Graphics g) {
        super.paint(g);
        // Draw the snake
        for (Point segment : snake.getBody()) {
            g.setColor(Color.GREEN);
            g.fillRect(segment.x * 20, segment.y * 20, 20, 20);
        }
        // Draw the food
        g.setColor(Color.RED);
        g.fillRect(foodPosition.x * 20, foodPosition.y * 20, 20, 20);
    }
    public static void main(String[] args) {
        // Create an instance of the SnakeGame class and start the game loop
        SnakeGame snakeGame = new SnakeGame();
        snakeGame.runGame();
    }
}

This code sets up the game window, initializes the snake, and handles the game loop. The runGame() method is responsible for continuously updating the game state, checking for collisions, repainting the window, and introducing a delay to control the game's speed.

User Input and Direction Changes

To make the game interactive, we need to handle user input for changing the snake's direction. Modify the keyPressed method in the KeyListener to capture arrow key presses:

@Override
public void keyPressed(KeyEvent e) {
    switch (e.getKeyCode()) {
        case KeyEvent.VK_UP:
            snake.setDirection(Snake.Direction.UP);
            break;
        case KeyEvent.VK_DOWN:
            snake.setDirection(Snake.Direction.DOWN);
            break;
        case KeyEvent.VK_LEFT:
            snake.setDirection(Snake.Direction.LEFT);
            break;
        case KeyEvent.VK_RIGHT:
            snake.setDirection(Snake.Direction.RIGHT);
            break;
    }
}

Ensure that the Snake class has a setDirection method to update the snake's direction based on user input.

public void setDirection(Direction newDirection) {
    // Logic to set the snake's direction, considering constraints to avoid 180-degree turns
}

Generating Food

The generateFood() method is responsible for placing food in a random position on the game grid. Ensure that it doesn't overlap with the snake's body.

private void generateFood() {
    // Logic to generate a random position for the food
}

Game Over Logic

When a collision is detected, it's time to end the game. You might want to display a game-over message and provide an option to restart the game.

if (snake.checkCollision()) {
    JOptionPane.showMessageDialog(this, "Game Over!", "Game Over", JOptionPane.PLAIN_MESSAGE);
    System.exit(0);
}

Implementation of The Code

SnakeGame.java

import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.LinkedList;
import javax.swing.*;
public class SnakeGame extends JFrame {
    private Snake snake;
    private Point foodPosition;
    public SnakeGame() {
        // Initialize the game window
        setTitle("Snake Game");
        setSize(400, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // Initialize the snake and generate initial food position
        snake = new Snake();
        generateFood();
        // Set up key listener for user input
        addKeyListener(new KeyListener() {
            @Override
            public void keyPressed(KeyEvent e) {
                // Handle arrow key input to change the snake's direction
                switch (e.getKeyCode()) {
                    case KeyEvent.VK_UP:
                        snake.setDirection(Snake.Direction.UP);
                        break;
                    case KeyEvent.VK_DOWN:
                        snake.setDirection(Snake.Direction.DOWN);
                        break;
                    case KeyEvent.VK_LEFT:
                        snake.setDirection(Snake.Direction.LEFT);
                        break;
                    case KeyEvent.VK_RIGHT:
                        snake.setDirection(Snake.Direction.RIGHT);
                        break;
                }
            }
            @Override
            public void keyTyped(KeyEvent e) {
            }
            @Override
            public void keyReleased(KeyEvent e) {
            }
        });
        // Set the game window to be focusable and visible
        setFocusable(true);
        setVisible(true);

        // Start the game loop
        runGame();
    }
    private void generateFood() {
        // Logic to generate a random position for the food
        int x = (int) (Math.random() * 10); // Random x-coordinate (assuming a 10x10 grid)
        int y = (int) (Math.random() * 10); // Random y-coordinate
        foodPosition = new Point(x, y);
    }
    // Game loop
    private void runGame() {
        while (true) {
            // Update the snake's state
            snake.move();

            // Check for collisions
            if (snake.checkCollision()) {
                // Game over logic
                JOptionPane.showMessageDialog(this, "Game Over!", "Game Over", JOptionPane.PLAIN_MESSAGE);
                System.exit(0);
            }
            // Repaint the game window
            repaint();
            // Introduce a delay to control the speed of the game
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    // Rendering method to draw the snake and food on the game window
    @Override
    public void paint(Graphics g) {
        super.paint(g);
        // Draw the snake
        for (Point segment : snake.getBody()) {
            g.setColor(Color.GREEN);
            g.fillRect(segment.x * 20, segment.y * 20, 20, 20);
        }
        // Draw the food
        g.setColor(Color.RED);
        g.fillRect(foodPosition.x * 20, foodPosition.y * 20, 20, 20);
    }
    public static void main(String[] args) {
        // Create an instance of the SnakeGame class
        SwingUtilities.invokeLater(() -> new SnakeGame());
    }
}
class Snake {
    private LinkedList<Point> body;
    private Direction direction;
    public Snake() {
        body = new LinkedList<>();
        body.add(new Point(5, 5));
        direction = Direction.RIGHT;
    }
    public enum Direction {
        UP, DOWN, LEFT, RIGHT
    }
    public void move() {
        Point head = body.getFirst();
        switch (direction) {
            case UP:
                head = new Point(head.x, head.y - 1);
                break;
            case DOWN:
                head = new Point(head.x, head.y + 1);
                break;
            case LEFT:
                head = new Point(head.x - 1, head.y);
                break;
            case RIGHT:
                head = new Point(head.x + 1, head.y);
                break;
        }
        body.addFirst(head);
        if (head.equals(foodPosition)) {
            grow();
            generateFood();
        } else {
            body.removeLast();
        }
    }
    public void grow() {
        // Logic to add a new segment to the snake's body
        body.add(new Point(-1, -1)); // Placeholder for the new segment
    }
    public boolean checkCollision() {
        Point head = body.getFirst();
        for (int i = 1; i < body.size(); i++) {
            if (head.equals(body.get(i))) {
                return true;
            }
        }
        if (head.x < 0 || head.x >= 10 || head.y < 0 || head.y >= 10) {
            return true;
        }
        return false;
    }
    public LinkedList<Point> getBody() {
        return body;
    }
    public void setDirection(Direction newDirection) {
        if ((direction == Direction.UP && newDirection != Direction.DOWN) ||
            (direction == Direction.DOWN && newDirection != Direction.UP) ||
            (direction == Direction.LEFT && newDirection != Direction.RIGHT) ||
            (direction == Direction.RIGHT && newDirection != Direction.LEFT)) {
            direction = newDirection;
        }
    }
}

Output:

Now, we can create a new Java project, copy and paste the above code into appropriate files (Snake.java and SnakeGame.java), and run the SnakeGame class. The game window will appear, and we can use arrow keys to control the snake. The code provided is a basic implementation. We may want to enhance it further by adding features such as scoring, levels, and better graphics. Additionally, make sure to adjust the grid size and window dimensions based on your preferences.

Building the Snake game in Java is an excellent exercise for honing your skills in object-oriented programming, game development, and user input handling. The code provided serves as a foundation, and you can enhance and customize it based on your preferences. Experiment with features such as score tracking, levels, or additional obstacles to make the game even more engaging. As you delve deeper into game development, you'll find endless possibilities for expanding and refining your projects.

Next TopicTower of Hanoi Program in Java

← prev next →