(Old) MineSwee++ 2

» Download «

You will download two installation-free standalone program files (one game, one solver) along with a DLL. If MineSwee++ 2 fails to initialize properly or can not find mscoree.dll, download .Net Framework 2.0 Redistributable Package here.

System requirements

» An Intel Pentium III or AMD Athlon XP, or any other x86 CPU supporting SSE
» Recommended: Intel Pentium D 9xx or AMD Athlon 64 X2.

Algorithm

MineSwee++ 2 is close-source. However, I decide to make the algorithm of C[o]re public. The following pseudo-code is used since MineSwee++ 2 Release Candidate V (2.1.503).

GetGridWithBestProbability(board) returns (row, col)
board: the board being played
row: the row index of the grid to open
col: the column index of the grid to open
begin
   initialize board_sum with all 0
   initialize board_no_mines_around_sum with all 0
   num_mines ← number of mines flagged in board
   num_mines_left ← 51 - num_mines
   num_matched_board ← 0
   while num_matched_board is not large enough and time is not up do
   begin
      board2 ← generate a board with num_mines_left 1's randomly spread in suited places 
                                     and (256 - num_mines_left) 0's in other places
      if ((1's of board2) and (mines of board)) matches conditions of board then
      begin
         add board2 to board_sum
         for each corresponding grid in board, grid2 in board2,
                                gridnma in board_no_mines_around do
         begin
             if total number of mines around (grid and grid2) = 0 then
             begin
                gridnma ← 1
             end
             else
             begin
                gridnma ← 0
             end
         end
         add board_no_mines_around to board_no_mines_around_sum
         num_matched_board ← num_matched_board + 1
      end
   end
   if num_matched_board = 0 then
   begin
      return (0, 0)
   end
   best_grid_row ← 0
   best_grid_col ← 0
   best_grid_probability ← 0
   best_grid_probability_no_mines_around ← 0
   for r ← 1 to 16 do
   begin
      for c ← 1 to 16 do
      begin
         if board_sum[r][c] ≥ best_grid_probability then
         begin
            if board_sum[r][c] - best_grid_probability > num_matched_board × 0.03
               or (board_no_mines_around_sum[r][c] ≤ best_grid_probability_no_mines_around
                   and neither r nor c is margin) then
            begin
               best_grid_row ← r
               best_grid_col ← c
               best_grid_probability ← board_sum[r][c]
               best_grid_probability_no_mines_around ← board_no_mines_around_sum[r][c]
            end
         end
      end
   end
   return (best_grid_row, best_grid_col)
end

Frequently Asked Questions

Q: May I use C[o]re.dll in my own program?

A: Yes. Of course, you have to address this usage in your program and on your program website. C[o]re.dll is a 32-bit DLL. Following is some information you may find useful.

• The function is declared as following in Visual C++ 2005:
  

  void __stdcall DetermineGrid2(/*    in   */ char* strMineBoard,
                                /*   out   */ float* probabilityMine,
                                /*   out   */ float* probabilityZeroMineAround,
                                /*   out   */ uint* numValidGen,
                                /*    in   */ uint numThread,
                                /*    in   */ uint minValidGen,
                                /*    in   */ uint timeCalculationMS)

• strMineboard point to a 256 chars 1D array, transformed in the row-major fashion from the 2D board. An unopened grid is denoted by '-', an flagged-as-mine grid is denoted by '+', and an otherwise opened grid is denoted by '0' to '8'. The array does not need to be null-terminated.
• probabilityMine and probabilityZeroMineAround point to 256 floats 1D arrays, to be correlated with a 2D board in the row-major fashion. Each element of probabilityMine array stores the probability to contain a mine for the corresponding grid, while each element of probabilityZeroMineAround array stores the probability that the corresponding grid is an expander (i.e. there is no mine around that grid). The space of the arrays has to be allocated by the caller and is advised to be initialized as all zeros. The probabilities range from 0.0 to 1.0, whereas -1.0 specifies the probability is unavailable.
• numValidGen stores the number of valid boards C[o]re actually generates (see Algorithm section for more information). The space of the variable pointed has to be allocated by the caller.
• C[o]re always tries a pass of shortcut evaluation to search whether grids definitely to contain mines exist. If so, only the corresponding elements for those grids in probabilityMine will be set 1.0 and the rest -1.0; all elements in probabilityZeroMineAround will be set -1.0; the content of the variable pointed by numValidGen will be undefined.
• numThread has a max of 32.
• minValidGen stores the minimum number of valid boards C[o]re should generate before the timespan specified by timeCalculationMS is up.
• timeCalculationMS is in milliseconds.
• The function does not do any exception handling and there are no special values to make the caller aware of any error. Passing NULL in pointers may crash the DLL.

Q: How do I use the Solver?

A: Just input the character in the corresponding grids and click "Solve". The characters accepted are: - for an opened grid, + for a flagged-as-mine grid and 0 to 8 for a grid that is opened with a number shown (if no number is shown, then it's a 0). The solver will calculate the probabilities of the grids and display probability information.