Cartographie récursive de mines sur un plateau de dragueur de mines

Question

J'ai essayé de faire un jeu de dragueur de mines où les coordonnées données pour une cellule révèlent récursivement les cellules adjacentes jusqu'à ce qu'une cellule adjacente à une bombe soit trouvée. J'ai une méthode qui donne des coordonnées x et y calcule le nombre de mines qui l'entourent.

// Counts how many mines are adjacent to a given coordinate cell if any 
void board::mineCount(int x, int y) { 

// North 
if (y > 0) { 
    if (board[x][y - 1].hasMine) { 
     board[x][y].mineCount++; 
    } 
} 

// South 
if (y < dimensions[1] - 1) { 
    if (board[x][y + 1].hasMine) { 
     board[x][y].mineCount++; 

    } 
} 

// East 
if (x < dimensions[0] - 1) { 
    if (board[x + 1][y].hasMine) { 
     board[x][y].mineCount++; 

    } 
} 

// West 
if (x > 0) { 
    if (board[x - 1][y].hasMine) { 
     board[x][y].mineCount++; 
    } 
} 

// North East 
if (x < dimensions[0] - 1 && y > 0) { 
    if (board[x + 1][y - 1].hasMine) { 
     board[x][y].mineCount++; 

    } 
} 

// North West 
if (x > 0 && y > 0) { 
    if (board[x - 1][y - 1].hasMine) { 
     board[x][y].mineCount++; 
    } 
} 

// South East 
if (x < dimensions[0] - 1 && y < dimensions[1] - 1) { 
    if (board[x + 1][y + 1].hasMine) { 
     board[x][y].mineCount++; 

    } 
} 

// South West 
if (x > 0 && y < dimensions[1] - 1) { 
    if (board[x - 1][y + 1].hasMine) { 
     board[x][y].mineCount++; 
    } 
    } 
} 

Chaque cellule est une structure qui a un champ mineCount qui obtient incrémenté de 1 à chaque fois une mine se trouve à côté de lui. J'ai de la difficulté à trouver où irait ma logique de récurrence. J'ai essayé de faire quelque chose comme:

// North 
if (y > 0) { 
    if (board[x][y - 1].hasMine) { 
     board[x][y].mineCount++; 
    } else { 
     minecount(x, y-1); 
    } 
} 

pour chaque position mais en vain. Tout pointeur serait apprécié.

Answer 1

La récursivité ne doit pas faire partie du code qui effectue le comptage de mine lui-même. Cela devrait faire partie de la fonction qui est responsable de révéler les tuiles à proximité.

int get_adjacent_mine_count(point p) { 
    int mine_count = 0; 
    for(int i = -1; i <= 1; i++) { 
     for(int j = -1; j <= 1; j++) { 
      point this_point(p.x + i, p.y + j); 
      //is_inside_board checks to see if the point's coordinates are less than 0 
      //or greater than the board size 
      if(!is_inside_board(board, this_point)) continue; 
      //We ignore the center tile 
      if(i == 0 && j == 0) continue; 

      if(board(this_point).hasMine) 
       mine_count++; 
     } 
    } 
    return mine_count; 
} 

void reveal_tiles(point p) { 
    //We shouldn't throw if the recursion is correct 
    if(board(p).hasMine) throw Explosion("Stepped on a Mine!"); 
    //Single call to previously defined function 
    int num_of_adjacent_mines = get_adjacent_mine_count(p); 
    //I'm assuming this gets initialized to -1 beforehand 
    board(p).revealed = num_of_adjacent_mines; 
    if(num_of_adjacent_mines == 0) { 
     for(int i = -1; i <= 1; i++) { 
      for(int j = -1; j <= 1; j++) { 
       point this_point(p.x + i, p.y + j); 
       if(!is_inside_board(board, this_point)) continue; 
       if(i == 0 && j == 0) continue; 
       if(board(this_point).revealed == -1) 
        reveal_tiles(this_point); 
      } 
     } 
    } 
} 

Je vais fortement recommander que vous écrivez une simple classe Matrix pour représenter board, que mon code implique que vous avez fait, parce que c'est une solution beaucoup plus robuste que d'essayer d'interagir avec un tableau 2D de la Façon C-style, vous le faites.