Détecter une erreur

**chamludo** · 02/08/2025, 11h20

Bonjour,
J'ai un petit souci sûrement bête mais qui m'ennuie beaucoup.
Je code en C avec Code Block et j'ai une erreur que je n'arrive pas éclaircir.

J'ai un plateau de 20 cases et une IA qui doit trouver la bonne case à jouer.
Dans l'exemple que je teste, la seule case correcte à jouer pour gagner est la 17.

Lorsque j'exécute le programme en mode normal, l'IA ne joue pas la case 17 mais joue soit la 10 soit la 13.
Lorsque j'exécute le programme en mode débogage, la seule case qu'il joue est la 17.

J'ai eu l'idée de faire écrire dans un fichier les choix de l'IA dans les 2 modes, pour comparer. Idem
En mode normal, l'IA hésite bien entre 10 et 13.
En mode débogage, l'IA choisit 17.

Lorsque je renverse le plateau avec une symétrie horizontale et que, du coup, la case à jouer n'est plus la 17 mais devient la 2, le mode normal joue la bonne case et ne se trompe pas.

Ce que je ne comprends pas, c'est pourquoi en testant le même exemple en deux modes différents, je n'ai pas le même résultat.

Quelqu'un sait-il régler ce genre de problème ?
Merci de votre aide.

**foetus** · 02/08/2025, 12h43

Je ne sais pas si c'est encore le cas

mais le mode débogage initialisait toutes les variables/ pointeurs à zéro (NULL)

Donc commence par regarder les initialisations dans ton code

**chamludo** · 02/08/2025, 13h21

Merci de ta suggestion
Il me semble que mes variables sont bien initialisées. Et que mon problème ne vienne pas de là, car dans ce cas, pourquoi dans la configuration haute, il n'y aurait jamais aucun soucis et dans la configuration basse, ça coince à chaque fois, la même erreur.

Un des soucis que j'ai (juste un peu), c'est que j'ai (comme beaucoup d'entre vous), des variables, des pointeurs, des structures, ...
Lorsque je lance le debugger, c'est facile avec code block de voir les valeurs des variables définie dans la fonction, mais pas celle des pointeurs utilisés. Pour cela, je dois définir à chaque fois une variable ayant pour valeur la valeur du pointeur et ensuite regarder la valeur de la variable.

Existe-t-il un moyen d'éviter cela, ou pas ? Car cela m'oblige de déclarer une nouvelle variable pour chaque pointeur et tableau utilisé et d'insérer des actualisations à plusieurs endroit de mon programme.

**gerald3d** · 02/08/2025, 13h52

Bonjour.

Attends un instant, je regarde dans ma boule de cristal...

Sans code cela va être difficile voir impossible de répondre à la problématique. Je comprends bien qu'en utilisant un modèle d'IA le code source peut ne pas être parlant, mais quand même.

Ceci dit, j'imagine que tu utilises un modèle par renforcement puisque tu désires trouver un chemin. Le problème vient peut-être des "récompenses" qui sont mal calibrées...

**chamludo** · 02/08/2025, 14h26

Merci Gerald, je suis désolé pour ta boule de cristal et j'espère qu'elle est réparable et qu'elle sera sera bientôt réparée. Elle m'a l'air bien pratique en tout cas.

Sans autre blague, je sais bien qu'il est difficile de résoudre un problème sans avoir le code devant soi, mais ma question initiale était déjà de comprendre pourquoi entre le mode normal et le mode debugger, je n'ai pas le même comportement, et que ce comportement se répète à chaque fois à l'identique.

Mon jeu est en fait un jeu morpion. Dans mon cas, 4*5 avec un alignement de 4 jetons identiques.
Je ne peux pas poster l'intégralité du code et tu le comprendras aisément (2 700 lignes)

