Write python code to generate a dataset which will solve minesweeper. Each step of…
- User
Write python code to generate a dataset which will solve minesweeper. Each step of solving should be done and then send the state of the board again
- Assistant
Sure! Below is a Python script that generates a Minesweeper dataset by solving the game step-by-step. At each step, it records the state of the board. This dataset can be useful for training machine learning models or analyzing the solving process.
Overview
- Board Generation: Create a Minesweeper board with a specified size and number of mines.
- Solver: Implement a basic Minesweeper solver that uses deterministic rules to uncover cells and mark mines.
- Dataset Recording: After each action (uncovering a cell or marking a mine), record the current state of the board.
- Output: Save the dataset as a sequence of board states, which can later be used for analysis or training.
Implementation
import numpy as np import random import copy # Constants to represent cell states HIDDEN = -1 # Cell is hidden MINE = -2 # Cell is a mine FLAG = -3 # Cell is flagged as mine class MinesweeperBoard: def __init__(self, rows, cols, num_mines): self.rows = rows self.cols = cols self.num_mines = num_mines self.board = np.zeros((rows, cols), dtype=int) # Internal board with mine positions and numbers self.visible = np.full((rows, cols), HIDDEN, dtype=int) # Player's view of the board self.mines_set = False def place_mines(self, first_move): """ Place mines on the board ensuring that the first move is not a mine. """ all_cells = [(r, c) for r in range(self.rows) for c in range(self.cols)] all_cells.remove(first_move) mines = random.sample(all_cells, self.num_mines) for (r, c) in mines: self.board[r][c] = MINE # Now calculate the numbers for each cell for r in range(self.rows): for c in range(self.cols): if self.board[r][c] == MINE: continue # Count neighboring mines count = 0 for dr in [-1, 0, 1]: for dc in [-1, 0, 1]: if dr == 0 and dc == 0: continue nr, nc = r + dr, c + dc if 0 <= nr < self.rows and 0 <= nc < self.cols: if self.board[nr][nc] == MINE: count += 1 self.board[r][c] = count self.mines_set = True def uncover(self, cell): """ Uncover a cell. If it's the first move, place mines avoiding this cell. Returns False if a mine is uncovered, True otherwise. """ r, c = cell if not self.mines_set: self.place_mines(cell) if self.board[r][c] == MINE: self.visible[r][c] = MINE return False # Hit a mine self._reveal_recursive(r, c) return True def _reveal_recursive(self, r, c): """ Recursively reveal cells using flood fill for cells with 0 neighboring mines. """ if self.visible[r][c] != HIDDEN: return self.visible[r][c] = self.board[r][c] if self.board[r][c] == 0: for dr in [-1, 0, 1]: for dc in [-1, 0, 1]: nr, nc = r + dr, c + dc if dr == 0 and dc == 0: continue if 0 <= nr < self.rows and 0 <= nc < self.cols: self._reveal_recursive(nr, nc) def flag(self, cell): """ Flag a cell as a mine. """ r, c = cell if self.visible[r][c] == HIDDEN: self.visible[r][c] = FLAG def is_solved(self): """ Check if the board is solved: all non-mine cells are uncovered. """ for r in range(self.rows): for c in range(self.cols): if self.board[r][c] != MINE and self.visible[r][c] == HIDDEN: return False return True def print_visible(self): """ Print the current visible state of the board. """ for r in range(self.rows): row = "" for c in range(self.cols): val = self.visible[r][c] if val == HIDDEN: row += "■ " elif val == FLAG: row += "⚑ " elif val == MINE: row += "* " else: row += f"{val} " print(row) print() class MinesweeperSolver: def __init__(self, board: MinesweeperBoard): self.board = board self.dataset = [] def solve(self): """ Solve the Minesweeper board step-by-step and record each state. """ # Initial step: choose a random cell to uncover initial_cell = (random.randint(0, self.board.rows -1), random.randint(0, self.board.cols -1)) success = self.board.uncover(initial_cell) self.record_state() if not success: print("Hit a mine on the first move! Restarting...") return # Repeat until solved or stuck progress = True while not self.board.is_solved() and progress: progress = False # Apply deterministic rules for r in range(self.board.rows): for c in range(self.board.cols): if self.board.visible[r][c] > 0: # Count hidden and flagged neighbors hidden = [] flagged = 0 for dr in [-1, 0, 1]: for dc in [-1, 0, 1]: nr, nc = r + dr, c + dc if dr == 0 and dc == 0: continue if 0 <= nr < self.board.rows and 0 <= nc < self.board.cols: if self.board.visible[nr][nc] == HIDDEN: hidden.append((nr, nc)) elif self.board.visible[nr][nc] == FLAG: flagged += 1 # If number equals flagged neighbors, safe to uncover hidden if flagged == self.board.visible[r][c]: for cell in hidden: success = self.board.uncover(cell) self.record_state() progress = True if not success: print("Hit a mine!") return # If number equals flagged + hidden, flag all hidden elif self.board.visible[r][c] == flagged + len(hidden): for cell in hidden: self.board.flag(cell) self.record_state() progress = True # If no progress, make a guess (optional) # For simplicity, we'll stop here if self.board.is_solved(): print("Board solved successfully!") else: print("Could not solve the board deterministically.") def record_state(self): """ Record the current visible state of the board. Deep copy to ensure state is preserved. """ self.dataset.append(copy.deepcopy(self.board.visible)) def get_dataset(self): return self.dataset def generate_minesweeper_dataset(rows=9, cols=9, num_mines=10, num_games=100): """ Generate a dataset by solving multiple Minesweeper games. Each game will record the sequence of board states as it is being solved. """ all_games = [] for game_num in range(num_games): board = MinesweeperBoard(rows, cols, num_mines) solver = MinesweeperSolver(board) solver.solve() game_dataset = solver.get_dataset() all_games.append(game_dataset) print(f"Game {game_num +1} completed with {len(game_dataset)} steps.") return all_games if __name__ == "__main__": # Example usage: generate dataset of 5 games dataset = generate_minesweeper_dataset(rows=9, cols=9, num_mines=10, num_games=5) # Example: Print the first game steps for step, board_state in enumerate(dataset[0]): print(f"Step {step +1}:") for row in board_state: row_str = "" for cell in row: if cell == HIDDEN: row_str += "■ " elif cell == FLAG: row_str += "⚑ " elif cell == MINE: row_str += "* " else: row_str += f"{cell} " print(row_str) print()Explanation
-
Constants: Defined constants to represent the state of each cell (
HIDDEN,MINE,FLAG). -
MinesweeperBoardClass:- Initializes the board with given dimensions and mine count.
place_mines: Randomly places mines on the board, ensuring the first move is not a mine. It also calculates the number of adjacent mines for each cell.uncover: Uncovers a cell. If it's the first move, it places mines first. If a mine is uncovered, it returnsFalse. Otherwise, it reveals the cell and recursively reveals neighboring cells if the cell has zero adjacent mines.flag: Flags a cell as a mine.is_solved: Checks if the game is solved (all non-mine cells are uncovered).print_visible: Prints the current visible state of the board for debugging or visualization.
-
MinesweeperSolverClass:- Takes a
MinesweeperBoardinstance and attempts to solve it using deterministic rules:- Uncovering: If the number on a revealed cell equals the number of flagged neighboring cells, it safely uncovers the remaining hidden neighbors.
- Flagging: If the number on a revealed cell equals the sum of flagged and hidden neighboring cells, it flags all hidden neighbors as mines.
solve: Executes the solving process step-by-step, recording the state after each action.record_state: Saves the current state of the board to the dataset.
- Takes a
-
generate_minesweeper_datasetFunction:- Generates multiple Minesweeper games.
- For each game, it creates a new board and solver, solves the game, and records the sequence of board states.
- Returns a list containing datasets for all games.
-
Main Execution:
- Generates a dataset of 5 Minesweeper games on a 9x9 board with 10 mines each.
- Prints the sequence of board states for the first game as an example.
Customization
-
Board Size and Mine Count: You can adjust the
rows,cols, andnum_minesparameters in thegenerate_minesweeper_datasetfunction to create different board sizes and difficulty levels. -
Number of Games: Change the
num_gamesparameter to generate a larger or smaller dataset. -
Solving Strategy: The current solver uses basic deterministic rules. For more complex solving (like probabilistic guessing), you can extend the
MinesweeperSolverclass.
Notes
-
First Move Safety: The solver ensures that the first move is always safe by placing mines after the first cell is chosen.
-
Deterministic Solving: The solver stops if it cannot make progress using deterministic rules. Implementing guessing or more advanced strategies can increase the number of solvable boards.
-
Dataset Structure: The dataset is a list of games, where each game is a list of board states (2D arrays). Each board state represents the player's view after each move.
-
Visualization: The
print_visiblemethod and the example in the__main__section help visualize the solving process.
Example Output
Running the script will generate output similar to the following for each game:
Game 1 completed with 10 steps. Game 2 completed with 8 steps. ...And for the first game, it will print each step:
Step 1: ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ Step 2: 1 ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ... ...This provides a step-by-step record of how the board was solved, which can be used as a dataset for further analysis or training purposes.