Discussion :

[tatata1]

Bonjour a tous! Je suis actuellement en train de créer un jeu java et je me heurte depuis hier a un probleme que je n'arrive pas a identifier.
J''execute une fonction recursive qui va lire une grille, et lorsque je l'execute j'ai des resultat qui me semble illogiques, je vous ai mis la reponse que j'"ai en dessous du code, j'ai mis des marqueur " DROITE " "Gauche "( c'est avec ca que j'ai remarqué que le deroulement n'etait pas normal) dans mon code pour voir dans la reponse ou est l'erreur, de plus la recursivité s'arrete en bas de "Z" , je ne comprend pas pourquoi ce "return" alors qu'il y a d'autre possibilité. BREF, je vous laisse jeter un petit coup d'oeil et m'eclaire par votre savoir.
Merci beaucoup pour votre aide!
Si vous avez besoin d'info n'hesitez pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
/**
 *
 */
public class Etude_grille1 {
 
    int colonne_prec = 0;
    int ligne_prec = 0;
    int longueur_chaine = 0;
    int monotonie_chaine = 0;
    int monotonie_case = 0;
    int score = 0;
    int tableau_score[][];
    int grille[][];
    int GrillesJeux[][];
    int score_chaine;
    int a = 0;
 
    Etude_grille1() {
 
        GrillesJeux = new int[10][11];
 
 
 
    }
 
    public int lecture_grille(Grilles G, int ligne, int colonne, int sens) {
// permet de passer d'une case à l'autre
        if (colonne < 10 && ligne < 11) {
 
 
 
 
 
            if (sens != 3) {
 
                // on trouve la case d'apres qui est bonne
                if (verification(G, ligne, colonne + 1) == true) {
 
                    System.out.println("Droite"+G.GrilleJeu[ligne][colonne]);
                    if (a != 0) {
                        comparaison(G, ligne, colonne, ligne_prec, colonne_prec);
                    } // on la compare a la precedente, et on verifie qu'on reviens pas sur case preceden
                    a++;
                    ligne_prec = ligne;
                    colonne_prec = colonne;
 
                    return lecture_grille(G, ligne, colonne + 1, 1);
                }
            }
 
            if (sens != 4) {
                if (verification(G, ligne + 1, colonne) == true) {
                    System.out.println("Haut"+G.GrilleJeu[ligne][colonne]);// on trouve la case d'apres qui est bonne
                    if (a != 0) {
                        comparaison(G, ligne, colonne, ligne_prec, colonne_prec);
                    } // on la compare a la precedente, et on verifie qu'on reviens pas sur case precedente
                    a++;
 
                    ligne_prec = ligne;
                    colonne_prec = colonne;
 
                    return lecture_grille(G, ligne + 1, colonne, 2);
                }
            }
 
 
            if (sens != 2) {
                if (verification(G, ligne, colonne - 1) == true) {
                    System.out.println("Gauche"+G.GrilleJeu[ligne][colonne]);// on trouve la case d'apres qui est bonne
                    if (a != 0) {
                        comparaison(G, ligne, colonne, ligne_prec, colonne_prec);
                    }// on la compare a la precedente, et on verifie qu'on reviens pas sur case precedente
                    a++;
 
                    ligne_prec = ligne;
                    colonne_prec = colonne;
 
                    return lecture_grille(G, ligne, colonne - 1, 4);
                }
            }
 
            if (sens != 1) {
                if (verification(G, ligne - 1, colonne) == true) {
                    System.out.println("Bas"+G.GrilleJeu[ligne][colonne]);// on trouve la case d'apres qui est bonne
                    if (a != 0) {
                        comparaison(G, ligne, colonne, ligne_prec, colonne_prec);
                    } // on la compare a la precedente, et on verifie qu'on reviens pas sur case precedente
                    a++;
 
                    ligne_prec = ligne;
                    colonne_prec = colonne;
 
                    return lecture_grille(G, ligne - 1, colonne, 3);
 
 
                    //  en meme temps on envoie les coordoonné pour savoir si c'est dans la meme sequence ou non
                }
            } else {
                System.out.println("PD4");
                ajoutscore(longueur_chaine);
                longueur_chaine = 0;
 
                //  FIN DU JEU!!!
            }
            System.out.println("PD");
            return score;
 
 
 
 
        }
        return score;
    }

ET LE RESULTAT QUE J'OBTIENS EST :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
         A  B  C  D  E  F  G  H  I  J  K
    10 15 21  4  1 11  8               
   9                       28               
   8                       14               
   7                       16               
   6                       19               
   5                       2               
   4                      14               
   3                       22               
   2                       24              
   1                       18 1  6 17 13 5

( la grille rend mal sur ce site mais imaginé qu'elle est bien faite, c'est en forme de "Z" et la colonne F contient les chiffres , (8.28 etc...)

[Gaillac]

Bonjour.

Tu attends quoi en fait comme résultat?
Parce que là la fonction est plus que récursive, elle est multi-récursive (pour peu que le terme existe).

Une même itération, qui aurait comme paramètre sens = 1, va d'abord passer dans sens != 3 et faire des petits, puis dans sens != 4 et faire des petits puis dans sans != 2 et faire de petits.

Et de mêmes pour les "petits". Bref, c'est le bordel et ça va être chaud à prédire.

Parce qu'intuitivement je me serais plus attendu à voir un switch/case voire des else if qu'un suite de conditions ne s'excluant pas et qui font toutes un appel récursif.