Problème de fonction qui plante

Version imprimable

Bonjour à tous,
Je suis en train de créer un démineur en langage C, j'essaye de réaliser une fonction qui dévoile automatiquement toutes les cases sans bombes à proximité lorsqu'on la sélectionne.

Je regarde donc la case en haut, à droite, en bas et à gauche et je le propage en répétant la fonction. Lorsque j'utilise seulement deux conditions, par exemple haut gauche ou bas gauche. Mais quand je fais des conditions opposées comme haut bas et droite gauche ça plante. Donc la fonction est inutilisable.

Je vous donne le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
void caseVide(int x, int y, int grilleValeur[XMAX+2][YMAX+2], int grilleUser[XMAX][YMAX], int *compteurVictoire, int *j)
{
 
 
    //Condition
    //Case du dessus
    if(x>0 && grilleUser[x-1][y]==0) //On regarde si ça ne dépasse pas du tableau et si la case a déjà était dévoilé
    {
        if(grilleValeur[x][y+1]==0) //Je regarde si la case est un 0
        {
            caseVide(x-1,y,grilleValeur,grilleUser,&*compteurVictoire,&*j);//Je répète la fonction
            *j=*j+1;//J'incrément ma boucle de 1;
        }
        grilleUser[x-1][y]=1; //Je dévoile la case
        *compteurVictoire = *compteurVictoire+1; //J'incrémente le compteur de victoire de 1
 
    }
    //Case de droite
    if(y<YMAX-1 && grilleUser[x][y+1]==0)
    {
        if(grilleValeur[x+1][y+2]==0)
        {
            caseVide(x,y+1,grilleValeur,grilleUser,&*compteurVictoire,&*j);
            *j=*j+1;
        }
        grilleUser[x][y+1]=1;
        *compteurVictoire = *compteurVictoire+1;
    }
    //Case du bas
    if(x<XMAX-1 && grilleUser[x+1][y]==0)
    {
        if(grilleValeur[x+2][y+1]==0)
        {
            caseVide(x+1,y,grilleValeur,grilleUser,&*compteurVictoire,&*j);
            *j=*j+1;
        }
        grilleUser[x+1][y]=1;
        *compteurVictoire = *compteurVictoire+1;
    }
    //Case de gauche
    if(y>0 && grilleUser[x][y-1]==0)
    {
        if(grilleValeur[x+1][y]==0)
        {
            caseVide(x,y-1,grilleValeur,grilleUser,&*compteurVictoire,&*j);
            *j=*j+1;
        }
        grilleUser[x][y-1]=1;
        *compteurVictoire = *compteurVictoire+1;
    }
 
}

Cordialement Airox

Et avec des tests de façon classique :koi: :koi:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#define TEST_BOMB(POS_X, POS_Y) \
    if (grilleUser[POS_X][POS_X] == 0) { \
         \
        grilleUser[POS_X][POS_Y] = 1; /*<- à tester mais dévoiler avant de lancer la récursivité*/ \
         \
        if(grilleValeur[(POS_X + 1)][(POS_Y + 1)] == 0) { \
            caseVide((POS_X, POS_Y, grilleValeur, grilleUser, compteurVictoire, j); \
        } \
         \
        (*compteurVictoire) = ((*compteurVictoire) + 1); \
    }
 
 
//  ...
 
void caseVide(int x, int y, int* grilleValeur, int* grilleUser, int* compteurVictoire, int* j) {
    if (x > 0) {
        if (y > 0) {
//          left - bottom
            TEST_BOMB((x - 1), (y - 1))
 
//          middle - bottom
            TEST_BOMB(x, (y - 1))
        }
 
//      left - middle
        TEST_BOMB((x - 1), y)
 
        if (y < (YMAX - 1)) {
//          left - top
            TEST_BOMB((x - 1), (y + 1))
 
//          middle - top
            TEST_BOMB(x, (y + 1))
        }
    }
 
//  middle - middle
    TEST_BOMB(x, y)
 
 
    if (x < (XMAX - 1)) {
        if (y > 0) {
//          right - bottom
            TEST_BOMB((x + 1), (y - 1))
 
//          middle - bottom if not yet done
//          TEST_BOMB(x, (y - 1))
        }
 
//      middle - right
        TEST_BOMB((x + 1), y)
 
        if (y < (YMAX - 1)) {
//          top - right
            TEST_BOMB((x + 1), (y + 1))
 
//          middle - top if not yet done
//          TEST_BOMB(x, (y + 1))
        }
    }
}

Édit 1: j'arrive après la bataille :aie:, mais il faut inverser 2 lignes. On marque la case visitée et ensuite on lance la récursivité

Édit 2: Mes tests sont à vérifier quand même :whistle:, mais c'est l'idée du truc: on teste si le point à un côté gauche et ensuite s'il a un côté droit. Et pour chaque côté, on teste s'il a un (y - 1) et un (y + 1)

On peut inverser mes tests. On teste si le point à un (y - 1) et ensuite s'il a un (y + 1). Et pour haut/ bas, on teste s'il a un côté gauche et un côté droit

18/12/2016, 08h09
fearyourself

Sans regarder le code quand on me dit:

- J'ai une fonction récursive et j'ai quatre directions
- Cela ne plante pas quand je regarde dans les directions non opposées
- Cela plante quand je regarde dans des directions opposées

Tout de suite, cela hurle: récursivité infinie...

Et ce que je suppose:
- La fonction va regarder à gauche, la fonction va regarder à droite, la fonction va regarder à gauche, la fonction va regarder à droite...

Et donc je me dis: ça doit être parce que la personne ne garde pas en mémoire les cases visitées.

Enfin, je regarde ton code: je vois une variation de la visite d'une case (donc mieux que ce que je pensais :)) mais l'ordre n'est pas bon:

- Marque ta case comme dévoilé
- Ensuite regarde autour
18/12/2016, 12h21
Airox-

Merci c'est exactement ça ! J'y ai pensé pendant la nuit (oui je rêve de mon code :mouarf:). En tout cas merci pour ta réponse. Foetus je savais pas qu'on pouvais faire un if comme ça. Je vais pouvoir compacter mon code :) Merci à toi aussi.