Now that we have a working game with basic movement and apple collection, it's time to add win-and-loss conditions to create a complete experience. In this lesson, we'll implement collision detection for game over states, add a winning condition when the snake reaches maximum length, and provide visual feedback for both outcomes. ## Starting Point We'll continue from where we left off in the previous lesson. Our project already has a grid of interactive cells, a controllable snake, the ability for the snake to eat apples and grow, and a restart button. 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" #include "Snake/RestartButton.h" class SnakeUI { public: SnakeUI() : Grid{AssetList}, RestartBtn{ Config::WINDOW_WIDTH - 150, Config::GRID_HEIGHT + Config::PADDING * 2, 150 - Config::PADDING, Config::FOOTER_HEIGHT - Config::PADDING } {} void HandleEvent(const SDL_Event& E) { Grid.HandleEvent(E); RestartBtn.HandleEvent(E); } void Tick(Uint64 DeltaTime) { Grid.Tick(DeltaTime); } void Render(SDL_Surface* Surface) { Grid.Render(Surface); RestartBtn.Render(Surface); } private: Assets AssetList; Grid Grid; RestartButton RestartBtn; }; ``` ```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; } else if (E.type == UserEvents::RESTART_GAME) { RestartGame(); } } void Tick(Uint64 DeltaTime) { if (IsPaused) return; 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 (IsPaused) { IsPaused = false; NextDirection = Right; UpdateSnake(); } else 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); } void RestartGame() { IsPaused = true; ElapsedTime = 0; Snake = { .HeadRow = Config::GRID_ROWS / 2, .HeadCol = 3, .Length = 2, .Direction = Right }; NextDirection = Right; } bool IsPaused{true}; Uint64 ElapsedTime{0}; SnakeData Snake{ .HeadRow = Config::GRID_ROWS / 2, .HeadCol = 3, .Length = 2, .Direction = Right }; MovementDirection NextDirection{Right}; }; ``` ```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 } { Reset(); } 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; } } else if (E.type == UserEvents::RESTART_GAME) { Reset(); } } 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::Reset() { 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) { auto* 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; } } } ``` ## The `GAME_WON` and `GAME_LOST` Events Let's begin by creating new event types that we can dispatch to notify our components that a game has been won or lost: ```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)}; inline const Uint32 RESTART_GAME{SDL_RegisterEvents(1)}; inline const Uint32 GAME_WON{// SDL_RegisterEvents(1)};// inline const Uint32 GAME_LOST{// SDL_RegisterEvents(1)};// } // ... ``` ## Winning the Game The only way to win in Snake is to get our snake to some target length. We'll create a variable in our `Globals.h` to set what this should be. We're free to set it however we like, and we can derive the value based on the grid size if we want: ```c++ // ... namespace Config{ // ... 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"); inline constexpr int MAX_LENGTH{// GRID_COLUMNS * GRID_ROWS};// // ... } // ... ``` Currently, the length of our snake is managed within the `GameState` class, where it is incremented every time an `APPLE_EATEN` event is encountered. Let's expand that logic to dispatch a `GAME_WON` event if our snake's length reaches the maximum length: ```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; if (Snake.Length == Config::MAX_LENGTH) {// SDL_Event Event{};// Event.type = UserEvents::GAME_WON;// SDL_PushEvent(&Event);// }// } else if (E.type == UserEvents::RESTART_GAME) { RestartGame(); } } // ... }; ``` ## Losing the Game There are two failure conditions in our Snake game: 1. **Boundary Collision**: When the snake hits the edge of the grid 2. **Self-Collision**: When the snake runs into its own body Let's implement both of these conditions. ### Implementing Boundary Collision We'll add boundary collision detection in the `UpdateSnake()` method of our `GameState` class. After calculating the new head position, we'll check if it lies outside the valid grid coordinates. If it does, we'll dispatch a `GAME_LOST` event, otherwise, we'll dispatch an `ADVANCE` event as before: ```c++ // ... class GameState { // ... private: 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; } if (// Snake.HeadRow < 0 ||// Snake.HeadRow >= Config::GRID_ROWS ||// Snake.HeadCol < 0 ||// Snake.HeadCol >= Config::GRID_COLUMNS// ) {// SDL_Event Event{};// Event.type = UserEvents::GAME_LOST;// SDL_PushEvent(&Event);// } else { // If we're not going outside the bounds // of the grid, advance as before SDL_Event Event{}; Event.type = UserEvents::ADVANCE; Event.user.data1 = &Snake; SDL_PushEvent(&Event); } } // ... }; ``` ### Implementing Self Collision For detecting when the snake collides with itself, we'll use our `Cell` class. Within the `Cell::Advance()` method, we'll check if the snake is moving into a cell that already contains a snake segment. If it is, we'll dispatch a `GAME_LOST` event: ```c++ // ... void Cell::Advance(const SDL_UserEvent& E) { auto* Data{static_cast(E.data1)}; bool isThisCell{ Data->HeadRow == Row && Data->HeadCol == Column }; if (isThisCell) { if (State == CellState::Snake) {// SDL_Event Event{};// Event.type = UserEvents::GAME_LOST;// SDL_PushEvent(&Event);// return;// }// 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; } } } ``` ## Reacting to Victory and Loss Now that we're dispatching `GAME_WON` and `GAME_LOST` events at the correct time, we need to update our components to react to these events. We'll do three things when the game is over: - Our `GameState` will have a `GameOver` state which pauses the game and ignores keyboard input until the user presses the restart button. - The `RestartButton` will be highlighted, indicating that the user needs to press it. - The snake's color will change to indicate whether the user won or lost. Let's update these components step by step. ### 1. Updating the Game State We'll add an `IsGameOver` boolean to our `GameState` class. We'll initialize it to `false`, and reset it back to `false` every time we restart the game: ```c++ #pragma once #include #include "Globals.h" #include "Snake/SnakeData.h" class GameState { // ... private: void RestartGame() { IsPaused = true; IsGameOver = false;// ElapsedTime = 0; Snake = { .HeadRow = Config::GRID_ROWS / 2, .HeadCol = 3, .Length = 2, .Direction = Right }; NextDirection = Right; } bool IsPaused{true}; bool IsGameOver{false};// // ... }; ``` When our `GameState` object receives a `GAME_LOST` or `GAME_WON` event, we'll update this `IsGameOver` variable to `true`: ```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; if (Snake.Length == Config::MAX_LENGTH) { SDL_Event Event{}; Event.type = UserEvents::GAME_WON; SDL_PushEvent(&Event); } } else if (E.type == UserEvents::RESTART_GAME) { RestartGame(); } else if (E.type == UserEvents::GAME_LOST ||// E.type == UserEvents::GAME_WON) {// IsGameOver = true;// }// } // ... }; ``` When the game is over, we'll replicate a similar behavior to the initial `IsPaused` state. First, we'll disable our ticking logic: ```c++ #pragma once #include #include "Globals.h" #include "Snake/SnakeData.h" class GameState { public: // ... void Tick(Uint64 DeltaTime) { if (IsPaused || IsGameOver) return;// ElapsedTime += DeltaTime; if (ElapsedTime >= Config::ADVANCE_INTERVAL) { ElapsedTime = 0; UpdateSnake(); } } // ... }; ``` Additionally, when the game is over, we'll ignore keyboard input until the game is restarted: ```c++ // ... class GameState { // ... private: void HandleKeyEvent(const SDL_KeyboardEvent& E) { if (IsGameOver) return;// // 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 (IsPaused) { NextDirection = Right; IsPaused = false; UpdateSnake(); } else if (Snake.Direction != Left) { NextDirection = Right; } break; } // } }; ``` If we run our game, we should now note that our snake stops moving and our keyboard input is ignored once we win or lose the game. Note that the `IsGameOver` and `IsPaused` states are subtly different. Both of these states disable our `GameState` object's `Tick()` behavior, but the logic in our `HandleKeyEvent()` function continues to be evaluated if the game is only paused. Players can press the right arrow or D key to unpause the game by setting `IsPaused` to `false`, but to set `IsGameOver` to `false`, they need to restart the game. ### 2. Highlighting the Restart Button To indicate to the user that they need to press the restart button when the game is over, let's highlight that button. We'll first create a variable to control the highlighted color of our button: ```c++ // ... namespace Config{ // ... // Colors // ... inline constexpr SDL_Color BUTTON_COLOR{ 73, 117, 46, 255}; inline constexpr SDL_Color BUTTON_HIGHLIGHT_COLOR{// 67, 117, 234, 255};// // ... } // ... ``` In our `RestartButton` class, we'll update our `HandleEvent()` function to change the `CurrentColor` member based on `GAME_LOST`, `GAME_WON`, and `RESTART_GAME` events: ```c++ #pragma once #include #include "Globals.h" #include "Engine/Text.h" class RestartButton { public: // ... void HandleEvent(const SDL_Event& E) { if (E.type == SDL_EVENT_MOUSE_BUTTON_DOWN) { HandleClick(E.button); } else if (// E.type == UserEvents::GAME_LOST ||// E.type == UserEvents::GAME_WON// ) {// CurrentColor = Config::BUTTON_HIGHLIGHT_COLOR;// } else if (E.type == UserEvents::RESTART_GAME) {// CurrentColor = Config::BUTTON_COLOR;// }// } // ... }; ``` Running our code, we should now see that the restart button uses a different color when the game is over: Screenshot showing the restart button highlighting after the snake collides with the border

