C++ - Snake Game

Snake Game Project in C++

Introduction

This document explains the C++ Snake Game project code, detailing the key components, functions, and logic used to implement the game.

Code Overview

The C++ Snake Game is built using several core components, including classes for the snake, food, and the game state. The game runs in a console window and uses basic input/output and simple game logic to create an interactive experience.

Project Structure

• main.cpp: Contains the main function and game loop.
• Snake.h / Snake.cpp: Defines the Snake class, which handles the snake's movement, growth, and collision detection.
• Food.h / Food.cpp: Defines the Food class, which manages the food's spawning and position.
• Game.h / Game.cpp: Manages the overall game flow, including rendering, collision detection, and score tracking.

Key Classes and Functions

Snake Class

The Snake class represents the snake in the game. It stores the snake's body segments and handles its movement.

class Snake {
public:
    Snake();  // Constructor to initialize snake position and size
    void move();  // Moves the snake based on input
    void grow();  // Grows the snake after eating food
    void draw();  // Renders the snake on the screen
    bool checkCollision();  // Checks if the snake collides with itself or the walls
};
    

Food Class

The Food class handles the creation and rendering of food on the screen. It spawns food at random positions and checks if the snake eats it.

class Food {
public:
    Food();  // Constructor to initialize food position
    void spawn();  // Spawns food at a random location
    void draw();  // Renders the food on the screen
    bool isEaten(int snakeX, int snakeY);  // Checks if the snake eats the food
};
    

Game Class

The Game class handles the game loop, game state transitions, input handling, and rendering of the entire game.

class Game {
private:
    Snake snake;
    Food food;
    int score;
public:
    Game();  // Constructor to initialize game state
    void run();  // Main game loop
    void handleInput();  // Handles user input (arrow keys)
    void render();  // Renders the game screen
    void update();  // Updates the game state (snake movement, food, etc.)
    void checkCollisions();  // Checks for collisions with walls or the snake itself
    void gameOver();  // Displays the game over screen
};
    

Game Loop

The game runs inside a loop where the game state is continuously updated and rendered. Here's a simplified version of the game loop:

int main() {
    Game game;
    while (true) {
        game.handleInput();  // Get user input
        game.update();  // Update game state
        game.render();  // Render the game state to the screen
        if (game.checkCollisions()) {
            game.gameOver();  // End the game if a collision occurs
            break;
        }
    }
    return 0;
}
    

Input Handling

The program uses the _kbhit() and _getch() functions (from conio.h) to handle input. The arrow keys control the direction of the snake:

void Game::handleInput() {
    if (_kbhit()) {
        switch (_getch()) {
            case 'w': // Move up
                snake.changeDirection(UP);
                break;
            case 's': // Move down
                snake.changeDirection(DOWN);
                break;
            case 'a': // Move left
                snake.changeDirection(LEFT);
                break;
            case 'd': // Move right
                snake.changeDirection(RIGHT);
                break;
        }
    }
}
    

Rendering the Game

Rendering is done by clearing the console screen and redrawing the entire game. The snake is represented by the character 'O', the food by '*', and walls by '#'. The screen is refreshed every frame to simulate movement:

void Game::render() {
    system("cls");  // Clear the console screen (Windows-specific)
    snake.draw();  // Draw the snake
    food.draw();   // Draw the food
    // Draw walls and score
    std::cout << "Score: " << score << std::endl;
}
    

Collision Detection

Collision detection checks if the snake has hit the walls or itself. If a collision occurs, the game ends:

void Game::checkCollisions() {
    if (snake.checkCollision()) {
        return true;
    }
    if (food.isEaten(snake.getHeadX(), snake.getHeadY())) {
        snake.grow();  // Grow the snake when food is eaten
        food.spawn();  // Spawn a new food
        score++;  // Increment the score
    }
    return false;
}
    

Game Over

The game ends when the snake collides with the wall or itself. A game over screen is displayed, and the player can choose to restart or exit:

void Game::gameOver() {
    std::cout << "Game Over!" << std::endl;
    std::cout << "Final Score: " << score << std::endl;
    // Prompt user to restart or quit
}
    

This C++ Snake Game project code demonstrates the basics of game development, including input handling, game loop implementation, rendering, and collision detection. By breaking the game into multiple classes and using simple logic, the game creates a fun and interactive experience.