Snake Growth

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 configuration:

1// GameConfig.h
2// ...
3
4namespace UserEvents{
5  // ...
6  inline Uint32 APPLE_EATEN =
7    SDL_RegisterEvents(1);
8}
9// ...

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 four additional lines of code to handle apple consumption:

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

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 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 first update HandleEvent() in GameState.h, and have it increment the snake's length every time an apple is eaten:

1// GameState.h
2// ...
3
4class GameState {
5public:
6  // ...
7  void HandleEvent(SDL_Event& E) {
8    using namespace UserEvents;
9    if (E.type == SDL_KEYDOWN) {
10      HandleKeyEvent(E.key);
11    } else if (E.type == APPLE_EATEN) {
12      ++Snake.Length;
13    }
14  }
15  // ...
16};

Additionally, individual snake segments are being managed by any Cell object that has a CellState of 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 to take care of this:

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

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 object. If the Cell is 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() cell will do nothing except return false, indicating the action failed.

1// Cell.h
2// ...
3
4class Cell {
5public:
6  // ...
7  bool PlaceApple() {
8    if (CellState != Empty) return false;
9
10    CellState = Apple;
11    return true;
12  }
13  // ...
14};

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, index arrays start at 0 so, if our array contained 10 cells, their indices range from 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. Array indices use the size_t type, which is an alias for an integer:

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

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:

1// Grid.h
2// ...
3
4class Grid {
5 // ...
6private:
7  void PlaceRandomApple() {
8    while (true) {
9      size_t RandomIndex{
10        Random::Int(0, Cells.size() - 1)};
11      if (Cells[RandomIndex].PlaceApple()) {
12        break;
13      }
14    }
15  }
16  // ...
17};

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:

1// Grid.h
2// ...
3
4class Grid {
5public:
6  // ...
7  void HandleEvent(SDL_Event& E) {
8    for (auto& Cell : Cells) {
9      Cell.HandleEvent(E);
10    }
11    if (E.type == UserEvents::APPLE_EATEN) {
12      PlaceRandomApple();
13    }
14  }
15  // ...
16};

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

GameConfig.h (Edited)

Cell.h (Edited)

GameState.h (Edited)

Grid.h (Edited)

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