Mais voici les fonctions peut-être utiles :

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
void OrdiJoue(Case *plateau, Joueur Joueur, CaracteristiqueJeu *Jeu, DimPlateau DimJeu) //Gestion du jeu lorsque l'Ordi joue
{
    int NumeroCaseAJouer=-1;
  /**/    int tmc[20];//Jeu->tabMeilleuresCases[Jeu->NbMeilleuresCases]=
    /**/    int i,nmc;//=NbMeilleuresCases
 
    if(Jeu->NbCasesJouees==0) //si c'est le 1er coup de la partie, alors on choisit aleatoirement
    {
        NumeroCaseAJouer=alea_entre_bornes(0, DimJeu.N*DimJeu.M-1); //choisit aleatoirement une case sur tout le plateau
    }
    else
    {
        ia(plateau, Joueur, Jeu, DimJeu); //l'ordi joue une case en analysant le jeu et cherchant la case la plus gagnante
        NumeroCaseAJouer=Jeu->tabMeilleuresCases[alea_entre_bornes(0, Jeu->NbMeilleuresCases-1)]; //on tire une case au hasard parmi les meilleures possibles
 
 for (i=0; i<20; i++)
        {
            /**/tmc[i]=Jeu->tabMeilleuresCases[i];
        }
        /**/     nmc=Jeu->NbMeilleuresCases;
 
    }
    JouerCoup(plateau, Joueur, Jeu, NumeroCaseAJouer); //Joue le coup selectionné
}
/**********************/
void ia(Case *plateau, Joueur Joueur, CaracteristiqueJeu *Jeu, DimPlateau DimJeu)
{
    int *TabDeCoef= FonctionAllocation1D(DimJeu.N*DimJeu.M, sizeof(*TabDeCoef));
    //  Info InfoZoneDeRecherche;
    Couronne InfoZoneDeRecherche[5]= {{0,DimJeu.N,DimJeu.M},{0,0,0},{0,0,0},{0,0,0},{0,0,0}}; //les InfoZoneDeRecherche est un tableau de 6 infos (CaseDepart-Largeur-Hauteur) correspondant au tableau general [0] puis aux zones de recherche [couronne 1-2-3-4]
 
    int NbCasesVides=DimJeu.N*DimJeu.M-(Jeu->NbCasesJouees);
    int MeilleurScore = -10000;
    int NbMeilleurScore=0;//nombre de fois que le MeilleurScoreeeea été atteint
    int niveau=0;//[0: ordi teste 1 jeton][1: adv teste 1 jeton][2: ordi teste 2 jetons][3: adv teste 2 jetons][4: ordi teste 3 jetons][5: adv teste 3 jetons][6: ordi teste 4 jetons][7: adv teste 4 jetons]
    int AlignementRealise = NON;//[OUI : il y a eu un alignement, on ne teste pas un niveau plus profond][NON : il n'y a pas d'alignement, on testera un niveau plus profond]
    int i,j;
    int taille=DimJeu.N*DimJeu.M-Jeu->NbCasesJouees;//dimension maximale
//   int *ListeCasesVides= FonctionAllocation1D(taille, sizeof(*ListeCasesVides));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
 
// DefinirZoneEtendue(*Jeu, DimJeu, &InfoZoneDeRecherche); //determine la zone a etudier (InfoZoneDeRecherche)
 
    DefinirZoneEtendue(*Jeu, DimJeu, InfoZoneDeRecherche); //determine la zone a etudier (InfoZoneDeRecherche), Jeu nest aps modifie (d'ou *) mais InfoZoneDeRecherche est modifie (tableau passe en pointeur)
    DefinirListeCaseVide(Jeu, DimJeu, InfoZoneDeRecherche);
 
    int nbcv;//NbCasesVides
    /**/    int lcv[20];//listecasesvides
    /**/    int lcv1[20];//listecasesvides
    /**/    int lcv2[20];//listecasesvides
    /**/    int lcv3[20];//listecasesvides
    /**/    int lcv4[20];//listecasesvides
    /**/    int tdc[20];//tabdecoef
    /**/    int tmc[20];//Jeu->tabMeilleuresCases[Jeu->NbMeilleuresCases]=
    /**/    int nmc;//=NbMeilleuresCases
 
 
    /**/    for (i=0; i<20; i++)
    {
        /**/lcv[i]=Jeu->ListeCasesVides[i];
        /**/lcv1[i]=Jeu->ListeCasesVides_C1[i];
        /**/lcv2[i]=Jeu->ListeCasesVides_C2[i];
        /**/lcv3[i]=Jeu->ListeCasesVides_C3[i];
        /**/lcv4[i]=Jeu->ListeCasesVides_C4[i];
    }
 
    for (i=0; i<9; i++)
        tdc[i]=TabDeCoef[i];
 
    if(Jeu->NbCasesJouees==DimJeu.N*DimJeu.M-1) //S'il ne reste plus qu'une seule case à jouer, alors on la joue: c'est ListeCasesVides[0]
    {
//       for (i=0; i<9; i++)
//   lcv[i]=Jeu->ListeCasesVides[i];
 
        //Jeu->tabMeilleuresCases[0]=Jeu->ListeCasesVides_C0[0]; //Choisit la derniere case vide
        TabCroissant(Jeu->HistoriqueJeton, DimJeu.N*DimJeu.M-1);//on range toutes les cases jouées dans l'ordre croisant. Il n'y a qu'une suele case vide, toutes les cases sont Hist[i]=i (avant la case restante) ou Hist[i]= i-1 (apres la case restante)
 
//       for (i=0; i<9; i++)
//   lcv[i]=Jeu->ListeCasesVides[i];
 
        j=0;
        while(Jeu->HistoriqueJeton[j]==j)//tant que la case est au bon rang
            j=j+1;//on pâsse a la suivante
        Jeu->tabMeilleuresCases[0]=j;
        Jeu->NbMeilleuresCases=1;
        //     *NumeroCaseAJouer=j;
//  a=Jeu->tabMeilleuresCases[0];
    }
    else//si plusieurs choix, alors on lance on applique l'ia prevue
    {
        for (i=0; i<DimJeu.N*DimJeu.M; i++) //on rempli le tableau de -1
            TabDeCoef[i]=-1; //alors on ecrit -1 pour une "case occupée"
 
        for (i=0; i<NbCasesVides; i++) //on cherche les cases deja jouées
            TabDeCoef[Jeu->ListeCasesVides[i]]=0; //alors on ecrit 0 qui sera incrementé pour une "case à tester" et on garde //alors on ecrit -1 pour une "case occupée" a l'origine
//TabDeCoef contient TOUTES les cases du jeu avec un coef -1 si occupée et 0 si vide de TOUT le jeu
 
        /**/       for (i=0; i<20; i++)
        {
            /**/lcv[i]=Jeu->ListeCasesVides[i];
            /**/lcv1[i]=Jeu->ListeCasesVides_C1[i];
            /**/lcv2[i]=Jeu->ListeCasesVides_C2[i];
            /**/lcv3[i]=Jeu->ListeCasesVides_C3[i];
            /**/lcv4[i]=Jeu->ListeCasesVides_C4[i];
            /**/tdc[i]=TabDeCoef[i];
        }
        /**/nbcv=NbCasesVides;
 
        while((AlignementRealise==NON)&&(niveau<(DimJeu.NbJetonsAAligner-1)*2))
        {
            SimuleCoup(niveau, *Jeu, plateau, Joueur, InfoZoneDeRecherche, DimJeu, TabDeCoef, &AlignementRealise);//*Jeu car on ne modofie pas jeu
            niveau=niveau+1;
        }
        /**/       for (i=0; i<20; i++)
            /**/   tdc[i]=TabDeCoef[i];
 
        maximumTableau(TabDeCoef, DimJeu.N*DimJeu.M, &MeilleurScore, &NbMeilleurScore); //Recherche la valeur maximale du plateau de taille DimJeu.N*DimJeu.M  ainsi que le nombre de fois qu'eelle apparait.
 
        for (j=0; j<DimJeu.N*DimJeu.M; j++)//on va chercher toutes les cases de coef ayant le MeilleurScore
        {
            if(TabDeCoef[j]==MeilleurScore)
            {
                Jeu->tabMeilleuresCases[Jeu->NbMeilleuresCases]=j;
                Jeu->NbMeilleuresCases=Jeu->NbMeilleuresCases+1;//faut-il conserver ?
            }
        }
        for (i=0; i<20; i++)
        {
            /**/tdc[i]=TabDeCoef[i];
            /**/tmc[i]=Jeu->tabMeilleuresCases[i];
        }
        /**/     nmc=Jeu->NbMeilleuresCases;
    }
    /**/       for (i=0; i<20; i++)
        /**/tdc[i]=TabDeCoef[i];
// fprintf(fichierEssaiCase, "Dans IA, la liste des meilleures cases est tmc : %d.\n",tmc[0]);
  /**/ fprintf(fichierEssaiCase, "Dans IA, la liste des meilleures cases est tmc :\n");
  /**/     for (i=0; i<20; i++)
        {
      /**/      fprintf(fichierEssaiCase, "%d - %d.\n",tmc[i],Jeu->tabMeilleuresCases[i]);
        }
 
 
  fclose(fichierEssaiCase);
 
    free(TabDeCoef);
    TabDeCoef=NULL;
//    free(TabDeTravail);
//    TabDeTravail=NULL;
//    free(ListeCasesVides_C0);
//    ListeCasesVides_C0=NULL;
//    free(ListeCasesVides_C1);
//    ListeCasesVides_C1=NULL;
//    free(ListeCasesVides_C2);
//    ListeCasesVides_C2=NULL;
}
/**********************/
void SimuleCoup(int niveau, CaracteristiqueJeu Jeu, Case *plateau,Joueur Joueur, Couronne InfoZoneDeRecherche[], DimPlateau DimJeu, int *TabDeCoef,int *AlignementRealise)
{
    //niveau = nombre de jetons a ajouter à NbCasesJouees
    int i,j,k,l;
    /**/    int NbCasesVides;//=(InfoZoneDeRecherche.Hauteur)*(InfoZoneDeRecherche.Largeur)-(Jeu.NbCasesJouees);//taille du tableau ListeCV, cases vides, que l'on va creer
    Case Ordi=(Joueur.ListeJ[(Jeu.NbCasesJouees)%2]).jeton;//Rond ou Croix, niveau 0 et 2 et 4 et 6
    Case Adversaire =(Joueur.ListeJ[(Jeu.NbCasesJouees+1)%2]).jeton;//Croix ou Rond, niveau 1 et 3 et 5 et 7
    Case JoueurTeste;
    int  NbAlignements=0;//initialisation
    int *ListeCV= FonctionAllocation1D(DimJeu.N*DimJeu.M, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide utile pour le jeu (si grandes dimensions), tableau grande taille N*M
 
 
    /*       for (i=0; i<9; i++)
    {lcv[i]=Jeu->ListeCasesVides[i];
       tdc[i]=TabDeCoef[i];}
    */
 
//     Jeu->HistoriqueJeton= FonctionAllocation1D(NouveauDimJeu.N*NouveauDimJeu.M, sizeof(Jeu->HistoriqueJeton)); //definit le nouveau HistoriqueJeu
 
    switch (niveau) //determine les boutons a afficher
    {
    case 0 :
        JoueurTeste=Ordi;
        NbCasesVides=InfoZoneDeRecherche[1].Largeur*InfoZoneDeRecherche[1].Hauteur-Jeu.NbCasesJouees;
        free(ListeCV); //on libere l'ancien HistoriqueJeu
        ListeCV=NULL;
        ListeCV= FonctionAllocation1D(NbCasesVides, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
        for (i = 0; i < NbCasesVides; i++) //on copie les bonnes cases vides dans la tableau ListeCV
            ListeCV[i]=Jeu.ListeCasesVides_C1[i];
        break;
    case 1 :
        JoueurTeste=Adversaire;
        NbCasesVides=InfoZoneDeRecherche[1].Largeur*InfoZoneDeRecherche[1].Hauteur-Jeu.NbCasesJouees;
        free(ListeCV); //on libere l'ancien HistoriqueJeu
        ListeCV=NULL;
        ListeCV= FonctionAllocation1D(NbCasesVides, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
        for (i = 0; i < NbCasesVides; i++) //on copie les bonnes cases vides dans la tableau ListeCV
            ListeCV[i]=Jeu.ListeCasesVides_C1[i];
        break;
    case 2 :
        JoueurTeste=Ordi;
        NbCasesVides=InfoZoneDeRecherche[2].Largeur*InfoZoneDeRecherche[2].Hauteur-Jeu.NbCasesJouees;
        free(ListeCV); //on libere l'ancien HistoriqueJeu
        ListeCV=NULL;
        ListeCV= FonctionAllocation1D(NbCasesVides, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
        for (i = 0; i < NbCasesVides; i++) //on copie les bonnes cases vides dans la tableau ListeCV
            ListeCV[i]=Jeu.ListeCasesVides_C2[i];
        break;
    case 3 :
        JoueurTeste=Adversaire;
        NbCasesVides=InfoZoneDeRecherche[2].Largeur*InfoZoneDeRecherche[2].Hauteur-Jeu.NbCasesJouees;
        free(ListeCV); //on libere l'ancien HistoriqueJeu
        ListeCV=NULL;
        ListeCV= FonctionAllocation1D(NbCasesVides, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
        for (i = 0; i < NbCasesVides; i++) //on copie les bonnes cases vides dans la tableau ListeCV
            ListeCV[i]=Jeu.ListeCasesVides_C2[i];
        break;
    case 4 :
        JoueurTeste=Adversaire;
        NbCasesVides=InfoZoneDeRecherche[3].Largeur*InfoZoneDeRecherche[3].Hauteur-Jeu.NbCasesJouees;
        free(ListeCV); //on libere l'ancien HistoriqueJeu
        ListeCV=NULL;
        ListeCV= FonctionAllocation1D(NbCasesVides, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
        for (i = 0; i < NbCasesVides; i++) //on copie les bonnes cases vides dans la tableau ListeCV
            ListeCV[i]=Jeu.ListeCasesVides_C3[i];
        break;
    case 5 :
        JoueurTeste=Adversaire;
        NbCasesVides=InfoZoneDeRecherche[3].Largeur*InfoZoneDeRecherche[3].Hauteur-Jeu.NbCasesJouees;
        free(ListeCV); //on libere l'ancien HistoriqueJeu
        ListeCV=NULL;
        ListeCV= FonctionAllocation1D(NbCasesVides, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
        for (i = 0; i < NbCasesVides; i++) //on copie les bonnes cases vides dans la tableau ListeCV
            ListeCV[i]=Jeu.ListeCasesVides_C3[i];
        break;
    case 6 :
        JoueurTeste=Adversaire;
        NbCasesVides=InfoZoneDeRecherche[4].Largeur*InfoZoneDeRecherche[4].Hauteur-Jeu.NbCasesJouees;
        free(ListeCV); //on libere l'ancien HistoriqueJeu
        ListeCV=NULL;
        ListeCV= FonctionAllocation1D(NbCasesVides, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
        for (i = 0; i < NbCasesVides; i++) //on copie les bonnes cases vides dans la tableau ListeCV
            ListeCV[i]=Jeu.ListeCasesVides_C4[i];
        break;
    case 7 :
        JoueurTeste=Adversaire;
        NbCasesVides=InfoZoneDeRecherche[4].Largeur*InfoZoneDeRecherche[4].Hauteur-Jeu.NbCasesJouees;
        free(ListeCV); //on libere l'ancien HistoriqueJeu
        ListeCV=NULL;
        ListeCV= FonctionAllocation1D(NbCasesVides, sizeof(*ListeCV));//tableau servant a creer la ListeCaseVide, tableau grande taille N*M
        for (i = 0; i < NbCasesVides; i++) //on copie les bonnes cases vides dans la tableau ListeCV
            ListeCV[i]=Jeu.ListeCasesVides_C4[i];
        break;
    }
 
    Jeu.NbCasesJouees=Jeu.NbCasesJouees+(niveau+1);//on va jouer 1 coup pour ordi
 
    switch(niveau)
    {
    case 0 ://test de 1 case
    case 1 :
        for (i = 0; i < NbCasesVides; i++) //pour chaque CaseVide, on teste son score
        {
            NbAlignements=0;//initialisation
            plateau[ListeCV[i]] = JoueurTeste;//On place le jeton de l'ordi
            Jeu.HistoriqueJeton[Jeu.NbCasesJouees-1]=ListeCV[i];//on actualise le dernier jeton joué
            verifFini(plateau, Joueur, DimJeu, &Jeu, &NbAlignements); //Fonction pour vérifier si la partie est terminée//on verfie s'il y a alignement
 
            if(NbAlignements!=0)//le jeton ne permet pas de gagner, il faut annuler et passer au suivant, inutile de modifier Jeu->NbCasesJouees (enlever puis le rajouter?)
            {
                TabDeCoef[ListeCV[i]]=TabDeCoef[ListeCV[i]]+1;//on incrémente le coef de la case testee
                *AlignementRealise=OUI;
            }
            AnnulerVerifFini(plateau, &Jeu, DimJeu);
            plateau[ListeCV[i]] = Vide;//on vide la case du plateau, inutile de liberer la derniere case de HistoriqueJeton
        }
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-1]=-1;//une fois toutes les possibilités testée, on vide le dernier jeton
        break;
    case 2 ://test de 2 cases
    case 3 :
        for (i = 0; i < NbCasesVides; i++) //pour chaque CaseVide, on teste son score
        {
            for (j = 0; j < NbCasesVides; j++) //pour chaque CaseVide, on teste son score
            {
                if(j!=i)//si pas la meme case alors on simule sinon, on passe a la case j suivante
                {
                    NbAlignements=0;//initialisation
                    plateau[ListeCV[i]] = JoueurTeste;//On place le jeton de l'ordi
                    plateau[ListeCV[j]] = JoueurTeste;//On place le jeton de l'ordi
                    Jeu.HistoriqueJeton[Jeu.NbCasesJouees-2]=ListeCV[i];//on actualise l'avant dernier jeton joué
                    Jeu.HistoriqueJeton[Jeu.NbCasesJouees-1]=ListeCV[j];//on actualise le dernier jeton joué
 
                    verifFini(plateau, Joueur, DimJeu, &Jeu, &NbAlignements); //Fonction pour vérifier si la partie est terminée//on verfie s'il y a alignement
 
                    if(NbAlignements!=0)//le jeton ne permet pas de gagner, il faut annuler et passer au suivant, inutile de modifier Jeu->NbCasesJouees (enlever puis le rajouter?)
                    {
                        TabDeCoef[ListeCV[i]]=TabDeCoef[ListeCV[i]]+1;//on incrémente le coef de la case testee
                        TabDeCoef[ListeCV[j]]=TabDeCoef[ListeCV[j]]+1;
                        *AlignementRealise=OUI;
                    }
                    AnnulerVerifFini(plateau, &Jeu, DimJeu);
                    plateau[ListeCV[i]] = Vide;//on vide la case du plateau
                    plateau[ListeCV[j]] = Vide;//on vide la case du plateau
                }
            }
        }
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-2]=-1;//une fois toutes les possibilités testée, on vide l'avant dernier jeton
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-1]=-1;//une fois toutes les possibilités testée, on vide le dernier jeton
        break;
    case 4 ://test de 3 cases
    case 5 :
        for (i = 0; i < NbCasesVides; i++) //pour chaque CaseVide, on teste son score
        {
            for (j = 0; j < NbCasesVides; j++) //pour chaque CaseVide, on teste son score
            {
                if(j!=i)//si pas la meme case alors on simule sinon, on passe a la case j suivante
                {
                    for (k = 0; k < NbCasesVides; k++) //pour chaque CaseVide, on teste son score
                        if((k!=i)&&(k!=j))//si pas la meme case alors on simule sinon, on passe a la case j suivante
                        {
                            NbAlignements=0;//initialisation
                            plateau[ListeCV[i]] = JoueurTeste;//On place le jeton de l'ordi
                            plateau[ListeCV[j]] = JoueurTeste;//On place le jeton de l'ordi
                            plateau[ListeCV[k]] = JoueurTeste;//On place le jeton de l'ordi
                            Jeu.HistoriqueJeton[Jeu.NbCasesJouees-3]=ListeCV[i];//on actualise l'avant dernier jeton joué
                            Jeu.HistoriqueJeton[Jeu.NbCasesJouees-2]=ListeCV[j];//on actualise le dernier jeton joué
                            Jeu.HistoriqueJeton[Jeu.NbCasesJouees-1]=ListeCV[k];//on actualise le dernier jeton joué
 
                            verifFini(plateau, Joueur, DimJeu, &Jeu, &NbAlignements); //Fonction pour vérifier si la partie est terminée//on verfie s'il y a alignement
 
                            if(NbAlignements!=0)//le jeton ne permet pas de gagner, il faut annuler et passer au suivant, inutile de modifier Jeu->NbCasesJouees (enlever puis le rajouter?)
                            {
                                TabDeCoef[ListeCV[i]]=TabDeCoef[ListeCV[i]]+1;//on incrémente le coef de la case testee
                                TabDeCoef[ListeCV[j]]=TabDeCoef[ListeCV[j]]+1;
                                TabDeCoef[ListeCV[k]]=TabDeCoef[ListeCV[k]]+1;
                                *AlignementRealise=OUI;
                            }
                            AnnulerVerifFini(plateau, &Jeu, DimJeu);
                            plateau[ListeCV[i]] = Vide;//on vide la case du plateau
                            plateau[ListeCV[j]] = Vide;//on vide la case du plateau
                            plateau[ListeCV[k]] = Vide;//on vide la case du plateau
                        }
                }
            }
        }
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-3]=-1;//une fois toutes les possibilités testée, on vide l'avant-avant dernier jeton
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-2]=-1;//une fois toutes les possibilités testée, on vide l'avant dernier jeton
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-1]=-1;//une fois toutes les possibilités testée, on vide le dernier jeton
        break;
    case 6 ://test de 4 cases
    case 7 :
        for (i = 0; i < NbCasesVides; i++) //pour chaque CaseVide, on teste son score
        {
            for (j = 0; j < NbCasesVides; j++) //pour chaque CaseVide, on teste son score
            {
                if(j!=i)//si pas la meme case alors on simule sinon, on passe a la case j suivante
                {
                    for (k = 0; k < NbCasesVides; k++) //pour chaque CaseVide, on teste son score
                        if((k!=i)&&(k!=j))//si pas la meme case alors on simule sinon, on passe a la case j suivante
                        {
                            for (l = 0; l < NbCasesVides; l++) //pour chaque CaseVide, on teste son score
                                if((l!=i)&&(l!=j)&&(l!=k))//si pas la meme case alors on simule sinon, on passe a la case j suivante
                                {
                                    NbAlignements=0;//initialisation
                                    plateau[ListeCV[i]] = JoueurTeste;//On place le jeton de l'ordi
                                    plateau[ListeCV[j]] = JoueurTeste;//On place le jeton de l'ordi
                                    plateau[ListeCV[k]] = JoueurTeste;//On place le jeton de l'ordi
                                    plateau[ListeCV[l]] = JoueurTeste;//On place le jeton de l'ordi
                                    Jeu.HistoriqueJeton[Jeu.NbCasesJouees-4]=ListeCV[i];//on actualise l'avant dernier jeton joué
                                    Jeu.HistoriqueJeton[Jeu.NbCasesJouees-3]=ListeCV[i];//on actualise l'avant dernier jeton joué
                                    Jeu.HistoriqueJeton[Jeu.NbCasesJouees-2]=ListeCV[j];//on actualise le dernier jeton joué
                                    Jeu.HistoriqueJeton[Jeu.NbCasesJouees-1]=ListeCV[k];//on actualise le dernier jeton joué
 
                                    verifFini(plateau, Joueur, DimJeu, &Jeu, &NbAlignements); //Fonction pour vérifier si la partie est terminée//on verfie s'il y a alignement
 
                                    if(NbAlignements!=0)//le jeton ne permet pas de gagner, il faut annuler et passer au suivant, inutile de modifier Jeu->NbCasesJouees (enlever puis le rajouter?)
                                    {
                                        TabDeCoef[ListeCV[i]]=TabDeCoef[ListeCV[i]]+1;//on incrémente le coef de la case testee
                                        TabDeCoef[ListeCV[j]]=TabDeCoef[ListeCV[j]]+1;
                                        TabDeCoef[ListeCV[k]]=TabDeCoef[ListeCV[k]]+1;
                                        TabDeCoef[ListeCV[k]]=TabDeCoef[ListeCV[l]]+1;
                                        *AlignementRealise=OUI;
                                    }
                                    AnnulerVerifFini(plateau, &Jeu, DimJeu);
                                    plateau[ListeCV[i]] = Vide;//on vide la case du plateau
                                    plateau[ListeCV[j]] = Vide;//on vide la case du plateau
                                    plateau[ListeCV[k]] = Vide;//on vide la case du plateau
                                    plateau[ListeCV[l]] = Vide;//on vide la case du plateau
                                }
                        }
                }
            }
        }
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-4]=-1;//une fois toutes les possibilités testée, on vide l'avant-avant dernier jeton
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-3]=-1;//une fois toutes les possibilités testée, on vide l'avant-avant dernier jeton
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-2]=-1;//une fois toutes les possibilités testée, on vide l'avant dernier jeton
        Jeu.HistoriqueJeton[Jeu.NbCasesJouees-1]=-1;//une fois toutes les possibilités testée, on vide le dernier jeton
        break;
    }
 
    Jeu.NbCasesJouees=Jeu.NbCasesJouees-(niveau+1);//on annule le jeton joué pour l'ordi
 
    free(ListeCV);
    ListeCV=NULL;
}

toutes les lignes /**/ sont des lignes pour pouvoir afficher la valeur des pointeurs lors du débogage
Les paramètres OrdiJoue(Case *plateau, Joueur Joueur, CaracteristiqueJeu *Jeu, DimPlateau DimJeu) contiennent les dimensions du jeu (longueur, largeur, nombre de jetons à aligner, ...)
Dis moi si tu veux plus de détails.
je sais que je peux raccourcir la 1ere partie de la fonction SimuleCoup, mais je n'y arrive pas pour la fin de la fonction.

**gerald3d** · 02/08/2025, 16h33

Effectivement il y a du monde

. Ça triture pas mal avec les tableaux. Dans la fonction ia(); tu initialises cinq tableaux lcv[] mais vu ton code leur première initialisation ne sert à rien puisque qu'ils ne sont jamais utilisés en dehors des conditions qui suivent.

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
 /**/    int lcv[20];//listecasesvides
  /**/    int lcv1[20];//listecasesvides
  /**/    int lcv2[20];//listecasesvides
  /**/    int lcv3[20];//listecasesvides
  /**/    int lcv4[20];//listecasesvides
 
...
 
/**/    for (i=0; i<20; i++)
    {
      /**/lcv[i]=Jeu->ListeCasesVides[i];
      /**/lcv1[i]=Jeu->ListeCasesVides_C1[i];
      /**/lcv2[i]=Jeu->ListeCasesVides_C2[i];
      /**/lcv3[i]=Jeu->ListeCasesVides_C3[i];
      /**/lcv4[i]=Jeu->ListeCasesVides_C4[i];
    }

Ce code peut être supprimé ou mis en commentaire s'il doit être utilisé ultérieurement. D'ailleurs tu les initialises plus loin dans une condition mais ils ne sont jamais utilisés après. Un reliquat d'essai peut être. Pense à commenter tous les codes en trop pour avoir un minimum de chose sous les yeux. Ça aide au débogage.

Pour la fonction SimuleCoup(); je ne comprends pas pourquoi tu ne transmets pas un pointeur pour CaracteristiqueJeu. En faisant cela tu crées une copie dans ta fonction. Les modifications effectuées ne se répercutent pas ailleurs.

Code :

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

void SimuleCoup(int niveau, CaracteristiqueJeu Jeu, Case *plateau,Joueur Joueur, Couronne InfoZoneDeRecherche[], DimPlateau DimJeu, int *TabDeCoef,int *AlignementRealise)

Crée des fonctions temporaires pour afficher le contenu de tes différents tableaux. À chaque manipulation d'un d'entre-eux affiche son contenu avant et après manipulation, ça t'aidera à voir où ton code ne fait pas ce que tu attends.

Détecter une erreur

C

Vue hybride

Discussions similaires

Partager

Partager