GamePanel.java

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Random;

import javax.swing.JPanel;

/**
 * The GamePanel class is a JPanel that implements the core functionality of the Snake game.
 * It handles the game logic, drawing, and user input.
 *
 * <p>This class includes methods to start the game, draw the game components,
 * generate new apples, move the snake, check for collisions, and display the game over screen.</p>
 *
 * <p>The game board is represented as a grid, with the snake moving to eat apples and grow in size.
 * The game ends if the snake collides with itself or the walls.</p>
 *
 * @author Pranav Kale
 */
public class GamePanel extends JPanel implements ActionListener {

    static final int SCREEN_WIDTH = 600;
    static final int SCREEN_HEIGHT = 600;
    static final int UNIT_SIZE = 25;
    static final int GAME_UNITS = (SCREEN_WIDTH * SCREEN_HEIGHT)/UNIT_SIZE;
    static final int DELAY = 75;
    final int x[] = new int[GAME_UNITS];
    final int y[] = new int[GAME_UNITS];
    int bodyParts = 6;
    int applesEaten;
    int appleX;
    int appleY;
    char direction = 'R';
    boolean running = false;
    Timer timer;
    Random random;

    /**
     * Constructs the GamePanel, sets its properties, and starts the game.
     */
    GamePanel() {
        random = new Random();
        this.setPreferredSize(new Dimension(SCREEN_WIDTH,SCREEN_HEIGHT));
        this.setBackground(new Color(88, 184, 84));
        this.setFocusable(true);
        this.addKeyListener(new MyKeyAdapter());
        startGame();

    }

    /**
     * Starts the game by generating a new apple, setting the game running state to true,
     * and starting the game timer.
     */
    public void startGame() {
        newApple();
        running = true;
        timer = new Timer(DELAY, (ActionListener) this);
        timer.start();
    }

    /**
     * Overrides the paintComponent method to draw the game elements on the panel.
     *
     * @param g the Graphics object to protect
     */
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        draw(g);
    }

    /**
     * Draws the game grid, snake, apple, and score on the panel.
     *
     * @param g the Graphics object to draw with
     */
    public void draw(Graphics g) {
        if(running) {
            for (int i = 0; i < SCREEN_HEIGHT / UNIT_SIZE; i++) {
                g.setColor(new Color(50, 102, 48));
                g.drawLine(i * UNIT_SIZE, 0, i * UNIT_SIZE, SCREEN_HEIGHT);
                g.drawLine(0, i * UNIT_SIZE, SCREEN_WIDTH, i * UNIT_SIZE);
            }
            g.setColor(Color.red);
            g.fillOval(appleX, appleY, UNIT_SIZE, UNIT_SIZE);

            for (int i = 0; i < bodyParts; i++) {
                if (i == 0) {
                    g.setColor(new Color(26, 94, 31));
                    g.fillRect(x[i], y[i], UNIT_SIZE, UNIT_SIZE);
                } else {
                    g.setColor(new Color(34, 122, 41));
                    g.fillRect(x[i], y[i], UNIT_SIZE, UNIT_SIZE);
                }
            }
            //Score points
            g.setColor(Color.red);
            g.setFont(new Font("Ink Free",Font.BOLD,40));
            FontMetrics metrics = getFontMetrics(g.getFont());
            g.drawString("Score: " + applesEaten,(SCREEN_WIDTH - metrics.stringWidth("Score: " + applesEaten))/2,g.getFont().getSize());
        } else {
            gameOver(g);
        }
        //END
        }

    /**
     * Generates a new apple at a random location on the game grid.
     */
    public void newApple() {
        appleX = random.nextInt((int)(SCREEN_WIDTH/UNIT_SIZE))*UNIT_SIZE;
        appleY = random.nextInt((int)(SCREEN_HEIGHT/UNIT_SIZE))*UNIT_SIZE;
    }

    /**
     * Moves the snake in the current direction and updates its position.
     */
    public void move() {
        for(int i = bodyParts;i>0;i--) {
            x[i] = x[i-1];
            y[i] = y[i-1];
        }

        switch (direction) {
            case 'U' -> y[0] = y[0] - UNIT_SIZE;
            case 'D' -> y[0] = y[0] + UNIT_SIZE;
            case 'L' -> x[0] = x[0] - UNIT_SIZE;
            case 'R' -> x[0] = x[0] + UNIT_SIZE;
        }
    }

    /**
     * Checks if the snake's head has collided with an apple.
     * If so, increases the snake's body size and the score, and generates a new apple.
     */
    public void checkApple() {
        if((x[0] == appleX) && (y[0] == appleY)) {
            bodyParts++;
            applesEaten++;
            newApple();
        }
    }

    /**
     * Checks if the snake has collided with itself or the borders of the game area.
     * If a collision is detected, the game is stopped.
     */
    public void checkCollisions() {
        // Checks if head collides with body
        for(int i=bodyParts;i>0;i--) {
            if((x[0] == x[i]) && (y[0] == y[i])) {
                running = false;
            }
        }
        // Checks if head collides with left border
        if(x[0] < 0) {
            running = false;
        }
        // Checks if head collides with right border
        if(x[0] > SCREEN_WIDTH) {
            running = false;
        }
        // Checks if head collides with upper border
        if(y[0] < 0) {
            running = false;
        }
        // Checks if head collides with lower border
        if(y[0] > SCREEN_HEIGHT) {
            running = false;
        }
        if(!running) {
            timer.stop();
        }
    }

    /**
     * Displays the "Game Over" screen with the final score.
     *
     * @param g the Graphics object to draw with
     */
    public void gameOver(Graphics g) {
        //Game Over Text
        g.setColor(Color.red);
        g.setFont(new Font("Ink Free",Font.BOLD,75));
        FontMetrics metrics1 = getFontMetrics(g.getFont());
        g.drawString("Game Over!",(SCREEN_WIDTH - metrics1.stringWidth("Game Over"))/2,SCREEN_HEIGHT/2);
        // Game Over Score
        g.setColor(Color.red);
        g.setFont(new Font("Ink Free",Font.BOLD,40));
        FontMetrics metrics2 = getFontMetrics(g.getFont());
        g.drawString("Score: " + applesEaten,(SCREEN_WIDTH - metrics2.stringWidth("Score: " + applesEaten))/2,g.getFont().getSize());
    }
    /**
     * Handles the game action events, updating the game state and repainting the game panel.
     *
     * @param e the action event
     */
    public void actionPerformed(ActionEvent e) {
        if(running) {
            move();
            checkApple();
            checkCollisions();
        }
        repaint();

    }

    /**
     * The MyKeyAdapter class handles keyboard input to control the direction of the snake.
     */
    public class MyKeyAdapter extends KeyAdapter {
        /**
         * Responds to key presses to change the direction of the snake.
         *
         * @param e the key event
         */
        @Override
        public void keyPressed(KeyEvent e) {
            switch (e.getKeyCode()) {
                case KeyEvent.VK_LEFT -> {
                    if (direction != 'R') {
                        direction = 'L';
                    }
                }
                case KeyEvent.VK_RIGHT -> {
                    if (direction != 'L') {
                        direction = 'R';
                    }
                }
                case KeyEvent.VK_UP -> {
                    if (direction != 'D') {
                        direction = 'U';
                    }
                }
                case KeyEvent.VK_DOWN -> {
                    if (direction != 'U') {
                        direction = 'D';
                    }
                }
            }
        }
    }

}