In this final part of our series, we'll add the ability for players to place flags on suspected mine locations. We'll update our game logic to handle flag placement and removal, create a visual representation for flags, and implement a counter to track the number of flags placed. By the end of this lesson, you'll have a fully functional Minesweeper game. ## Starting Point Our project already has a grid of interactive cells, win/loss detection, and a restart button. The starting point below is a direct continuation of the previous lesson's final code - we've repeated the most relevant files to this lesson below for reference: ```c++ #include #include #include #include #include "Globals.h" #include "Engine/Window.h" #include "Minesweeper/UI.h" int main(int, char**){ SDL_Init(SDL_INIT_VIDEO); #ifdef SHOW_DEBUG_HELPERS Utils::CheckSDLError("SDL_Init"); #endif TTF_Init(); #ifdef SHOW_DEBUG_HELPERS Utils::CheckSDLError("TTF_Init"); #endif Engine::Window GameWindow; MinesweeperUI UI; SDL_Event Event; bool shouldQuit{false}; while (!shouldQuit) { while (SDL_PollEvent(&Event)) { if (Event.type == SDL_EVENT_QUIT) { shouldQuit = true; } else { UI.HandleEvent(Event); } } GameWindow.Render(); UI.Render(GameWindow.GetSurface()); GameWindow.Update(); } TTF_Quit(); SDL_Quit(); return 0; } ``` ```c++ #pragma once #include #include #include "Globals.h" #include "Minesweeper/Cell.h" #include "Engine/Random.h" class MinesweeperGrid { public: MinesweeperGrid(int x, int y){ using namespace Config; Children.reserve(GRID_COLUMNS * GRID_ROWS); for (int Col{1}; Col <= GRID_COLUMNS; ++Col) { for (int Row{1}; Row <= GRID_ROWS; ++Row) { constexpr int Spacing{ CELL_SIZE + PADDING}; Children.emplace_back( x + (Spacing) * (Col - 1), y + (Spacing) * (Row - 1), CELL_SIZE, CELL_SIZE, Row, Col ); } } PlaceBombs(); } void Render(SDL_Surface* Surface){ for (auto& Child : Children) { Child.Render(Surface); } } void HandleEvent(const SDL_Event& E){ if (E.type == UserEvents::CELL_CLEARED) { HandleCellCleared(E.user); } else if (E.type == UserEvents::NEW_GAME) { for (auto& Child : Children) { Child.Reset(); } PlaceBombs(); } for (auto& Child : Children) { Child.HandleEvent(E); } } private: void HandleCellCleared(const SDL_UserEvent& E){ auto* Cell{ static_cast(E.data1) }; if (Cell->GetHasBomb()) { SDL_Event Event{}; Event.type = UserEvents::GAME_LOST; SDL_PushEvent(&Event); } else { --CellsToClear; if (CellsToClear == 0) { SDL_Event Event{}; Event.type = UserEvents::GAME_WON; SDL_PushEvent(&Event); } } } void PlaceBombs(){ int BombsToPlace{Config::BOMB_COUNT}; CellsToClear = Config::GRID_COLUMNS * Config::GRID_ROWS - Config::BOMB_COUNT; while (BombsToPlace > 0) { const size_t RandomIndex{ Engine::Random::Int( 0, Children.size() - 1 )}; if (Children[RandomIndex].PlaceBomb()) { --BombsToPlace; } } } std::vector Children; int CellsToClear{0}; }; ``` ```c++ #pragma once #include #include #include "Engine/Button.h" #include "Engine/Image.h" #include "Engine/Text.h" class MinesweeperCell : public Engine::Button { public: MinesweeperCell( int X, int Y, int W, int H, int Row, int Col ); void HandleEvent(const SDL_Event& E) override; void Render(SDL_Surface* Surface) override; void Reset(); bool PlaceBomb(); [[nodiscard]] bool GetHasBomb() const{ return hasBomb; } [[nodiscard]] int GetRow() const{ return Row; } [[nodiscard]] int GetCol() const{ return Col; } protected: void HandleLeftClick() override; private: void ClearCell(); void ReportEvent(Uint32 EventType); void HandleCellCleared(const SDL_UserEvent& E); void HandleBombPlaced(const SDL_UserEvent& E); bool isAdjacent(const MinesweeperCell* Other) const; int AdjacentBombs{0}; int Row; int Col; bool hasBomb{false}; bool isCleared{false}; std::unique_ptr BombImage; std::unique_ptr Text; }; ``` ```c++ #include #include #include #include #include "Minesweeper/Cell.h" #include "Globals.h" MinesweeperCell::MinesweeperCell( int x, int y, int w, int h, int Row, int Col) : Button{x, y, w, h}, Row{Row}, Col{Col} { BombImage = std::make_unique( x, y, w, h, Config::BOMB_IMAGE ); Text = std::make_unique( x, y, w, h, std::to_string(AdjacentBombs), Config::TEXT_COLORS[AdjacentBombs] ); }; void MinesweeperCell::HandleEvent( const SDL_Event& E){ if (E.type == UserEvents::CELL_CLEARED) { HandleCellCleared(E.user); } else if (E.type == UserEvents::BOMB_PLACED) { HandleBombPlaced(E.user); } else if (E.type == UserEvents::GAME_WON) { if (hasBomb) { SetColor(Config::BUTTON_SUCCESS_COLOR); } SetIsDisabled(true); } else if (E.type == UserEvents::GAME_LOST) { if (hasBomb) { isCleared = true; SetColor(Config::BUTTON_FAILURE_COLOR); } SetIsDisabled(true); } Button::HandleEvent(E); } void MinesweeperCell::Render(SDL_Surface* Surface){ Button::Render(Surface); if (isCleared && hasBomb) { BombImage->Render(Surface); } else if (isCleared && AdjacentBombs > 0) { Text->Render(Surface); } #ifdef SHOW_DEBUG_HELPERS else if (hasBomb) { BombImage->Render(Surface); } #endif } void MinesweeperCell::Reset(){ isCleared = false; hasBomb = false; AdjacentBombs = 0; SetIsDisabled(false); SetColor(Config::BUTTON_COLOR); Text->SetText( std::to_string(AdjacentBombs), Config::TEXT_COLORS[AdjacentBombs] ); } bool MinesweeperCell::PlaceBomb(){ if (hasBomb) return false; hasBomb = true; ReportEvent(UserEvents::BOMB_PLACED); return true; } void MinesweeperCell::ClearCell(){ if (isCleared) return; isCleared = true; SetIsDisabled(true); SetColor(Config::BUTTON_CLEARED_COLOR); ReportEvent(UserEvents::CELL_CLEARED); } void MinesweeperCell::ReportEvent(Uint32 EventType){ SDL_Event event{}; event.type = EventType; event.user.data1 = this; SDL_PushEvent(&event); } void MinesweeperCell::HandleCellCleared( const SDL_UserEvent& E){ const auto* Cell{ static_cast(E.data1) }; if (Cell->GetHasBomb()) return; if (isAdjacent(Cell) && Cell->AdjacentBombs == 0) { ClearCell(); } } void MinesweeperCell::HandleBombPlaced( const SDL_UserEvent& E){ const auto* Cell{ static_cast(E.data1) }; if (isAdjacent(Cell)) { ++AdjacentBombs; Text->SetText(std::to_string(AdjacentBombs), Config::TEXT_COLORS[AdjacentBombs]); } } bool MinesweeperCell::isAdjacent( const MinesweeperCell* Other) const{ return !(Other == this) && std::abs(Other->GetRow() - Row) <= 1 && std::abs(Other->GetCol() - Col) <= 1; } void MinesweeperCell::HandleLeftClick(){ ClearCell(); } ``` ## Updating Globals Let's start by updating our `Globals.h`. We'll register events for flags being placed and cleared. We'll also be using the `FLAG_IMAGE` string we added earlier, defining where our flag image is stored: ```c++ // ... namespace UserEvents{ // ... inline const Uint32 NEW_GAME{ SDL_RegisterEvents(1)}; inline const Uint32 FLAG_PLACED{// SDL_RegisterEvents(1)};// inline const Uint32 FLAG_CLEARED{// SDL_RegisterEvents(1)};// } namespace Config{ // ... // Asset Paths inline const std::string BASE_PATH{ SDL_GetBasePath()}; inline const std::string BOMB_IMAGE{ BASE_PATH + "Bomb.png"}; inline const std::string FLAG_IMAGE{// BASE_PATH + "Flag.png"};// inline const std::string FONT{ BASE_PATH + "Roboto-Medium.ttf"}; } // ... ``` ## Placing Flags on Right Clicks To place a flag, players will right-click on a cell, so we need to update our `MinesweeperCell` class. The base `Engine::Button` class has a `HandleRightClick()` method we can override, and we'll additionally add a boolean to store whether the player has placed a flag in this cell: ```c++ // ... class MinesweeperCell : public Engine::Button { // ... protected: // ... void HandleRightClick() override;// private: // ... bool hasFlag{false};// }; ``` In our `HandleRightClick()` implementation, we'll simply toggle the `hasFlag` variable, and report the appropriate event: ```c++ // ... void MinesweeperCell::HandleLeftClick(){ ClearCell(); } void MinesweeperCell::HandleRightClick(){// if (hasFlag) {// ReportEvent(UserEvents::FLAG_CLEARED);// hasFlag = false;// } else {// ReportEvent(UserEvents::FLAG_PLACED);// hasFlag = true;// }// }// ``` Left-clicking on a cell that contains a flag shouldn't clear the cell, so let's add that logic to our `HandleLeftClick()` function: ```c++ // ... void MinesweeperCell::HandleLeftClick(){ if (!hasFlag) { ClearCell(); }// } // ... ``` When the player starts a new game, all the flags should be cleared. Let's add that to our `Reset()` function: ```c++ // ... void MinesweeperCell::Reset(){ isCleared = false; hasFlag = false;// hasBomb = false; AdjacentBombs = 0; SetIsDisabled(false); SetColor(Config::BUTTON_COLOR); Text->SetText( std::to_string(AdjacentBombs), Config::TEXT_COLORS[AdjacentBombs] ); } // ... ``` The player doesn't necessarily need to mark all the bombs to win the game. As a small presentational improvement, let's just automatically flag all the cells with bombs in response to the `GAME_WON` event: ```c++ // ... void MinesweeperCell::HandleEvent( const SDL_Event& E){ if (E.type == UserEvents::CELL_CLEARED) { HandleCellCleared(E.user); } else if (E.type == UserEvents::BOMB_PLACED) { HandleBombPlaced(E.user); } else if (E.type == UserEvents::GAME_WON) { if (hasBomb) { hasFlag = true; // SetColor(Config::BUTTON_SUCCESS_COLOR); } SetIsDisabled(true); } else if (E.type == UserEvents::GAME_LOST) { if (hasBomb) { isCleared = true; SetColor(Config::BUTTON_FAILURE_COLOR); } SetIsDisabled(true); } Button::HandleEvent(E); } // ... ``` ## Rendering Flags Now that our cells are keeping track of whether or not they're flagged, let's render some visual output for the flags. We'll add another `std::unique_ptr` member to our `MinesweeperCell` to render the flag: ```c++ // ... class MinesweeperCell : public Engine::Button { // ... private: // ... std::unique_ptr FlagImage;// std::unique_ptr BombImage; std::unique_ptr Text; }; ``` In our constructor, we initialize this variable in much the same way we initialized the bomb image: ```c++ // ... MinesweeperCell::MinesweeperCell( int x, int y, int w, int h, int Row, int Col) : Button{x, y, w, h}, Row{Row}, Col{Col} { FlagImage = std::make_unique(// x, y, w, h,// Config::FLAG_IMAGE// );// BombImage = std::make_unique( x, y, w, h, Config::BOMB_IMAGE ); Text = std::make_unique( x, y, w, h, std::to_string(AdjacentBombs), Config::TEXT_COLORS[AdjacentBombs] ); }; // ... ``` Finally, in our `Render()` method, if the cell has a flag, we'll render the `FlagImage`: ```c++ // ... void MinesweeperCell::Render( SDL_Surface* Surface){ Button::Render(Surface); if (hasFlag) {// FlagImage->Render(Surface);// } else if (isCleared && hasBomb) { BombImage->Render(Surface); } else if (isCleared && AdjacentBombs > 0) { Text->Render(Surface); } #ifdef SHOW_DEBUG_HELPERS else if (hasBomb) { BombImage->Render(Surface); } #endif } // ... ``` Running our game, we can now right-click in any uncleared cell to place a flag. Left-clicking a flagged cell should have no effect, but right-clicking it will remove the flag: Screenshot of our program

