Engine Overview

Making Minesweeper Window Resizable

Is it possible to create a resizable window for the game?

Abstract art representing computer programming

Yes, it's definitely possible to create a resizable window for your Minesweeper game. This can enhance the player's experience by allowing them to adjust the game window to their preference. Here's how you can implement this feature:

Step 1: Modify Window Creation

First, we need to modify how we create our window. In your Window class constructor, add the SDL_WINDOW_RESIZABLE flag:

1// Engine/Window.h
2class Window {
3public:
4  Window() {
5    SDLWindow = SDL_CreateWindow(
6      Config::GAME_NAME.c_str(),
7      SDL_WINDOWPOS_UNDEFINED,
8      SDL_WINDOWPOS_UNDEFINED,
9      Config::WINDOW_WIDTH,
10      Config::WINDOW_HEIGHT,
11      SDL_WINDOW_RESIZABLE 
12    );
13  }
14  // ... (rest of the class)
15};

Step 2: Handle Window Resize Events

Now we need to handle the SDL_WINDOWEVENT_RESIZED event. Add this to your main event loop:

1// main.cpp
2while (!shouldQuit) {
3  while (SDL_PollEvent(&Event)) {
4    if (Event.type == SDL_QUIT) {
5      shouldQuit = true;
6    } else if (Event.type == SDL_WINDOWEVENT) {
7      if (Event.window.event ==
8          SDL_WINDOWEVENT_RESIZED) {
9        int NewWidth = Event.window.data1;
10        int NewHeight = Event.window.data2;
11        GameWindow.HandleResize(NewWidth,
12                                NewHeight);
13        UI.HandleResize(NewWidth, NewHeight);
14      }
15    } else {
16      UI.HandleEvent(Event);
17    }
18  }
19  // ... (rest of the game loop)
20}

Step 3: Update Window Class

Add a method to handle resizing in your Window class:

1// Engine/Window.h
2class Window {
3public:
4  // ... (existing code)
5
6  void HandleResize(int NewWidth,
7                    int NewHeight) {
8    SDL_SetWindowSize(SDLWindow, NewWidth,
9                      NewHeight);
10    SDL_FreeSurface(
11      SDL_GetWindowSurface(SDLWindow));
12  }
13
14  // ... (rest of the class)
15};

Step 4: Update UI to Handle Resizing

Now, we need to update our MinesweeperUI class to handle resizing. This involves recalculating the size and position of UI elements based on the new window size:

1// Minesweeper/UI.h
2class MinesweeperUI {
3public:
4  // ... (existing code)
5
6  void HandleResize(int NewWidth,
7                    int NewHeight) {
8    WindowWidth = NewWidth;
9    WindowHeight = NewHeight;
10    RecalculateLayout();
11  }
12
13private:
14  void RecalculateLayout() {
15    // Recalculate sizes and positions of UI
16    // elements - for example:
17    int CellSize =
18      std::min(WindowWidth / GridWidth,
19               WindowHeight / GridHeight);
20    // Update grid position and size
21    GridX =
22      (WindowWidth - (CellSize * GridWidth)) /
23      2;
24    GridY =
25      (WindowHeight - (CellSize * GridHeight)) /
26      2;
27
28    // Update other UI elements...
29  }
30
31  int WindowWidth{Config::WINDOW_WIDTH};
32  int WindowHeight{Config::WINDOW_HEIGHT};
33  int GridWidth{10}; // Example value
34  int GridHeight{10}; // Example value
35  int GridX{0};
36  int GridY{0};
37  // ... (other members)
38};

Step 5: Update Rendering

Finally, update your rendering code to use the new positions and sizes:

1void MinesweeperUI::Render(
2  SDL_Surface *Surface) {
3  // Render grid
4  for (int y = 0; y < GridHeight; ++y) {
5    for (int x = 0; x < GridWidth; ++x) {
6      int CellSize =
7        std::min(WindowWidth / GridWidth,
8                 WindowHeight / GridHeight);
9      int CellX = GridX + (x * CellSize);
10      int CellY = GridY + (y * CellSize);
11
12      // Render cell at (CellX, CellY) with size
13      // CellSize// ... (cell rendering code)
14    }
15  }
16
17  // Render other UI elements...
18}

By implementing these changes, your Minesweeper game will now have a resizable window. The game grid and UI elements will adjust their size and position based on the new window dimensions, providing a flexible and user-friendly interface.

Remember to test thoroughly to ensure all UI elements behave correctly when resizing, especially at extreme aspect ratios. You might want to implement minimum and maximum size limits to prevent the window from becoming too small or too large.

This Question is from the Lesson: