Jeu de démineur bloquant autour des mines

Question

Bonjour, je suis en train de construire un programme pour créer le jeu classique démineur en Java, et j'ai presque terminé mais je n'arrive pas à trouver comment vérifier les carrés autour d'une mine et écrire les chiffres (c'est-à-dire s'il y a une, deux, trois mines à côté). J'ai inclus uniquement la méthode ci-dessous, mais je peux poster le reste du programme si nécessaire. Quelle devrait être mon approche? Merci!

private void countAdjacentMines()
{        
            for (int i = 0; i < mineField.length; i++)
    {
        for (int j = 0; j < mineField.length; j++)
        {
            if (!(mineField[i][j].getIsMine()))
            {
                mineField[i-1][j-1];
                mineField[i-1][j];
                mineField[i-1][j+1];
                mineField[i][j-1];
                mineField[i][j+1];
                mineField[i+1][j-1];
                mineField[i+1][j];
                mineField[i+1][j+1];

                mineField[i][j].setAdjacentMines(0);
            }
        } // fin de la boucle pour les lignes
    } // fin de la boucle pour les colonnes
} // fin countAdjacentMines

Answer 1

Pour chaque élément de cette "liste", faites quelque chose comme :

if ((i-1) >= 0 && (j-1) >= 0 && mineField[i-1][j-1].getIsMine()) {
    numAdjacentMines++;
}

Il vaut probablement la peine d'écrire une fonction d'aide pour faire tout cela, puis il vous suffit de l'appeler 8 fois.

Answer 2

Vous êtes sur la bonne voie. Vous devriez garder un compteur, qui représente le nombre de mines adjacentes qui renvoient true pour .getIsMine().

if (!(mineField[i][j].getIsMine()))
{
    counter = 0;
    if (i-1 >= 0) 
    { 
        if (j-1 >=0 && mineField[i-1][j-1].getIsMine()) counter++;
        if (mineField[i-1][j].getIsMine()) counter++;
        if (j+1 < mineField.length && mineField[i-1][j+1].getIsMine()) counter++;
    }

    if (j-1 >=0 && mineField[i][j-1].getIsMine()) counter++;
    if (j+1 < mineField.length && mineField[i][j+1].getIsMine()) counter++;

    if (i+1 < mineField.length)
    {
        if (j-1 >=0 && mineField[i+1][j-1].getIsMine()) counter++;
        if (mineField[i+1][j].getIsMine()) counter++;
        if (j+1 < mineField.length && mineField[i+1][j+1].getIsMine()) counter++;
    }

    mineField[i][j].setAdjacentMines(counter);
}

Vous devez également vérifier que toutes ces valeurs (i-1, j-1, i+1, j+1) ne dépassent pas les limites de votre tableau (i - 1 > -1, etc)

ÉDITER:: Je pense avoir couvert toutes les vérifications.

Answer 3

Quelque chose comme ça :

private void countAdjacentMines()
{        
    for (int i = 0; i < mineField.length; i++)
    {
        for (int j = 0; j < mineField.length; j++)
        {
            if (!(mineField[i][j].getIsMine()))
            {
                int count = 0;

                for (int p = i - 1; p <= i + 1; p++)
                {
                    for (int q = j - 1; q <= j + 1; q++)
                    {
                        if (0 <= p && p < mineField.length && 0 <= q && q < mineField.length)
                        {
                            if (mineField[p][q].getIsMine())
                                ++count;
                        }
                    }
                }

                mineField[i][j].setAdjacentMines(count);
            }
        } // fin de la boucle des lignes
    } // fin de la boucle des colonnes
} // fin countAdjacentMines

Answer 4

Je ne suis pas sûr de ce que vous essayez de faire. Cette déclaration, mineField[i-1][j-1]; et celles comme celle-ci accèdent simplement aux données et n'en font rien.

Je suppose que le tableau stocke quelque chose qui inclut un booléen qui vous indique s'il y a une mine dans cet espace. Si c'est le cas, il suffit de créer un compteur et de changer ces déclarations en quelque chose comme if(mineField[i-1][j-1].hasMine()) counter++;. Et ensuite changer la dernière déclaration en mineField[i][j].setAdjacentMines(counter);.

Answer 5

            int somme = 0;
            somme += mineField[i-1][j-1].getIsMine() ? 1 : 0;
            somme += mineField[i-1][j].getIsMine() ? 1 : 0;
            somme += mineField[i-1][j+1].getIsMine() ? 1 : 0;
            somme += mineField[i][j-1].getIsMine() ? 1 : 0;
            somme += mineField[i][j+1].getIsMine() ? 1 : 0;
            somme += mineField[i+1][j-1].getIsMine() ? 1 : 0;
            somme += mineField[i+1][j].getIsMine() ? 1 : 0;
            somme += mineField[i+1][j+1].getIsMine() ? 1 : 0;

            mineField[i][j].setAdjacentMines(somme);

Cela compte combien de mines il y a et l'utilise correctement. Il serait peut-être plus propre de créer une boucle pour effectuer ce calcul, car c'est la même chose pour chaque champ adjacent.