## Flag Counter Let's add a counter to our footer, so the player can keep track of how many bombs they have yet to place flags on. This indicator will span the full height of the footer, with its width and color controlled by `Config` variables in `Globals.h`: ```c++ // ... namespace Config{ // ... inline constexpr int FLAG_COUNTER_WIDTH{100}; // ... inline constexpr SDL_Color FLAG_COUNTER_COLOR{ 80, 80, 80, 255}; // ... } // ... ``` Let's create our `Minesweeper/FlagCounter.h` class. It inherits from `Engine::Rectangle`, and will contain an `Image` and `Text` element side-by-side. The position and size of the `Rectangle` will be controlled by constructor arguments, with the color coming from our `Config` namespace. The `Image` will be placed at the top left of the `Rectangle`, with its height being based on the `FOOTER_HEIGHT` config variable, and its width being the same as the height to ensure it is square. We also apply a 24 pixel padding to make the image slightly smaller. The `Text` variable uses slightly more arithmetic to ensure it appears to the right of the `Image`. We also set the initial string to be the total number of bombs in the grid. We set the color to white, and the font size to 20: ```c++ #pragma once #include #include #include #include "Globals.h" #include "Engine/Rectangle.h" #include "Engine/Text.h" #include "Engine/Image.h" class FlagCounter : public Engine::Rectangle { public: FlagCounter(int x, int y, int w, int h) : Rectangle{ x, y, w, h, Config::FLAG_COUNTER_COLOR}, Image{ std::make_unique( x, y, Config::FOOTER_HEIGHT - Config::PADDING, Config::FOOTER_HEIGHT - Config::PADDING, Config::FLAG_IMAGE, 24 )}, Text{ std::make_unique( x + Config::FOOTER_HEIGHT, y, w - Config::FOOTER_HEIGHT - 24, h, std::to_string(Config::BOMB_COUNT), SDL_Color{255, 255, 255, 255}, 20.0f )} {} private: std::unique_ptr Image; std::unique_ptr Text; }; ``` We'll override the base rectangle's `Render()` method to ensure the `Text` and `Image` are also rendered: ```c++ // ... class FlagCounter : public Engine::Rectangle { public: // ... void Render(SDL_Surface* Surface) override{ Rectangle::Render(Surface); Text->Render(Surface); Image->Render(Surface); } // ... }; ``` Finally, we'll implement a `HandleEvent()` method so that the `FlagCounter` can update appropriately: - When the player places a flag, we decrement the number of available flags - When the player clears a flag, we increment the number of available flags - When the game is won, we set the available flags to `0` because, when the game is won, our `MinesweeperCell` objects automatically place flags where all the bombs were - When the user restarts the game, the number of available flags is set to its initial value. Additionally, when _**any**_ of these events occur, we call the `Text` member's `SetText()` function to inform it what number it should be rendering: ```c++ // ... class FlagCounter : public Engine::Rectangle { public: // ... void HandleEvent(const SDL_Event& E){ if (E.type == UserEvents::FLAG_PLACED) { --FlagsAvailable; } else if (E.type == UserEvents::FLAG_CLEARED) { ++FlagsAvailable; } else if (E.type == UserEvents::GAME_WON) { FlagsAvailable = 0; } else if (E.type == UserEvents::NEW_GAME) { FlagsAvailable = Config::BOMB_COUNT; } else { return; } Text->SetText( std::to_string(FlagsAvailable) ); } private: // ... int FlagsAvailable{Config::BOMB_COUNT}; }; ``` Finally, let's add it to the UI. As before, we add it as a member of our `MinesweeperUI`, and add it to our `Render()` and `HandleEvent()` functions. We reduce the width of the `NewGameButton` to make space in the footer, and then do some arithmetic to set the `FlagCounter`'s position (`x` and `y`) and size (`w` and `h`). The calculations involved to determine these constructor arguments is getting excessively messy and something we'd typically want to address. Given we're essentially finished with this project, we'll leave it like this for now. However, it's a problem we should consider solving in our `Engine` module to make future projects easier. We discuss options for this later in the lesson. Our final `MinesweeperUI` class looks like this: ```c++ #pragma once #include #include "Globals.h" #include "Minesweeper/Grid.h" #include "Minesweeper/NewGameButton.h" #include "Minesweeper/FlagCounter.h"// class MinesweeperUI { public: void Render(SDL_Surface* Surface){ Grid.Render(Surface); Button.Render(Surface); Counter.Render(Surface);// } void HandleEvent(const SDL_Event& E){ Grid.HandleEvent(E); Button.HandleEvent(E); Counter.HandleEvent(E);// }; private: MinesweeperGrid Grid{ Config::PADDING, Config::PADDING }; NewGameButton Button{ Config::PADDING, Config::GRID_HEIGHT + Config::PADDING * 2, Config::WINDOW_WIDTH - Config::PADDING * 3 - Config::FLAG_COUNTER_WIDTH,// Config::FOOTER_HEIGHT - Config::PADDING }; FlagCounter Counter{// Config::WINDOW_WIDTH - Config::PADDING// - Config::FLAG_COUNTER_WIDTH,// Config::GRID_HEIGHT + Config::PADDING * 2,// Config::FLAG_COUNTER_WIDTH,// Config::FOOTER_HEIGHT - Config::PADDING// };// }; ``` Our game is now complete and should be fully working! Remember to disable the `SHOW_DEBUG_HELPERS` definition to hide the bombs: Screenshot of our program

## Complete Code Complete versions of the files we changed in this part are available below. ```c++ #include #include #include #include #include "Globals.h" #include "Engine/Window.h" #include "Minesweeper/UI.h" int main(int, char**){ SDL_Init(SDL_INIT_VIDEO); #ifdef SHOW_DEBUG_HELPERS Utils::CheckSDLError("SDL_Init"); #endif TTF_Init(); #ifdef SHOW_DEBUG_HELPERS Utils::CheckSDLError("TTF_Init"); #endif Engine::Window GameWindow; MinesweeperUI UI; SDL_Event Event; bool shouldQuit{false}; while (!shouldQuit) { while (SDL_PollEvent(&Event)) { if (Event.type == SDL_EVENT_QUIT) { shouldQuit = true; } else { UI.HandleEvent(Event); } } GameWindow.Render(); UI.Render(GameWindow.GetSurface()); GameWindow.Update(); } TTF_Quit(); SDL_Quit(); return 0; } ``` ```c++ #pragma once // #define SHOW_DEBUG_HELPERS #include #include #include #include namespace UserEvents{ inline const Uint32 CELL_CLEARED{ SDL_RegisterEvents(1)}; inline const Uint32 BOMB_PLACED{ SDL_RegisterEvents(1)}; inline const Uint32 FLAG_PLACED{ SDL_RegisterEvents(1)}; inline const Uint32 FLAG_CLEARED{ SDL_RegisterEvents(1)}; inline const Uint32 GAME_WON{ SDL_RegisterEvents(1)}; inline const Uint32 GAME_LOST{ SDL_RegisterEvents(1)}; inline const Uint32 NEW_GAME{ SDL_RegisterEvents(1)}; } namespace Config{ // Game Settings inline const std::string GAME_NAME{ "Minesweeper"}; inline constexpr int BOMB_COUNT{6}; inline constexpr int GRID_COLUMNS{8}; inline constexpr int GRID_ROWS{4}; static_assert( BOMB_COUNT < GRID_COLUMNS * GRID_ROWS, "Cannot have more bombs than cells" ); // Size and Positioning inline constexpr int PADDING{5}; inline constexpr int CELL_SIZE{50}; inline constexpr int FOOTER_HEIGHT{60}; inline constexpr int FLAG_COUNTER_WIDTH{100}; inline constexpr int GRID_HEIGHT{ CELL_SIZE * GRID_ROWS + PADDING * (GRID_ROWS - 1) }; inline constexpr int GRID_WIDTH{ CELL_SIZE * GRID_COLUMNS + PADDING * (GRID_COLUMNS - 1)}; 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{ 170, 170, 170, 255}; inline constexpr SDL_Color BUTTON_COLOR{ 200, 200, 200, 255}; inline constexpr SDL_Color BUTTON_HOVER_COLOR{ 220, 220, 220, 255}; inline constexpr SDL_Color BUTTON_CLEARED_COLOR{ 240, 240, 240, 255}; inline constexpr SDL_Color BUTTON_SUCCESS_COLOR{ 210, 235, 210, 255}; inline constexpr SDL_Color BUTTON_FAILURE_COLOR{ 235, 210, 210, 255}; inline constexpr SDL_Color FLAG_COUNTER_COLOR{ 80, 80, 80, 255}; // Text color based on number of surrounding bombs inline const std::vector TEXT_COLORS{ /* 0 */ {0, 0, 0, 255}, // Unused /* 1 */ {0, 1, 249, 255}, /* 2 */ {1, 126, 1, 255}, /* 3 */ {250, 1, 2, 255}, /* 4 */ {1, 0, 128, 255}, /* 5 */ {129, 1, 0, 255}, /* 6 */ {0, 128, 128, 255}, /* 7 */ {0, 0, 0, 255}, /* 8 */ {128, 128, 128, 255} }; // Asset Paths inline const std::string BASE_PATH{ SDL_GetBasePath()}; inline const std::string BOMB_IMAGE{ BASE_PATH + "Bomb.png"}; inline const std::string FLAG_IMAGE{ BASE_PATH + "Flag.png"}; inline const std::string FONT{ BASE_PATH + "Roboto-Medium.ttf"}; } namespace Utils{ #ifdef SHOW_DEBUG_HELPERS inline void CheckSDLError( const std::string& Msg){ const char* error = SDL_GetError(); if (*error != '\0') { std::cerr << Msg << " Error: " << error << '\n'; SDL_ClearError(); } } #endif } ``` ```c++ #pragma once #include #include "Globals.h" namespace Engine{ class Window { public: Window(){ SDLWindow = SDL_CreateWindow( Config::GAME_NAME.c_str(), Config::WINDOW_WIDTH, Config::WINDOW_HEIGHT, 0 ); } void Render(){ const auto* Fmt = SDL_GetPixelFormatDetails( GetSurface()->format ); SDL_FillSurfaceRect( GetSurface(), nullptr, SDL_MapRGB(Fmt, nullptr, Config::BACKGROUND_COLOR.r, Config::BACKGROUND_COLOR.g, Config::BACKGROUND_COLOR.b) ); } void Update(){ SDL_UpdateWindowSurface(SDLWindow); } SDL_Surface* GetSurface() const { return SDL_GetWindowSurface(SDLWindow); } ~Window() { if (SDLWindow && SDL_WasInit(SDL_INIT_VIDEO)) { SDL_DestroyWindow(SDLWindow); } } Window(const Window&) = delete; Window& operator=(const Window&) = delete; private: SDL_Window* SDLWindow{nullptr}; }; } ``` ```c++ #pragma once #include namespace Engine{ class Rectangle { public: Rectangle( int x, int y, int w, int h, SDL_Color Color = {0, 0, 0, 255}) : Rect{x, y, w, h}, Color{Color}{} virtual void Render(SDL_Surface* Surface){ const auto* Fmt = SDL_GetPixelFormatDetails( Surface->format ); SDL_FillSurfaceRect( Surface, &Rect, SDL_MapRGB( Fmt, nullptr, Color.r, Color.g, Color.b ) ); } void SetColor(SDL_Color C){ Color = C; } bool IsWithinBounds(int x, int y) const{ if (x < Rect.x) return false; if (x > Rect.x + Rect.w) return false; if (y < Rect.y) return false; if (y > Rect.y + Rect.h) return false; return true; } const SDL_Rect* GetRect() const { return &Rect; } virtual ~Rectangle() = default; private: SDL_Rect Rect{0, 0, 0, 0}; SDL_Color Color{0, 0, 0, 0}; }; } ``` ```c++ #pragma once #include #include "Globals.h" #include "Engine/Rectangle.h" namespace Engine{ class Button : public Rectangle { public: Button(int x, int y, int w, int h) : Rectangle{x, y, w, h}{ SetColor(Config::BUTTON_COLOR); } virtual void HandleEvent(const SDL_Event& E){ if (isDisabled) return; if (E.type == SDL_EVENT_MOUSE_MOTION) { HandleMouseMotion(E.motion); } else if (E.type == SDL_EVENT_MOUSE_BUTTON_DOWN) { if (IsWithinBounds( (int)E.button.x, (int)E.button.y) ) { E.button.button == SDL_BUTTON_LEFT ? HandleLeftClick() : HandleRightClick(); } } } void SetIsDisabled(bool NewValue){ isDisabled = NewValue; } protected: virtual void HandleLeftClick(){} virtual void HandleRightClick(){} virtual void HandleMouseMotion( const SDL_MouseMotionEvent& E){ if (IsWithinBounds((int)E.x, (int)E.y)) { SetColor(Config::BUTTON_HOVER_COLOR); } else { SetColor(Config::BUTTON_COLOR); } } private: bool isDisabled{false}; }; } ``` ```c++ #pragma once #include #include #include #include "Globals.h" namespace Engine{ class Image { public: Image( int x, int y, int w, int h, const std::string& Filename, int Padding = 12 ): Destination{ x + Padding/2, y + Padding/2, w-Padding, h-Padding }{ ImageSurface = IMG_Load(Filename.c_str()); #ifdef SHOW_DEBUG_HELPERS Utils::CheckSDLError("IMG_Load"); #endif } void Render(SDL_Surface* Surface) { SDL_BlitSurfaceScaled( ImageSurface, nullptr, Surface, &Destination, SDL_SCALEMODE_LINEAR ); } ~Image() { if (ImageSurface) { SDL_DestroySurface(ImageSurface); } } Image(const Image&) = delete; Image& operator=(const Image&) = delete; private: SDL_Surface* ImageSurface{nullptr}; SDL_Rect Destination{0, 0, 0, 0}; }; } ``` ```c++ #pragma once #include #include #include #include "Globals.h" namespace Engine{ class Text { public: Text( int x, int y, int w, int h, const std::string& Content, SDL_Color Color = {0, 0, 0, 255}, float FontSize = 30.0f ) : DestinationRect{x, y, w, h}, Color{Color} { Font = TTF_OpenFont( Config::FONT.c_str(), FontSize); #ifdef SHOW_DEBUG_HELPERS Utils::CheckSDLError("TTF_OpenFont"); #endif SetText(Content); } void SetText(const std::string& Text){ SetText(Text, Color); } void SetText(const std::string& Text, SDL_Color NewColor){ if (TextSurface) { SDL_DestroySurface(TextSurface); } Color = NewColor; TextSurface = TTF_RenderText_Blended( Font, Text.c_str(), 0, Color ); auto [x, y, w, h] = DestinationRect; // Horizontally centering const int WidthDifference{w - TextSurface->w}; const int LeftOffset{WidthDifference / 2}; // Vertically centering const int HeightDifference{h - TextSurface->h}; const int TopOffset{HeightDifference / 2}; TextPosition = { x + LeftOffset, y + TopOffset, TextSurface->w, TextSurface->h }; } void Render(SDL_Surface* Surface) { SDL_BlitSurface( TextSurface, nullptr, Surface, &TextPosition ); } ~Text() { if (TTF_WasInit()) { TTF_CloseFont(Font); } if (TextSurface) { SDL_DestroySurface(TextSurface); } } Text(const Text&) = delete; Text& operator=(const Text&) = delete; private: SDL_Surface* TextSurface{nullptr}; TTF_Font* Font{nullptr}; SDL_Rect DestinationRect{0, 0, 0, 0}; SDL_Rect TextPosition{0, 0, 0, 0}; SDL_Color Color{0, 0, 0, 255}; }; } ``` ```c++ #pragma once #include namespace Engine::Random{ inline std::random_device SEEDER; inline std::mt19937 ENGINE{SEEDER()}; inline size_t Int(size_t Min, size_t Max){ std::uniform_int_distribution Get{Min, Max}; return Get(ENGINE); } } ``` ```c++ #pragma once #include #include "Globals.h" #include "Minesweeper/Grid.h" #include "Minesweeper/NewGameButton.h" #include "Minesweeper/FlagCounter.h" class MinesweeperUI { public: void Render(SDL_Surface* Surface){ Grid.Render(Surface); Button.Render(Surface); Counter.Render(Surface); } void HandleEvent(const SDL_Event& E){ Grid.HandleEvent(E); Button.HandleEvent(E); Counter.HandleEvent(E); }; private: MinesweeperGrid Grid{ Config::PADDING, Config::PADDING }; NewGameButton Button{ Config::PADDING, Config::GRID_HEIGHT + Config::PADDING * 2, Config::WINDOW_WIDTH - Config::PADDING * 3 - Config::FLAG_COUNTER_WIDTH, Config::FOOTER_HEIGHT - Config::PADDING }; FlagCounter Counter{ Config::WINDOW_WIDTH - Config::PADDING - Config::FLAG_COUNTER_WIDTH, Config::GRID_HEIGHT + Config::PADDING * 2, Config::FLAG_COUNTER_WIDTH, Config::FOOTER_HEIGHT - Config::PADDING }; }; ``` ```c++ #pragma once #include #include #include "Globals.h" #include "Minesweeper/Cell.h" #include "Engine/Random.h" class MinesweeperGrid { public: MinesweeperGrid(int x, int y){ using namespace Config; Children.reserve(GRID_COLUMNS * GRID_ROWS); for (int Col{1}; Col <= GRID_COLUMNS; ++Col) { for (int Row{1}; Row <= GRID_ROWS; ++Row) { constexpr int Spacing{ CELL_SIZE + PADDING}; Children.emplace_back( x + (Spacing) * (Col - 1), y + (Spacing) * (Row - 1), CELL_SIZE, CELL_SIZE, Row, Col ); } } PlaceBombs(); } void Render(SDL_Surface* Surface){ for (auto& Child : Children) { Child.Render(Surface); } } void HandleEvent(const SDL_Event& E){ if (E.type == UserEvents::CELL_CLEARED) { HandleCellCleared(E.user); } else if (E.type == UserEvents::NEW_GAME) { for (auto& Child : Children) { Child.Reset(); } PlaceBombs(); } for (auto& Child : Children) { Child.HandleEvent(E); } } private: void HandleCellCleared(const SDL_UserEvent& E){ auto* Cell{ static_cast(E.data1) }; if (Cell->GetHasBomb()) { SDL_Event Event{}; Event.type = UserEvents::GAME_LOST; SDL_PushEvent(&Event); } else { --CellsToClear; if (CellsToClear == 0) { SDL_Event Event{}; Event.type = UserEvents::GAME_WON; SDL_PushEvent(&Event); } } } void PlaceBombs(){ int BombsToPlace{Config::BOMB_COUNT}; CellsToClear = Config::GRID_COLUMNS * Config::GRID_ROWS - Config::BOMB_COUNT; while (BombsToPlace > 0) { const size_t RandomIndex{ Engine::Random::Int( 0, Children.size() - 1 )}; if (Children[RandomIndex].PlaceBomb()) { --BombsToPlace; } } } std::vector Children; int CellsToClear{0}; }; ``` ```c++ #pragma once #include #include #include "Engine/Button.h" #include "Engine/Image.h" #include "Engine/Text.h" class MinesweeperCell : public Engine::Button { public: MinesweeperCell( int X, int Y, int W, int H, int Row, int Col ); void HandleEvent(const SDL_Event& E) override; void Render(SDL_Surface* Surface) override; void Reset(); bool PlaceBomb(); [[nodiscard]] bool GetHasBomb() const{ return hasBomb; } [[nodiscard]] int GetRow() const{ return Row; } [[nodiscard]] int GetCol() const{ return Col; } protected: void HandleLeftClick() override; void HandleRightClick() override; private: void ClearCell(); void ReportEvent(Uint32 EventType); void HandleCellCleared( const SDL_UserEvent& E); void HandleBombPlaced(const SDL_UserEvent& E); bool isAdjacent(const MinesweeperCell* Other) const; int AdjacentBombs{0}; int Row; int Col; bool hasBomb{false}; bool hasFlag{false}; bool isCleared{false}; std::unique_ptr FlagImage; std::unique_ptr BombImage; std::unique_ptr Text; }; ``` ```c++ #include #include #include #include "Minesweeper/Cell.h" #include "Globals.h" MinesweeperCell::MinesweeperCell( int x, int y, int w, int h, int Row, int Col) : Button{x, y, w, h}, Row{Row}, Col{Col} { FlagImage = std::make_unique( x, y, w, h, Config::FLAG_IMAGE ); BombImage = std::make_unique( x, y, w, h, Config::BOMB_IMAGE ); Text = std::make_unique( x, y, w, h, std::to_string(AdjacentBombs), Config::TEXT_COLORS[AdjacentBombs] ); }; void MinesweeperCell::HandleEvent( const SDL_Event& E){ if (E.type == UserEvents::CELL_CLEARED) { HandleCellCleared(E.user); } else if (E.type == UserEvents::BOMB_PLACED) { HandleBombPlaced(E.user); } else if (E.type == UserEvents::GAME_WON) { if (hasBomb) { hasFlag = true; SetColor(Config::BUTTON_SUCCESS_COLOR); } SetIsDisabled(true); } else if (E.type == UserEvents::GAME_LOST) { if (hasBomb) { isCleared = true; SetColor(Config::BUTTON_FAILURE_COLOR); } SetIsDisabled(true); } Button::HandleEvent(E); } void MinesweeperCell::Render( SDL_Surface* Surface){ Button::Render(Surface); if (hasFlag) { FlagImage->Render(Surface); } else if (isCleared && hasBomb) { BombImage->Render(Surface); } else if (isCleared && AdjacentBombs > 0) { Text->Render(Surface); } #ifdef SHOW_DEBUG_HELPERS else if (hasBomb) { BombImage->Render(Surface); } #endif } void MinesweeperCell::Reset(){ isCleared = false; hasFlag = false; hasBomb = false; AdjacentBombs = 0; SetIsDisabled(false); SetColor(Config::BUTTON_COLOR); Text->SetText( std::to_string(AdjacentBombs), Config::TEXT_COLORS[AdjacentBombs] ); } bool MinesweeperCell::PlaceBomb(){ if (hasBomb) return false; hasBomb = true; ReportEvent(UserEvents::BOMB_PLACED); return true; } void MinesweeperCell::ClearCell(){ if (isCleared) return; isCleared = true; SetIsDisabled(true); SetColor(Config::BUTTON_CLEARED_COLOR); ReportEvent(UserEvents::CELL_CLEARED); } void MinesweeperCell::ReportEvent( Uint32 EventType){ SDL_Event event{}; event.type = EventType; event.user.data1 = this; SDL_PushEvent(&event); } void MinesweeperCell::HandleCellCleared( const SDL_UserEvent& E){ const auto* Cell{ static_cast(E.data1) }; if (Cell->GetHasBomb()) return; if (isAdjacent(Cell) && Cell->AdjacentBombs == 0) { ClearCell(); } } void MinesweeperCell::HandleBombPlaced( const SDL_UserEvent& E){ const auto* Cell{ static_cast(E.data1) }; if (isAdjacent(Cell)) { ++AdjacentBombs; Text->SetText(std::to_string(AdjacentBombs), Config::TEXT_COLORS[ AdjacentBombs]); } } bool MinesweeperCell::isAdjacent( const MinesweeperCell* Other) const{ return !(Other == this) && std::abs(Other->GetRow() - Row) <= 1 && std::abs(Other->GetCol() - Col) <= 1; } void MinesweeperCell::HandleRightClick(){ if (hasFlag) { ReportEvent(UserEvents::FLAG_CLEARED); hasFlag = false; } else { ReportEvent(UserEvents::FLAG_PLACED); hasFlag = true; } } void MinesweeperCell::HandleLeftClick(){ if (!hasFlag) { ClearCell(); } } ``` ```c++ #pragma once #include #include "Globals.h" #include "Engine/Button.h" #include "Engine/Text.h" class NewGameButton : public Engine::Button { public: NewGameButton(int x, int y, int w, int h) : Button{x, y, w, h}, Text{x, y, w, h, "NEW GAME", {}, 20.0f}{} void Render(SDL_Surface* Surface) override{ Button::Render(Surface); Text.Render(Surface); } protected: void HandleLeftClick() override{ SDL_Event E{}; E.type = UserEvents::NEW_GAME; SDL_PushEvent(&E); } private: Engine::Text Text; }; ``` ```c++ #pragma once #include #include #include #include "Globals.h" #include "Engine/Rectangle.h" #include "Engine/Text.h" #include "Engine/Image.h" class FlagCounter : public Engine::Rectangle { public: FlagCounter(int x, int y, int w, int h) : Rectangle{ x, y, w, h, Config::FLAG_COUNTER_COLOR}, Image{ std::make_unique( x, y, Config::FOOTER_HEIGHT - Config::PADDING, Config::FOOTER_HEIGHT - Config::PADDING, Config::FLAG_IMAGE, 24 )}, Text{ std::make_unique( x + Config::FOOTER_HEIGHT, y, w - Config::FOOTER_HEIGHT - 24, h, std::to_string(Config::BOMB_COUNT), SDL_Color{255, 255, 255, 255}, 20.0f )} {} void Render(SDL_Surface* Surface) override{ Rectangle::Render(Surface); Text->Render(Surface); Image->Render(Surface); } void HandleEvent(const SDL_Event& E){ if (E.type == UserEvents::FLAG_PLACED) { --FlagsAvailable; } else if (E.type == UserEvents::FLAG_CLEARED) { ++FlagsAvailable; } else if (E.type == UserEvents::GAME_WON) { FlagsAvailable = 0; } else if (E.type == UserEvents::NEW_GAME) { FlagsAvailable = Config::BOMB_COUNT; } else { return; } Text->SetText( std::to_string(FlagsAvailable) ); } private: std::unique_ptr Image; std::unique_ptr Text; int FlagsAvailable{Config::BOMB_COUNT}; }; ``` ## Improvement Ideas To make the most of our learning, it can be helpful to go back to our project and change some things around, reworking how things are designed, or even completely rebuilding it. This self-directed learning helps solidify the concepts we've covered, and makes it easier to apply them to new projects that won't have as much guidance. Some ideas on how the project could be reworked are below, but don't worry if you don't feel confident enough to research and implement them independently. We'll walk through some of these mechanics step-by-step in future chapters. ### Refactoring Something we should constantly be reviewing is areas of our code that seem quite complex and difficult to follow. For example, our program has a very simple visual layout, with a grid at the top and a new game button and flag counter side by side at the bottom. However, the code to establish such a simple layout is already difficult to write and follow: ```c++ // Minesweeper/UI.h class MinesweeperUI { private: MinesweeperGrid Grid{ Config::PADDING, Config::PADDING }; NewGameButton Button{ Config::PADDING, Config::GRID_HEIGHT + Config::PADDING * 2, Config::WINDOW_WIDTH - Config::PADDING * 3 - Config::FLAG_COUNTER_WIDTH, Config::FOOTER_HEIGHT - Config::PADDING }; FlagCounter Counter{ Config::WINDOW_WIDTH - Config::PADDING - Config::FLAG_COUNTER_WIDTH, Config::GRID_HEIGHT + Config::PADDING * 2, Config::FLAG_COUNTER_WIDTH, Config::FOOTER_HEIGHT - Config::PADDING }; }; ``` Laying objects out in columns and rows is a recurring problem, so we could consider introducing generic classes like `Column` and `Row` that take care of that for us. These classes would accept some UI elements in their constructor and then take on the responsibility of rendering them in the correct position. Hypothetical `Column` and `Row` types might allow themselves to be used like this, for example: ```c++ // ... #include "Engine/Column.h" #include "Engine/Row.h" class MinesweeperUI { public: void Render(SDL_Surface* Surface){ Layout.Render(Surface); } // ... private: MinesweeperGrid Grid; NewGameButton Button; FlagCounter Counter; Column Layout{ Grid, Row{ Button, Counter } }; }; ``` ### Gameplay Improvements Currently, our game places bombs before the user clears the first cell. This can cause unfair outcomes, such as the first cell containing a bomb. Many implementations of Minesweeper do not choose bomb positions until **after** the user clicks their first cell. This allows them to guarantee the cell is safe so the player doesn't lose immediately. They may also choose to place bombs further away from this starting point. For example, we can ensure the adjacent cells to where the player starts have no bombs, either. This results in the first click clearing a large area of the grid, allowing the player to proceed strategically and reducing the probability they'll need to make guesses. ### Pooling Surface Data Currently, the cells in our grid are generating surfaces unnecessarily. For example, if our settings specify the grid has 32 cells, then 32 bomb images are loaded, and 32 identical surfaces are held in memory. Flag and text surfaces are similarly wasteful. Every cell that shows a `3` image, for example, is generating its own surface, which is identical to every other `3`. Additionally, if a cell ultimately has `3` adjacent bombs, the bomb placement algorithm has it generate `1` and `2` surfaces which it discards before the player ever sees them. These suboptimal approaches are fine for a simple game running on modern hardware, but we should consider reworking it anyway as a learning opportunity. We'd want to pool these common surfaces into a shared location where our cells can access and share them. Don't worry if you're not sure how you would set this up now. We revisit asset management multiple times throughout the course, and future projects will use increasingly more sophisticated techniques. ### Difficulty Modes Most Minesweeper games allow players to choose their preferred difficulty - typically, easy, medium or hard. Harder difficulties increase the size of the grid, and increase the number of bombs within the grid. It would involve a lot of changes to set our game up to support this. However, it wouldn't require any new concepts - we know everything we need to set this up. The `SDL_SetWindowSize()` function ([official documentation](https://wiki.libsdl.org/SDL3/SDL_SetWindowSize)) let's us programmatically resize the window, which can be useful if our grid size changes based on the difficulty setting. ## Summary We've successfully added flag placement functionality, complete with visual feedback and a counter in the UI. These final features round out the gameplay, allowing players to mark potential mine locations and strategize their moves. With all elements now in place, you have a fully-featured Minesweeper game. Well done on finishing the project!

Placing Flags

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation