In this part, we'll implement apple consumption mechanics, handle snake growth, and create a dynamic apple spawning system. By the end of this section, our snake will be able to move around the grid eating apples, and getting longer for every apple it consumes. Screenshot of the snake consuming apples and growing longer

Screenshot of the snake consuming apples and growing longer

## Starting Point 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. ```c++ #include #include #include #include #include "Engine/Window.h" #include "GameState.h" #include "SnakeUI.h" int main(int, char**) { SDL_Init(SDL_INIT_VIDEO); CheckSDLError("Initializing SDL"); TTF_Init(); CheckSDLError("Initializing SDL_ttf"); Engine::Window GameWindow{}; GameState State{}; SnakeUI UI{}; Uint64 PreviousTick{SDL_GetTicks()}; Uint64 CurrentTick; Uint64 DeltaTime; SDL_Event Event; bool IsRunning = true; while (IsRunning) { CurrentTick = SDL_GetTicks(); DeltaTime = CurrentTick - PreviousTick; // Events while (SDL_PollEvent(&Event)) { UI.HandleEvent(Event); State.HandleEvent(Event); if (Event.type == SDL_EVENT_QUIT) { IsRunning = false; } } // Tick State.Tick(DeltaTime); UI.Tick(DeltaTime); // Render GameWindow.Render(); UI.Render(GameWindow.GetSurface()); // Swap GameWindow.Update(); PreviousTick = CurrentTick; } TTF_Quit(); SDL_Quit(); return 0; } ``` ```c++ #pragma once #include #include "Assets.h" #include "Snake/Grid.h" class SnakeUI { public: SnakeUI() : Grid{AssetList} {} void HandleEvent(const SDL_Event& E) { Grid.HandleEvent(E); } void Tick(Uint64 DeltaTime) { Grid.Tick(DeltaTime); } void Render(SDL_Surface* Surface) { Grid.Render(Surface); } private: Assets AssetList; Grid Grid; }; ``` ```c++ #pragma once #include #include "Globals.h" #include "Snake/SnakeData.h" class GameState { public: void HandleEvent(const SDL_Event& E) { if (E.type == SDL_EVENT_KEY_DOWN) { HandleKeyEvent(E.key); } } void Tick(Uint64 DeltaTime) { ElapsedTime += DeltaTime; if (ElapsedTime >= Config::ADVANCE_INTERVAL) { ElapsedTime = 0; UpdateSnake(); } } private: void HandleKeyEvent(const SDL_KeyboardEvent& E) { switch (E.key) { case SDLK_UP: case SDLK_W: if (Snake.Direction != Down) { NextDirection = Up; } break; case SDLK_DOWN: case SDLK_S: if (Snake.Direction != Up) { NextDirection = Down; } break; case SDLK_LEFT: case SDLK_A: if (Snake.Direction != Right) { NextDirection = Left; } break; case SDLK_RIGHT: case SDLK_D: if (Snake.Direction != Left) { NextDirection = Right; } break; } } void UpdateSnake() { Snake.Direction = NextDirection; switch (NextDirection) { case Up: Snake.HeadRow--; break; case Down: Snake.HeadRow++; break; case Left: Snake.HeadCol--; break; case Right: Snake.HeadCol++; break; } SDL_Event Event{}; Event.type = UserEvents::ADVANCE; Event.user.data1 = &Snake; SDL_PushEvent(&Event); } Uint64 ElapsedTime{0}; SnakeData Snake{ Config::GRID_ROWS / 2, 3, 2, Right}; MovementDirection NextDirection{Right}; }; ``` ```c++ #include "Snake/Cell.h" Cell::Cell(int Row, int Column, Assets& AssetList) : Row(Row), Column(Column), AssetList(AssetList), BackgroundRect{ Column * Config::CELL_SIZE + Config::PADDING, Row * Config::CELL_SIZE + Config::PADDING, Config::CELL_SIZE, Config::CELL_SIZE}, BackgroundColor{ (Row + Column) % 2 == 0 ? Config::CELL_COLOR_A : Config::CELL_COLOR_B } { Initialize(); } void Cell::HandleEvent(const SDL_Event& E) { if (E.type == UserEvents::ADVANCE) { Advance(E.user); } } void Cell::Tick(Uint64 DeltaTime) {} void Cell::Render(SDL_Surface* Surface) { SDL_FillSurfaceRect( Surface, &BackgroundRect, SDL_MapRGB( SDL_GetPixelFormatDetails(Surface->format), nullptr, BackgroundColor.r, BackgroundColor.g, BackgroundColor.b ) ); if (State == CellState::Apple) { AssetList.Apple.Render(Surface, &BackgroundRect); } else if (State == CellState::Snake) { SDL_FillSurfaceRect( Surface, &BackgroundRect, SDL_MapRGB( SDL_GetPixelFormatDetails(Surface->format), nullptr, Config::SNAKE_COLOR.r, Config::SNAKE_COLOR.g, Config::SNAKE_COLOR.b ) ); } } void Cell::Initialize() { State = CellState::Empty; SnakeDuration = 0; int MiddleRow{Config::GRID_ROWS / 2}; if (Row == MiddleRow && Column == 2) { State = CellState::Snake; SnakeDuration = 1; } else if (Row == MiddleRow && Column == 3) { State = CellState::Snake; SnakeDuration = 2; } else if (Row == MiddleRow && Column == 11) { State = CellState::Apple; } } void Cell::Advance(const SDL_UserEvent& E) { SnakeData* Data{static_cast(E.data1)}; bool isThisCell{ Data->HeadRow == Row && Data->HeadCol == Column }; if (isThisCell) { State = CellState::Snake; SnakeDuration = Data->Length; } else if (State == CellState::Snake) { --SnakeDuration; if (SnakeDuration == 0) { State = CellState::Empty; } } } ``` ## Adding `APPLE_EATEN` Events 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. ```c++ #pragma once #define CHECK_ERRORS #include #include #include namespace UserEvents{ inline const Uint32 ADVANCE{SDL_RegisterEvents(1)}; inline const Uint32 APPLE_EATEN{// SDL_RegisterEvents(1)};// } // ... ``` 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: ```c++ // ... void Cell::Advance(const SDL_UserEvent& E) { SnakeData* Data{static_cast(E.data1)}; bool isThisCell{ Data->HeadRow == Row && Data->HeadCol == Column }; if (isThisCell) { if (State == CellState::Apple) {// SDL_Event Event{ .type = UserEvents::APPLE_EATEN };// SDL_PushEvent(&Event);// }// State = CellState::Snake; SnakeDuration = Data->Length; } else if (State == CellState::Snake) { --SnakeDuration; if (SnakeDuration == 0) { State = CellState::Empty; } } } ``` This approach keeps our code modular - the cell only needs to announce that an apple was eaten, and other components can react accordingly. ## Reacting to `APPLE_EATEN` Events 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: ```c++ #pragma once #include #include "Globals.h" #include "Snake/SnakeData.h" class GameState { public: void HandleEvent(const SDL_Event& E) { if (E.type == SDL_EVENT_KEY_DOWN) { HandleKeyEvent(E.key); } else if (E.type == UserEvents::APPLE_EATEN) {// ++Snake.Length;// }// } // ... }; ``` 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: ```c++ #include "Snake/Cell.h" // ... void Cell::HandleEvent(const SDL_Event& E) { if (E.type == UserEvents::ADVANCE) { Advance(E.user); } else if (E.type == UserEvents::APPLE_EATEN) {// if (State == CellState::Snake) {// ++SnakeDuration;// }// }// } // ... ``` ## Replacing Apples 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. ```c++ #pragma once #include #include "Globals.h" #include "Assets.h" #include "Snake/SnakeData.h" class Cell { public: // ... bool PlaceApple();// private: // ... }; ``` ```c++ // ... bool Cell::PlaceApple() { if (State != CellState::Empty) return false; State = CellState::Apple; return true; } ``` 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`: ```c++ #pragma once #include #include #include "Snake/Cell.h" #include "Globals.h" #include "Engine/Random.h"// class Grid { // ... private: void PlaceRandomApple() { int RandomIndex{ Engine::Random::Int(0, int(Cells.size()) - 1) }; // ... } std::vector Cells; }; ``` 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: ```c++ #pragma once #include #include #include "Snake/Cell.h" #include "Globals.h" #include "Engine/Random.h" class Grid { // ... private: void PlaceRandomApple() { while (true) { int RandomIndex{ Engine::Random::Int(0, int(Cells.size()) - 1) }; if (Cells[RandomIndex].PlaceApple()) { break; } } } std::vector Cells; }; ``` 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: ```c++ #pragma once #include #include "Snake/Cell.h" #include "Globals.h" #include "Engine/Random.h" class Grid { public: // ... void HandleEvent(const SDL_Event& E) { for (auto& Cell : Cells) { Cell.HandleEvent(E); } if (E.type == UserEvents::APPLE_EATEN) {// PlaceRandomApple();// }// } // ... }; ``` 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. Screenshot of the snake consuming apples and growing longer

