Implementing a Minesweeper Hint System

1#include <algorithm>
2#include <iostream>
3#include <random>
4#include <vector>
5
6class MinesweeperCell {
7public:
8  bool hasBomb{false};
9  bool isRevealed{false};
10  int adjacentBombs{0};
11};
12
13class MinesweeperGrid {
14public:
15  MinesweeperGrid(int rows, int cols,
16                  int bombs) :
17      rows{rows},
18      cols{cols}, bombCount{bombs},
19      grid(rows,
20           std::vector<MinesweeperCell>(cols)) {
21    placeBombs();
22    calculateAdjacentBombs();
23  }
24
25  bool revealCell(int row, int col) {
26    if (row < 0 || row >= rows || col < 0 ||
27        col >= cols)
28      return false;
29    if (grid[row][col].isRevealed) return false;
30
31    grid[row][col].isRevealed = true;
32    return !grid[row][col].hasBomb;
33  }
34
35  std::pair<int, int> getHint() {
36    std::vector<std::pair<int, int>> safeCells;
37
38    for (int i = 0; i < rows; ++i) {
39      for (int j = 0; j < cols; ++j) {
40        if (grid[i][j].isRevealed &&
41            hasUnrevealedNeighbors(i, j)) {
42          auto neighbors =
43            getSafeUnrevealedNeighbors(i, j);
44          safeCells.insert(safeCells.end(),
45                           neighbors.begin(),
46                           neighbors.end());
47        }
48      }
49    }
50
51    if (safeCells.empty())
52      return {-1, -1}; // No hint available
53
54    std::random_device rd;
55    std::mt19937 gen(rd());
56    std::uniform_int_distribution<> dis(
57      0, safeCells.size() - 1);
58    return safeCells[dis(gen)];
59  }
60
61  void printGrid() {
62    for (const auto &row : grid) {
63      for (const auto &cell : row) {
64        if (cell.isRevealed) {
65          std::cout
66            << (cell.hasBomb
67                  ? "*"
68                  : std::to_string(
69                      cell.adjacentBombs))
70            << " ";
71        } else {
72          std::cout << ". ";
73        }
74      }
75      std::cout << "\n";
76    }
77  }
78
79private:
80  int rows, cols, bombCount;
81  std::vector<std::vector<MinesweeperCell>>
82    grid;
83
84  void placeBombs() {
85    std::vector<int> cells(rows * cols);
86    std::iota(cells.begin(), cells.end(), 0);
87    std::random_device rd;
88    std::mt19937 g(rd());
89    std::shuffle(cells.begin(), cells.end(), g);
90
91    for (int i = 0; i < bombCount; ++i) {
92      int row = cells[i] / cols;
93      int col = cells[i] % cols;
94      grid[row][col].hasBomb = true;
95    }
96  }
97
98  void calculateAdjacentBombs() {
99    for (int i = 0; i < rows; ++i) {
100      for (int j = 0; j < cols; ++j) {
101        if (!grid[i][j].hasBomb) {
102          grid[i][j].adjacentBombs =
103            countAdjacentBombs(i, j);
104        }
105      }
106    }
107  }
108
109  int countAdjacentBombs(int row, int col) {
110    int count = 0;
111    for (int i = std::max(0, row - 1);
112         i <= std::min(rows - 1, row + 1);
113         ++i) {
114      for (int j = std::max(0, col - 1);
115           j <= std::min(cols - 1, col + 1);
116           ++j) {
117        if (grid[i][j].hasBomb) ++count;
118      }
119    }
120    return count;
121  }
122
123  bool hasUnrevealedNeighbors(int row,
124                              int col) {
125    for (int i = std::max(0, row - 1);
126         i <= std::min(rows - 1, row + 1);
127         ++i) {
128      for (int j = std::max(0, col - 1);
129           j <= std::min(cols - 1, col + 1);
130           ++j) {
131        if (!grid[i][j].isRevealed) return true;
132      }
133    }
134    return false;
135  }
136
137  std::vector<std::pair<int, int>>
138    getSafeUnrevealedNeighbors(int row,
139                               int col) {
140    std::vector<std::pair<int, int>>
141      safeNeighbors;
142    for (int i = std::max(0, row - 1);
143         i <= std::min(rows - 1, row + 1);
144         ++i) {
145      for (int j = std::max(0, col - 1);
146           j <= std::min(cols - 1, col + 1);
147           ++j) {
148        if (!grid[i][j].isRevealed &&
149            !grid[i][j].hasBomb) {
150          safeNeighbors.emplace_back(i, j);
151        }
152      }
153    }
154    return safeNeighbors;
155  }
156};
157
158int main() {
159  MinesweeperGrid game(8, 8, 10);
160  // Simulate some gameplay
161  game.revealCell(0, 0);
162  game.revealCell(1, 1);
163  game.printGrid();
164
165  std::cout << "\nGetting a hint...\n";
166  auto [hintRow, hintCol] = game.getHint();
167  if (hintRow != -1 && hintCol != -1) {
168    std::cout << "Hint: Try cell (" << hintRow
169              << ", " << hintCol << ")\n";
170    game.revealCell(hintRow, hintCol);
171    game.printGrid();
172  } else {
173    std::cout << "No hint available.\n";
174  }
175}