Screenshot showing the restart button highlighting after the snake collides with the border

### 3. Changing Snake Color Finally, let's update the color of our snake when the user has won or lost the game. We'll add new configuration variables for these colors: ```c++ // ... namespace Config{ // ... // Colors // ... inline constexpr SDL_Color SNAKE_COLOR{ 67, 117, 234, 255}; inline constexpr SDL_Color SNAKE_LOST_COLOR{// 227, 67, 97, 255};// inline constexpr SDL_Color SNAKE_VICTORY_COLOR{// 255, 140, 0, 255};// // ... } ``` In our `Cell` class, we'll add a `SnakeColor` variable to keep track of what color our snake segments should be. We'll set this to the default `SNAKE_COLOR` variable every time our cell is reset: ```c++ // ... class Cell { // ... private: // ... SDL_Color SnakeColor{Config::SNAKE_COLOR};// }; ``` ```c++ // ... void Cell::Reset() { State = CellState::Empty; SnakeColor = Config::SNAKE_COLOR;// 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; } } // ... ``` Within the `HandleEvent()` function, we'll change this color depending on whether the player won or lost. Our `Reset()` function is already being called when the game is restarted, so we're already handling that scenario: ```c++ // ... 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; } } else if (E.type == UserEvents::GAME_LOST) {// SnakeColor = Config::SNAKE_LOST_COLOR;// } else if (E.type == UserEvents::GAME_WON) {// SnakeColor = Config::SNAKE_VICTORY_COLOR;// } else if (E.type == UserEvents::RESTART_GAME) { Reset(); } } // ... ``` Finally, let's update our `Render()` method to use this new `SnakeColor` variable, rather than the static `Config::SNAKE_COLOR` value it was previously using: ```c++ // ... 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, SnakeColor.r,// SnakeColor.g,// SnakeColor.b// ) ); } } // ... ``` Now, when we lose, our snake should be rendered in the `SNAKE_LOST_COLOR` we defined: Screenshot showing the snake colored red after colliding with the border wall

Screenshot showing the snake colored red after colliding with the border wall

And, when we win, it should use the `SNAKE_VICTORY_COLOR`. To test this, it can be helpful to temporarily reduce the `MAX_LENGTH` value to make winning easier: Screenshot showing the snake colored gold after winning the game

Screenshot showing the snake colored gold after winning the game

## 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)}; inline const Uint32 GAME_WON{ SDL_RegisterEvents(1)}; inline const Uint32 GAME_LOST{ SDL_RegisterEvents(1)}; inline const Uint32 RESTART_GAME{ 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" ); inline constexpr int MAX_LENGTH{ GRID_COLUMNS * GRID_ROWS}; // Size and Positioning inline constexpr int PADDING{5}; inline constexpr int CELL_SIZE{36}; inline constexpr int FOOTER_HEIGHT{60}; 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 + FOOTER_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 SNAKE_LOST_COLOR{ 227, 67, 97, 255}; inline constexpr SDL_Color SNAKE_VICTORY_COLOR{ 255, 140, 0, 255}; inline constexpr SDL_Color BUTTON_COLOR{ 73, 117, 46, 255}; inline constexpr SDL_Color BUTTON_HIGHLIGHT_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 "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; if (Snake.Length == Config::MAX_LENGTH) { SDL_Event Event{}; Event.type = UserEvents::GAME_WON; SDL_PushEvent(&Event); } } else if (E.type == UserEvents::RESTART_GAME) { RestartGame(); } else if (E.type == UserEvents::GAME_LOST || E.type == UserEvents::GAME_WON ) { IsGameOver = true; } } void Tick(Uint64 DeltaTime) { if (IsPaused || IsGameOver) return; ElapsedTime += DeltaTime; if (ElapsedTime >= Config::ADVANCE_INTERVAL) { ElapsedTime = 0; UpdateSnake(); } } private: void HandleKeyEvent(const SDL_KeyboardEvent& E) { if (IsGameOver) return; 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 (IsPaused) { IsPaused = false; NextDirection = Right; UpdateSnake(); } else 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; } if (Snake.HeadRow < 0 || Snake.HeadRow >= Config::GRID_ROWS || Snake.HeadCol < 0 || Snake.HeadCol >= Config::GRID_COLUMNS ) { SDL_Event Event{}; Event.type = UserEvents::GAME_LOST; SDL_PushEvent(&Event); } else { SDL_Event Event{}; Event.type = UserEvents::ADVANCE; Event.user.data1 = &Snake; SDL_PushEvent(&Event); } } void RestartGame() { IsPaused = true; IsGameOver = false; ElapsedTime = 0; Snake = { .HeadRow = Config::GRID_ROWS / 2, .HeadCol = 3, .Length = 2, .Direction = Right }; NextDirection = Right; } bool IsPaused{true}; bool IsGameOver{false}; Uint64 ElapsedTime{0}; SnakeData Snake{ .HeadRow = Config::GRID_ROWS / 2, .HeadCol = 3, .Length = 2, .Direction = Right }; MovementDirection NextDirection{Right}; }; ``` ```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(); void Reset(); private: void Advance(const SDL_UserEvent& E); int Row; int Column; CellState State; int SnakeDuration; SDL_Color SnakeColor; 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 } { Reset(); } 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; } } else if (E.type == UserEvents::GAME_LOST) { SnakeColor = Config::SNAKE_LOST_COLOR; } else if (E.type == UserEvents::GAME_WON) { SnakeColor = Config::SNAKE_VICTORY_COLOR; } else if (E.type == UserEvents::RESTART_GAME) { Reset(); } } 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, SnakeColor.r, SnakeColor.g, SnakeColor.b ) ); } } bool Cell::PlaceApple() { if (State != CellState::Empty) return false; State = CellState::Apple; return true; } void Cell::Reset() { State = CellState::Empty; SnakeColor = Config::SNAKE_COLOR; 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) { auto* Data{static_cast(E.data1)}; bool isThisCell{ Data->HeadRow == Row && Data->HeadCol == Column }; if (isThisCell) { if (State == CellState::Snake) { SDL_Event Event{}; Event.type = UserEvents::GAME_LOST; SDL_PushEvent(&Event); return; } 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 "Engine/Text.h" class RestartButton { public: RestartButton(int x, int y, int w, int h) : ButtonRect{x, y, w, h}, CurrentColor{Config::BUTTON_COLOR}, Text{"RESTART", 20}, TextRect{ x + Config::PADDING * 5, y + Config::PADDING * 3, 0, 0 } {} void Render(SDL_Surface* Surface) { SDL_FillSurfaceRect(Surface, &ButtonRect, SDL_MapRGB( SDL_GetPixelFormatDetails(Surface->format), nullptr, CurrentColor.r, CurrentColor.g, CurrentColor.b ) ); Text.Render(Surface, &TextRect); } void HandleEvent(const SDL_Event& E) { if (E.type == SDL_EVENT_MOUSE_BUTTON_DOWN) { HandleClick(E.button); } else if ( E.type == UserEvents::GAME_LOST || E.type == UserEvents::GAME_WON ) { CurrentColor = Config::BUTTON_HIGHLIGHT_COLOR; } else if (E.type == UserEvents::RESTART_GAME) { CurrentColor = Config::BUTTON_COLOR; } } private: void HandleClick(const SDL_MouseButtonEvent& E) { if ( E.x >= ButtonRect.x && E.x <= ButtonRect.x + ButtonRect.w && E.y >= ButtonRect.y && E.y <= ButtonRect.y + ButtonRect.h ) { SDL_Event RestartEvent{}; RestartEvent.type = UserEvents::RESTART_GAME; SDL_PushEvent(&RestartEvent); } } Engine::Text Text; SDL_Rect TextRect; SDL_Rect ButtonRect; SDL_Color CurrentColor; }; ``` Files not listed above have not been changed since the previous section. ## Summary In this lesson, we implemented the win and loss conditions for our Snake game, bringing it closer completion. Key steps from this lesson include: - **Win/Loss Events**: We created custom SDL events (`GAME_WON` and `GAME_LOST`) to signal the end of the game. - **Collision Detection**: We implemented logic to detect both boundary and self-collisions, triggering a game loss. - **Win Condition**: We added a check for when the snake reaches its maximum possible length, triggering a game win. - **Visual Feedback**: We updated the game to change the snake's color and highlight the restart button based on the game's outcome. - **Game State Control**: We enhanced the `GameState` class to pause the game and disable input when the game is over. With these features in place, our game is nearly complete. The next lessons will add the final touches, including a score display and smoother snake movement.

Win/Loss Logic for Snake

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation