### Snake Game Documentation
#### Overview
This document provides a detailed explanation of the methods, data
structures, and algorithms used to create the Snake game using Java.
#### Classes and Methods
##### 1. `SnakeGame` Class
This class sets up the main game window.
**Methods:**
- **`SnakeGame()` Constructor**:
- Initializes the game window.
- Adds the `GameBoard` to the frame.
- Sets window properties like title, size, and close operation.
- **`main(String[] args)`**:
- Entry point of the application.
- Creates an instance of `SnakeGame` and makes it visible.
##### 2. `GameBoard` Class
This class handles the game board, including the drawing of the snake,
the apple, and the game logic.
**Fields:**
- `B_WIDTH`, `B_HEIGHT`: Dimensions of the game board.
- `DOT_SIZE`: Size of each segment of the snake.
- `ALL_DOTS`: Maximum number of possible dots on the board.
- `RAND_POS`: Factor used for positioning the apple.
- `DELAY`: Delay time for the game loop timer.
- `x[]`, `y[]`: Arrays to store the x and y coordinates of the snake's body
segments.
- `dots`: Current size of the snake.
- `apple_x`, `apple_y`: Coordinates of the apple.
- `leftDirection`, `rightDirection`, `upDirection`, `downDirection`: Boolean
variables to track the direction of the snake.
- `inGame`: Boolean to track the game state.
- `timer`: Timer to control the game loop.
- `ball`, `apple`, `head`: Images used for the snake and apple.
**Methods:**
- **`GameBoard()` Constructor**:
- Initializes the game board.
- Sets key listener, background color, and preferred size.
- Calls `loadImages()` and `initGame()` methods.
- **`initBoard()`**:
- Initializes the game board settings.
- **`loadImages()`**:
- Loads the images for the snake and the apple from the resources
directory.
- **`initGame()`**:
- Initializes the snake's starting position and size.
- Places the first apple on the board.
- Starts the timer.
- **`paintComponent(Graphics g)`**:
- Overrides the `paintComponent` method to draw the game elements.
- Calls `doDrawing(g)` method to handle the drawing logic.
- **`doDrawing(Graphics g)`**:
- Draws the apple and the snake on the game board.
- Calls `gameOver(g)` if the game is over.
- **`gameOver(Graphics g)`**:
- Displays the "Game Over" message.
- **`checkApple()`**:
- Checks if the snake has eaten the apple.
- Increases the snake size and relocates the apple if eaten.
- **`move()`**:
- Moves the snake in the current direction.
- **`checkCollision()`**:
- Checks for collisions with the snake itself or the borders of the game
board.
- Ends the game if a collision is detected.
- **`locateApple()`**:
- Randomly places the apple on the board.
- **`actionPerformed(ActionEvent e)`**:
- Invoked by the timer to update the game state.
- Calls `checkApple()`, `checkCollision()`, and `move()` methods.
- **`TAdapter` Class**:
- Inner class to handle key events.
- Changes the snake's direction based on arrow key presses.
#### Data Structures and Algorithms
##### Arrays
- Arrays `x[]` and `y[]` store the coordinates of the snake's body
segments.
- Arrays provide efficient access and update operations for the snake's
movement.
##### Random
- The `Random` class is used to generate random positions for the apple.
- Ensures the apple appears at random locations on the board.
##### Timers
- The `Timer` class is used to create a game loop that periodically updates
the game state.
- Controls the speed of the game by setting a delay between updates.
##### Event Listeners
- `KeyAdapter` is used to listen for key presses and change the snake's
direction.
- Ensures responsive and interactive gameplay.
##### Game Logic
- The game logic includes methods to check for collisions, move the
snake, and handle the game over state.
- Ensures the game runs smoothly and according to the rules.
#### Conclusion
This documentation covers the main classes, methods, data structures,
and algorithms used in the Snake game. Understanding these components
will help you modify and expand the game as needed.