### Performance Note This approach where we try a random option, and try again if the option isn't suitable, is a very common way of solving programming problems. However, we should be aware that it can have performance considerations. As our snake gets larger, it can take more attempts to find an empty cell through randomness. This isn't a problem for our simple game, but with more expensive procedures, it may be worth building a more robust solution to solve these types of problems. For example, we could maintain a second list of `Cell` pointers, containing just the empty cells. We could then update that list every time our snake advances, removing the cell the snake's head enters and adding the cell the snake's tail vacates. This approach smooths the work out over many frames ensuring that when the key event happens (e.g., an apple is eaten) there is not a sudden drop in performance whilst the CPU spends significant time finding an appropriate reaction.

## Complete Code Complete versions of the files we changed in this part are available below ```c++ #pragma once #define CHECK_ERRORS #include #include #include namespace UserEvents{ inline const Uint32 ADVANCE{SDL_RegisterEvents(1)}; inline const Uint32 APPLE_EATEN{SDL_RegisterEvents(1)}; } namespace Config{ // Game Settings inline const std::string GAME_NAME{"Snake"}; inline constexpr int ADVANCE_INTERVAL{200}; inline constexpr int GRID_COLUMNS{16}; static_assert( GRID_COLUMNS >= 12, "Grid must be at least 12 columns wide"); inline constexpr int GRID_ROWS{5}; static_assert( GRID_ROWS >= 5, "Grid must be at least 5 rows tall"); // Size and Positioning inline constexpr int PADDING{5}; inline constexpr int CELL_SIZE{36}; inline constexpr int GRID_HEIGHT{ CELL_SIZE * GRID_ROWS}; inline constexpr int GRID_WIDTH{ CELL_SIZE * GRID_COLUMNS}; inline constexpr int WINDOW_HEIGHT{ GRID_HEIGHT + PADDING * 2}; inline constexpr int WINDOW_WIDTH{ GRID_WIDTH + PADDING * 2}; // Colors inline constexpr SDL_Color BACKGROUND_COLOR{ 85, 138, 52, 255}; inline constexpr SDL_Color CELL_COLOR_A{ 171, 214, 82, 255}; inline constexpr SDL_Color CELL_COLOR_B{ 161, 208, 74, 255}; inline constexpr SDL_Color SNAKE_COLOR{ 67, 117, 234, 255}; inline constexpr SDL_Color FONT_COLOR{ 255, 255, 255, 255}; // Asset Paths inline const std::string BASE_PATH{ SDL_GetBasePath()}; inline const std::string APPLE_IMAGE{ BASE_PATH + "apple.png"}; inline const std::string FONT{ BASE_PATH + "Rubik-SemiBold.ttf"}; } inline void CheckSDLError(const std::string& Msg) { #ifdef CHECK_ERRORS const char* error = SDL_GetError(); if (*error != '\0') { std::cerr << Msg << " Error: " << error << '\n'; SDL_ClearError(); } #endif } ``` ```c++ #pragma once #include #include "Globals.h" #include "Assets.h" #include "Snake/SnakeData.h" enum class CellState { Snake, Apple, Empty }; class Cell { public: Cell(int Row, int Column, Assets& AssetList); void HandleEvent(const SDL_Event& E); void Tick(Uint64 DeltaTime); void Render(SDL_Surface* Surface); bool PlaceApple(); private: void Initialize(); void Advance(const SDL_UserEvent& E); int Row; int Column; CellState State; int SnakeDuration; SDL_Rect BackgroundRect; SDL_Color BackgroundColor; Assets& AssetList; }; ``` ```c++ #include "Snake/Cell.h" #include "Snake/SnakeData.h" Cell::Cell(int Row, int Column, Assets& AssetList) : Row(Row), Column(Column), AssetList(AssetList), BackgroundRect{ Column * Config::CELL_SIZE + Config::PADDING, Row * Config::CELL_SIZE + Config::PADDING, Config::CELL_SIZE, Config::CELL_SIZE}, BackgroundColor{ (Row + Column) % 2 == 0 ? Config::CELL_COLOR_A : Config::CELL_COLOR_B } { Initialize(); } void Cell::HandleEvent(const SDL_Event& E) { if (E.type == UserEvents::ADVANCE) { Advance(E.user); } else if (E.type == UserEvents::APPLE_EATEN) { if (State == CellState::Snake) { ++SnakeDuration; } } } void Cell::Tick(Uint64 DeltaTime) {} void Cell::Render(SDL_Surface* Surface) { SDL_FillSurfaceRect( Surface, &BackgroundRect, SDL_MapRGB( SDL_GetPixelFormatDetails(Surface->format), nullptr, BackgroundColor.r, BackgroundColor.g, BackgroundColor.b ) ); if (State == CellState::Apple) { AssetList.Apple.Render(Surface, &BackgroundRect); } else if (State == CellState::Snake) { SDL_FillSurfaceRect( Surface, &BackgroundRect, SDL_MapRGB( SDL_GetPixelFormatDetails(Surface->format), nullptr, Config::SNAKE_COLOR.r, Config::SNAKE_COLOR.g, Config::SNAKE_COLOR.b ) ); } } bool Cell::PlaceApple() { if (State != CellState::Empty) return false; State = CellState::Apple; return true; } void Cell::Initialize() { State = CellState::Empty; SnakeDuration = 0; int MiddleRow{Config::GRID_ROWS / 2}; if (Row == MiddleRow && Column == 2) { State = CellState::Snake; SnakeDuration = 1; } else if (Row == MiddleRow && Column == 3) { State = CellState::Snake; SnakeDuration = 2; } else if (Row == MiddleRow && Column == 11) { State = CellState::Apple; } } void Cell::Advance(const SDL_UserEvent& E) { SnakeData* Data{static_cast(E.data1)}; bool isThisCell{ Data->HeadRow == Row && Data->HeadCol == Column }; if (isThisCell) { if (State == CellState::Apple) { SDL_Event Event{.type = UserEvents::APPLE_EATEN}; SDL_PushEvent(&Event); } State = CellState::Snake; SnakeDuration = Data->Length; } else if (State == CellState::Snake) { --SnakeDuration; if (SnakeDuration == 0) { State = CellState::Empty; } } } ``` ```c++ #pragma once #include #include "Globals.h" #include "Snake/SnakeData.h" class GameState { public: void HandleEvent(const SDL_Event& E) { if (E.type == SDL_EVENT_KEY_DOWN) { HandleKeyEvent(E.key); } else if (E.type == UserEvents::APPLE_EATEN) { ++Snake.Length; } } void Tick(Uint64 DeltaTime) { ElapsedTime += DeltaTime; if (ElapsedTime >= Config::ADVANCE_INTERVAL) { ElapsedTime = 0; UpdateSnake(); } } private: void HandleKeyEvent(const SDL_KeyboardEvent& E) { switch (E.key) { case SDLK_UP: case SDLK_W: if (Snake.Direction != Down) { NextDirection = Up; } break; case SDLK_DOWN: case SDLK_S: if (Snake.Direction != Up) { NextDirection = Down; } break; case SDLK_LEFT: case SDLK_A: if (Snake.Direction != Right) { NextDirection = Left; } break; case SDLK_RIGHT: case SDLK_D: if (Snake.Direction != Left) { NextDirection = Right; } break; } } void UpdateSnake() { Snake.Direction = NextDirection; switch (NextDirection) { case Up: Snake.HeadRow--; break; case Down: Snake.HeadRow++; break; case Left: Snake.HeadCol--; break; case Right: Snake.HeadCol++; break; } SDL_Event Event{}; Event.type = UserEvents::ADVANCE; Event.user.data1 = &Snake; SDL_PushEvent(&Event); } Uint64 ElapsedTime{0}; SnakeData Snake{ Config::GRID_ROWS / 2, 3, 2, Right}; MovementDirection NextDirection{Right}; }; ``` ```c++ #pragma once #include #include #include "Snake/Cell.h" #include "Globals.h" #include "Engine/Random.h" class Grid { public: Grid(Assets& AssetList) { using namespace Config; Cells.reserve(GRID_ROWS * GRID_COLUMNS); for (int R{0}; R < GRID_ROWS; ++R) { for (int C{0}; C < GRID_COLUMNS; ++C) { Cells.emplace_back(R, C, AssetList); } } } void HandleEvent(const SDL_Event& E) { for (auto& Cell : Cells) { Cell.HandleEvent(E); } if (E.type == UserEvents::APPLE_EATEN) { PlaceRandomApple(); } } void Tick(Uint64 DeltaTime) { for (auto& Cell : Cells) { Cell.Tick(DeltaTime); } } void Render(SDL_Surface* surface) { for (auto& Cell : Cells) { Cell.Render(surface); } } private: std::vector Cells; void PlaceRandomApple() { while (true) { int RandomIndex{ Engine::Random::Int(0, int(Cells.size()) - 1) }; if (Cells[RandomIndex].PlaceApple()) { break; } } } }; ``` 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

Snake Growth

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation