Creating the Grid

Custom Grid Shapes in Minesweeper

Can we implement a custom grid shape instead of just rectangular?

Abstract art representing computer programming

Absolutely! Implementing a custom grid shape can add a unique twist to our Minesweeper game.

While rectangular grids are traditional, we can create various shapes like hexagonal, triangular, or even completely custom layouts. Let's explore how we might implement a hexagonal grid as an example.

Hexagonal Grid Implementation

To create a hexagonal grid, we need to adjust our MinesweeperGrid and MinesweeperCell classes. Here's a basic implementation:

1#include <cmath>
2#include <vector>
3#include "Minesweeper/Cell.h"
4
5class HexCell : public MinesweeperCell {
6public:
7  HexCell(int X, int Y, int Size, int Row,
8          int Col) :
9      MinesweeperCell(X, Y, Size, Size, Row,
10                      Col) {}
11
12  void Render(SDL_Surface *Surface) override {
13    // Draw hexagon shape instead of rectangle
14    const int centerX = X + Width / 2;
15    const int centerY = Y + Height / 2;
16    const int radius = Width / 2;
17
18    std::vector<SDL_Point> points;
19    for (int i = 0; i < 6; ++i) {
20      const double angle =
21        i * M_PI / 3 - M_PI / 6;
22      points.push_back(
23        {static_cast<int>(
24           centerX + radius * std::cos(angle)),
25         static_cast<int>(centerY +
26                          radius *
27                            std::sin(angle))});
28    }
29
30    // Draw filled hexagon
31    filledPolygonRGBA(
32      Surface,
33      reinterpret_cast<const Sint16 *>(
34        &points[0].x),
35      reinterpret_cast<const Sint16 *>(
36        &points[0].y),
37      6, Color.r, Color.g, Color.b, Color.a);
38  }
39};
40
41class HexGrid {
42public:
43  HexGrid(int x, int y) {
44    using namespace Config;
45    const int hexRadius = CELL_SIZE / 2;
46    const int verticalSpacing =
47      hexRadius * 3 / 2;
48
49    for (int row = 0; row < GRID_ROWS; ++row) {
50      for (int col = 0; col < GRID_COLUMNS;
51           ++col) {
52        int xPos = x +
53          col * (hexRadius * sqrt(3)) +
54          (row % 2) * (hexRadius * sqrt(3) / 2);
55        int yPos = y + row * verticalSpacing;
56        Cells.emplace_back(xPos, yPos,
57                           CELL_SIZE, row, col);
58      }
59    }
60  }
61
62  void Render(SDL_Surface *Surface) {
63    for (auto &cell : Cells) {
64      cell.Render(Surface);
65    }
66  }
67
68  std::vector<HexCell> Cells;
69};

In this implementation:

We create a HexCell class that inherits from MinesweeperCell but overrides the Render() method to draw a hexagon instead of a rectangle.
The HexGrid class calculates the position of each hexagonal cell based on its row and column.
We use the SDL2_gfx library's filledPolygonRGBA() function to draw the hexagonal shape.

Adapting Game Logic

Implementing a custom grid shape also requires adjusting our game logic:

Neighbor calculation: In a hexagonal grid, each cell has 6 neighbors instead of 8.
Cell selection: We need to implement a method to determine which cell was clicked based on the hexagonal layout.
Grid navigation: Moving between cells (e.g., with keyboard controls) would need to account for the hexagonal pattern.

Here's a basic neighbor calculation for hexagonal grids:

1std::vector<HexCell *> GetNeighbors(int row,
2                                    int col) {
3  std::vector<HexCell *> neighbors;
4  const std::vector<std::pair<int, int>>
5    offsets = {{-1, 0},
6               {1, 0},
7               {0, -1},
8               {0, 1},
9               {row % 2 ? 1 : -1, -1},
10               {row % 2 ? 1 : -1, 1}};
11
12  for (const auto &[rowOffset, colOffset] :
13       offsets) {
14    int newRow = row + rowOffset;
15    int newCol = col + colOffset;
16    if (newRow >= 0 && newRow < GRID_ROWS &&
17        newCol >= 0 && newCol < GRID_COLUMNS) {
18      neighbors.push_back(
19        &Cells[newRow * GRID_COLUMNS + newCol]);
20    }
21  }
22  return neighbors;
23}

Implementing a custom grid shape adds complexity but can make your Minesweeper game stand out. Remember to adjust all parts of your game logic to accommodate the new shape, including mine placement, cell clearing, and win condition checking.

This Question is from the Lesson: