Snake Growth

We'll continue from where we left off in the previous lesson. Our project already has a grid of interactive cells, and a snake that can be controlled with the arrow keys. The starting code for the most relevant files is provided below.

When our snake consumes an apple, we need to trigger a series of game events:

• Growing the snake
• Spawning a new apple somewhere in the grid
• Updating the score (in a future lesson)

We'll use SDL's event system to coordinate these actions. First, let's define a new user event type in our Globals.h file. We covered this topic in our lesson on Creating Custom Events .

1#pragma once
2#define CHECK_ERRORS
3#include <iostream>
4#include <SDL3/SDL.h>
5#include <string>
6
7namespace UserEvents{
8  inline const Uint32 ADVANCE{SDL_RegisterEvents(1)};
9  inline const Uint32 APPLE_EATEN{
10    SDL_RegisterEvents(1)};
11}
12// ...

Now we'll modify our Cell class to dispatch this event when the snake moves into a cell containing an apple. The Advance() function already detects snake movement, so we'll add a few additional lines of code to handle apple consumption:

1// ...
2
3void Cell::Advance(const SDL_UserEvent& E) {
4  SnakeData* Data{static_cast<SnakeData*>(E.data1)};
5
6  bool isThisCell{
7    Data->HeadRow == Row &&
8    Data->HeadCol == Column
9  };
10
11  if (isThisCell) {
12    if (State == CellState::Apple) {
13      SDL_Event Event{ .type = UserEvents::APPLE_EATEN };
14      SDL_PushEvent(&Event);
15    }
16    State = CellState::Snake;
17    SnakeDuration = Data->Length;
18  } else if (State == CellState::Snake) {
19    --SnakeDuration;
20    if (SnakeDuration == 0) {
21      State = CellState::Empty;
22    }
23  }
24}

This approach keeps our code modular - the cell only needs to announce that an apple was eaten, and other components can react accordingly.

Next, we need to update our classes to react to these events. Every time an apple is eaten, our snake needs to get longer. Our snake's length is stored in the Snake variable of our GameState object. Let's update HandleEvent() in GameState.h to increment the snake's length every time an apple is eaten:

1#pragma once
2#include <SDL3/SDL.h>
3#include "Globals.h"
4#include "Snake/SnakeData.h"
5
6class GameState {
7public:
8  void HandleEvent(const SDL_Event& E) {
9    if (E.type == SDL_EVENT_KEY_DOWN) {
10      HandleKeyEvent(E.key);
11    } else if (E.type == UserEvents::APPLE_EATEN) {
12      ++Snake.Length;
13    }
14  }
15  // ...
16};

Additionally, individual snake segments are managed by any Cell object that has a State of CellState::Snake. When an apple is eaten, we need to increment the SnakeDuration of these cells, meaning the cell will remain a snake segment for one additional turn.

Let's update our HandleEvent() function in Cell.cpp to take care of this:

1#include "Snake/Cell.h"
2
3// ...
4
5void Cell::HandleEvent(const SDL_Event& E) {
6  if (E.type == UserEvents::ADVANCE) {
7    Advance(E.user);
8  } else if (E.type == UserEvents::APPLE_EATEN) {
9    if (State == CellState::Snake) {
10      ++SnakeDuration;
11    }
12  }
13}
14
15// ...

Every time an apple is eaten, we need to place a new apple in a random, empty grid cell. Collectively, our Cell objects are managed by the Grid object, so the Grid class is the natural place to manage this.

First, however, let's add a PlaceApple() public method to our Cell class. If the Cell has a State of CellState::Empty, this method will update it to an Apple cell and return true, indicating the apple was successfully placed.

If the Cell is not empty, the PlaceApple() method will do nothing except return false, indicating the action failed.

src/Snake/Cell.h

1#pragma once
2#include <SDL3/SDL.h>
3#include "Globals.h"
4#include "Assets.h"
5#include "Snake/SnakeData.h"
6
7class Cell {
8public:
9  // ...
10  bool PlaceApple();
11
12private:
13  // ...
14};

src/Snake/Cell.cpp

1// ...
2
3bool Cell::PlaceApple() {
4  if (State != CellState::Empty) return false;
5
6  State = CellState::Apple;
7  return true;
8}

Over in Grid.h, we'll now implement the logic to place an apple in a random cell within the std::vector array called Cells. To access a random cell in this array, we'll generate a random index.

Remember, array indices start at 0 so, if our array contained 10 cells, their indices would range from 0 to 9. More generally, we want a random index from 0 to Cells.size() - 1.

The Random::Int() function we added to Engine/Random.h can help us choose an integer between two values. Arrays use the size_t type for their sizes and indices, which we can freely convert to and from a basic int:

src/Snake/Grid.h

1#pragma once
2#include <SDL3/SDL.h>
3#include <vector>
4#include "Snake/Cell.h"
5#include "Globals.h"
6#include "Engine/Random.h"
7
8class Grid {
9  // ...
10private:
11  void PlaceRandomApple() {
12    int RandomIndex{
13      Engine::Random::Int(0, int(Cells.size()) - 1)
14    };
15    // ...
16  }
17  
18  std::vector<Cell> Cells;
19};

We need to continuously call the PlaceApple() method on random cells until we find one that is empty - that is, until PlaceApple() returns true. We can implement this as a loop that will break once Cells[RandomIndex].PlaceApple() succeeds:

src/Snake/Grid.h

1#pragma once
2#include <SDL3/SDL.h>
3#include <vector>
4#include "Snake/Cell.h"
5#include "Globals.h"
6#include "Engine/Random.h"
7
8class Grid {
9 // ...
10private:
11  void PlaceRandomApple() {
12    while (true) {
13      int RandomIndex{
14        Engine::Random::Int(0, int(Cells.size()) - 1)
15      };
16      if (Cells[RandomIndex].PlaceApple()) {
17        break;
18      }
19    }
20  }
21  
22  std::vector<Cell> Cells;
23};

Finally, we need to call this PlaceRandomApple() function at the appropriate time. Our Grid class already has a HandleEvent() method, so we can invoke PlaceRandomApple() every time a UserEvents::APPLE_EATEN event is detected:

src/Snake/Grid.h

1#pragma once
2#include <vector>
3#include "Snake/Cell.h"
4#include "Globals.h"
5#include "Engine/Random.h"
6
7class Grid {
8public:
9  // ...
10  void HandleEvent(const SDL_Event& E) {
11    for (auto& Cell : Cells) {
12      Cell.HandleEvent(E);
13    }
14    if (E.type == UserEvents::APPLE_EATEN) {
15      PlaceRandomApple();
16    }
17  }
18  // ...
19};

With these changes, our snake can now move around the world and eat apples. Every time an apple is eaten, a new one spawns elsewhere in the grid, and our snake gets one segment larger.

Complete Code

Complete versions of the files we changed in this part are available below

Files

src

Select a file to view its content

Files not listed above have not been changed since the previous section.

Summary

In this lesson, we implemented more of the core gameplay mechanics for our Snake game. We added the following:

• A custom event type for apple consumption
• Reactions to this event type to handle snake growth
• A system for randomly placing new apples