Snake

Repository

I built this recreation of the classic Snake game to immerse myself in the Rust ecosystem and its unique approach to memory safety and performance. By moving beyond a simple console application to a graphical interface, I explored the minifb library for window management and pixel-buffer rendering. This project served as a foundation for understanding game loops, entity management, and the power of Rust's VecDeque for modeling dynamic structures.

Architectural Backbone: The Game Struct

The entire application state is encapsulated within a central Game struct. This structure manages the pixel buffer, window instance, and the snake's state. I implemented a new() function to handle the initial setup, including creating a window with specific dimensions (600x400) and initializing the rendering buffer with a default black color. This modular design allows for clear separation between the game's data and its execution logic.

1struct Game {
2    window: Window,
3    width: usize,
4    height: usize,
5    buffer: Vec<u32>,
6    cell_size: usize,
7    snake: Snake,
8    has_started: bool,
9    cookie_pos: [usize; 2],
10}
11
12impl Game {
13    fn new() -> Self {
14        let width = 600;
15        let height = 400;
16        let window = Window::new("Snake", width, height, WindowOptions::default())
17            .expect("Failed to create window");
18        let buffer = vec![0x000000; width * height]; // Initializing with black
19        Game {
20            window,
21            width,
22            height,
23            buffer,
24            cell_size: 20,
25            snake: Snake::new(),
26            has_started: false,
27            cookie_pos: [8, 9],
28        }
29    }
30}

Responsive Game Loop

The run() function implements a synchronized game loop that manages the transition between game states. It handles high-frequency input detection and updates the world state based on a defined tick rate (150ms). The loop is designed to be highly responsive, allowing users to start the game with the Spacebar, navigate with directional keys, and exit instantly with the Escape key. When a collision is detected, the game state is reset, demonstrating robust error and state recovery.

1fn run(&mut self) {
2    while self.window.is_open() {
3        // Start game on Spacebar press
4        if self.window.is_key_down(Key::Space) && !self.has_started {
5            self.reset_buffer();
6            self.has_started = true;
7            self.update();
8        }
9
10        if self.has_started {
11            self.capture_input(150);
12            self.calculate_next_position();
13            self.cookie_check();
14            let head = *self.snake.body.front().unwrap();
15            self.set_cell_color(head[0], head[1], self.snake.color);
16        } else {
17            self.snake = Snake::new(); // Ready for a new run
18        }
19
20        self.update(); // Push pixel buffer to window
21        if self.window.is_key_down(Key::Escape) { break; }
22    }
23}

Modeling the Snake with VecDeque

To handle the snake's movement and growth efficiently, I used a VecDeque to represent its body segments. This allows for O(1) operations when adding a new head and removing the tail during movement. When the snake consumes a "cookie," the tail removal is skipped, causing the snake to grow. This use of specialized data structures ensures that the game remains performant even as the snake spans across the entire grid.

1struct Snake {
2    color: u32,
3    body: VecDeque<[usize; 2]>, // Efficient head/tail manipulation
4    direction: u8,
5    length: usize,
6}
7
8impl Snake {
9    fn new() -> Self {
10        let mut snake_body = VecDeque::new();
11        snake_body.push_front([10, 12]); // Initial starting position
12        Snake {
13            color: 0xFF73F1, // Signature pink color
14            body: snake_body,
15            direction: 0,
16            length: 5,
17        }
18    }
19}

Visual Rendering and Memory Safety

The project utilizes direct pixel manipulation to render the game world. By calculating the exact indices in the buffer vector based on the snake's grid coordinates and the cell_size, I created a custom rendering engine. Rust's strict ownership rules ensured that I didn't encounter memory leaks or buffer overflows during these low-level operations, making the final game both stable and efficient.

Try It Out

Download

If you want to try this app out for yourself, click on the download button and install rust-snake.rar from GitHub, extract the .rar file and run the rust-snake executable.

Video Demonstration

External Media Required

This video requires third-party cookies from YouTube to be displayed. Accepting will enable all external media across the site.