### Triggering Game Over Event in Snake Game Now that we have the collision detection in place, let's implement the game over event that will trigger when the snake either hits the boundary or collides with itself. This is a crucial part of the game as it determines when the game should end. #### Understanding the Game Over Conditions The game should end under two conditions: 1. When the snake's head hits the boundary of the game board 2. When the snake's head collides with any part of its own body We'll create a function that checks these conditions and triggers the game over event when necessary. #### Implementing Game Over Event Let's create a function called `checkGameOver()` that will handle both boundary and self-collision checks. This function will return a boolean indicating whether the game should end. ```cpp #include using namespace std; // Assuming these are already defined from previous tasks extern const int BOARD_WIDTH = 20; extern const int BOARD_HEIGHT = 20; extern char gameBoard[BOARD_HEIGHT][BOARD_WIDTH]; extern queue> snakeBody; extern bool gameOver; void checkGameOver(pair headPosition) { // Boundary collision check if (headPosition.first < 0 || headPosition.first >= BOARD_HEIGHT || headPosition.second < 0 || headPosition.second >= BOARD_WIDTH) { gameOver = true; return; } // Self collision check for (auto it = snakeBody.begin(); it != snakeBody.end(); ++it) { if (it->first == headPosition.first && it->second == headPosition.second) { gameOver = true; return; } } gameOver = false; } ``` #### Displaying Game Over Message When the game ends, we want to display a game over message on the console. We'll create a function called `displayGameOver()` that will show the final score and a message. ```cpp void displayGameOver(int finalScore) { system("clear"); // Clear the console // Center the game over message int messageWidth = 20; int spaces = (BOARD_WIDTH - messageWidth) / 2; for (int i = 0; i < BOARD_HEIGHT; i++) { for (int j = 0; j < BOARD_WIDTH; j++) { if (i == BOARD_HEIGHT / 2 && j >= spaces && j < spaces + messageWidth) { if (j == spaces) { cout << "GAME OVER!"; } else if (j == spaces + 1) { cout << " Score: " << finalScore; } } else { gameBoard[i][j] = ' '; } } } // Display the final board state for (int i = 0; i < BOARD_HEIGHT; i++) { for (int j = 0; j < BOARD_WIDTH; j++) { cout << gameBoard[i][j]; } cout << endl; } } ``` #### Integrating with Game Loop Now, let's integrate these functions with our main game loop. The game loop should check for the game over condition after each move. ```cpp int main() { // Initialize game variables pair headPosition = make_pair(BOARD_HEIGHT / 2, BOARD_WIDTH / 2); int score = 0; while (true) { // Clear console system("clear"); // Draw game board drawBoard(); // Handle user input handleInput(headPosition); // Update snake position updateSnakePosition(headPosition, score); // Check for collisions checkGameOver(headPosition); if (gameOver) { displayGameOver(score); break; } // Update score if food is eaten if (foodEaten) { score++; foodEaten = false; } } return 0; } ``` #### Explanation 1. **Boundary Collision Check**: The function `checkGameOver()` first checks if the snake's head is outside the boundaries of the game board. If it is, `gameOver` is set to true. 2. **Self Collision Check**: The function then iterates through each segment of the snake's body (stored in the queue) to check if the head's position matches any body segment's position. If a match is found, `gameOver` is set to true. 3. **Displaying Game Over**: When `gameOver` is true, the `displayGameOver()` function is called. This function clears the console, displays the game over message, and shows the final score. 4. **Game Loop Integration**: The main game loop continuously checks for the game over condition after each move. If `gameOver` is true, the loop breaks, and the game ends. #### Next Steps Now that we've implemented the game over event, the next step is to implement the scoring system and high score functionality. This will involve: 1. Storing the score in a file 2. Reading the high score from the file 3. Updating the high score when the current score exceeds it 4. Displaying the high score on the game screen #### Further Reading - [Console Input/Output in C++](https://www.cplusplus.com/doc/tutorial/basic_io/) - [Queue Data Structure in C++](https://www.cplusplus.com/reference/stl/queue/) - [Boolean Flags in Game Development](https://gameprogrammingpatterns.com/game-loop.html) This implementation provides a solid foundation for handling game over conditions in your Snake game. The clear separation of concerns between collision detection and game over display makes the code maintainable and easy to extend.