remplissage d'un fichier txt

**chamludo** · 15/11/2024, 00h43

Bonjour,
J'ai un petit soucis pour écrire dans un fichier txt avec la sdl.
Je souhaite faire un fichier dans lequel est inscrit tous les éléments chargés pour mon jeu : Windows, Renderer, police, musique, liste des images, ...
Cela devrait donner :

Ouverture du fichier : fichierErreur.txt
Chargement des windows, renderer, sdl, ttf,... : en cours.
Chargement de SDL_Init (video et audio) : OK.
Chargement de Window et Renderer : OK.
Chargement de TTF_Init : OK.
Ouverture de la musique : OK.
Initialisation SDL : OK
Chargement des polices : en attente
Chargement de la police : OK.
Chargement des images : en attente
Chargement de l'image Image1.bmp : OK
Chargement de l'image Image2.bmp : OK
[...]
Nombre d'images correctement chargées : 11

Pour cela, j'ai déclaré un fichier "fichierErreur.txt" en variable globale ainsi qu'une structure contenant mes images et textes:

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
#define NbImagesMax 11 
#define NbImagesPionMax 24 
#define NbMessagesMax 15 
#define NbMessagesBoutonMax 36
 
typedef struct Images Images;
struct Images
{
    SDL_Texture *Image[NbImagesMax];//tableau de NbImagesMax images
    SDL_Texture *Pion[NbImagesPionMax];//tableau de tous les pions
    SDL_Texture *Message[NbMessagesMax];//tableau de NbMessagesMax messages
    SDL_Texture *MessageBouton[NbMessagesBoutonMax];//tableau de NbMessagesMax messages
    SDL_Rect DimensionImage[NbImagesMax]; //pour chaque image, dimensionner w et h
    SDL_Rect DimensionPion[NbImagesPionMax];
    SDL_Rect DimensionMessage[NbMessagesMax]; //pour chaque texte, dimensionner w et h
    SDL_Rect DimensionMessageBouton[NbMessagesBoutonMax]; //pour chaque texte, dimensionner w et h
};

J'ai des fonctions qui chargent les images et les textes.
J'obtiens comme résultat dans mon fichier "fichierErreur.txt": la liste des chargement (sdl, ttf, ...)+Tous les Image +Tous les Pion + Tous les Message + la moitie des MessageBouton.
Si j'intervertis le chargement des Message et des MessageBouton, alors j'obtiens la totalité des MessageBouton et la moitie des Message.
Comme si j'étais limité dans le nombre de caractères à écrire dans le "fichierErreur.txt".
Cette limite existe-t-elle ? Là, je bloque à environ 4000 caractères (4008 dans une version, 4018 dans une autre).

Ce que je trouve normal, c'est que si je ne charge pas Image , alors j'ai la liste totale de Pion + Message + MessageBouton.
Ce qui m'étonne, c'est que si je charge Image mais pas Pion, alors mon fichier est absolument vide, même pas "sdl, ttf, ... bien chargé".

Avez vous une explication ?
Merci à tous ceux qui feront l'effort de me lire et de m'aider.

**LittleWhite** · 15/11/2024, 08h12

Bonjour,

Le meilleur ami du programmeur, c'est le débogueur. Je vous conseille d'y jeter un coup d'œil : https://alexandre-laurent.developpez...e-application/.

Sinon, là où je regarderai : les index de vos tableaux, la fonction d'écriture dans le fichier.

**chamludo** · 15/11/2024, 14h35

Merci de ta réponse.
J'utilise Codeblock.
Or je n'ai aucun message d'alerte dans le compilateur.
De plus, même si mon fichier affiche que je n'ai chargé les images de que 1 jusqu'à 30 (sur les 50 possibles), j'arrive quand même a afficher les 50 images en question.

Les dernières lignes du mon fichier sont :
"
Chargement du texte " C ": OK
Chargement du texte " oudPouS ": OK
Chargement du t
"
La dernière ligne semble coupée en plein milieu.

Si j'utilise deux fichiers, un pour les images, et l'autre pour les textes, j'ai toutes mes lignes souhaitées incrites.

Je ne sais pas où passe ce texte non écrit dans le fichier.

**Mat.M** · 15/11/2024, 18h26

Envoyé par chamludo

Merci de ta réponse.
De plus, même si mon fichier affiche que je n'ai chargé les images de que 1 jusqu'à 30 (sur les 50 possibles), j'arrive quand même a afficher les 50 images en question.

Comment pouvez-vous charger 30 images alors que ce nombre est limité à 11

? Si je lis bien le code donné précédemment....

Code :

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

1
2
 
SDL_Texture *Image[NbImagesMax];

Si vous voulez de la souplesse alors il faut utiliser des listes chaînées d'images ou mieux des conteneurs C++ comme std::list, std::vector.

**chamludo** · 15/11/2024, 20h03

Je me suis peut être mal exprimé avec les 30 et 50 images.
C'était jute pour prendre un exemple.
De plus, ma structure de Image est composée de 4 types d'images/textures : les 11 images (pour les décors, ... ), les 24 pions (pour les joueurs), les 15 messages (texte pour les décor, l'aide, ... ) et les 36 messagesBouton (pour avoir des textes des boutions).
Cela me fait un total de 11+24+15+36 = 85 images
J'arrive à afficher les 85 images sur ma fenêtre, mais je n'ai pas les 85 lignes dans le fichier.txt, je n'en ai que 60 (environ).
C'set à dire que mes textures sont bien initialisées mais que je fichier ne se remplit pas entièrement

**Mat.M** · 15/11/2024, 22h49

bonsoir une question : le fichier texte est il ouvert en mode "a+t" ? C'est-à-dire en mode append et texte ?
Un peu plus de code ça serait mieux car là on n'a pas assez de code pour voir ce qui ne fonctionne pas.

**chamludo** · 15/11/2024, 23h19

Le fichier est ouvert en mode "w".

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
402
403
 
FILE* fichierErreur = NULL;//pour ecrire les chargements reussis et les erreurs de chargement
 
int main(int argc, char **argv)
{
    time_t temps;
    SDL_Window* Window = NULL;// Création de la fenêtre
    SDL_Renderer *Renderer=NULL;// Création du renderer
    Images Jeton =
    {
        NULL,/*icone*/
        {/*Image*/NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
        {/*Pion*/NULL, NULL, NULL,NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
        {/*Message*/NULL, NULL, NULL, NULL, NULL, NULL, NULL,NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
        {/*MessageBouton*/NULL, NULL, NULL, NULL, NULL, NULL, NULL,NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,NULL, NULL, NULL, NULL, NULL, NULL,NULL, NULL, NULL, NULL, NULL, NULL, NULL,NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
        {/*Image*/{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}},
        {/*Pion*/{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}},
        {/*Message*/{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}},
        {/*MessageBouton*/{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}}
    };
 
    Police police= {NULL, NULL};
 
    /**********************/ //debut du programme
    SDL_EventState(SDL_MOUSEBUTTONUP, SDL_IGNORE); //ignore tous les clics. A reactiver apres le titre avec SDL_EventState(SDL_MOUSEBUTTONUP, SDL_ENABLE);
 
    fichierErreur = fopen("fichierErreur.txt", "w");//ouverture (en mode ecriture) du fichier pour gerer les chargements des fonctions
    if (fichierErreur != NULL)//si reussite
    {
        temps=time(NULL);
        fprintf(fichierErreur, "%s\n", ctime(&temps));
        fputs("Ouverture du fichier : fichierErreur.txt \n", fichierErreur);
    }
    else exit(EXIT_FAILURE);//sinon, fin prog
 
    initSDL(&Window, &Renderer);//on continue car tout est OK. Utiliser QuitSDL pour desinstaller la SDL et etc
    police=ChargementPolice(&Window, &Renderer);//les polices ont ete forcement bien chargees, sinon, fin du prog dans le fonction ChargementPolice
 
    if(ChargementImagesMessages(Renderer,&Jeton,police)==ERREUR) //Si l'initialisation retourne faux
        QuitSDL(&Window, &Renderer,police,ERREUR);//on quitte la sdl (images et messages deja libérés)
 
    fputs("Chargement des images et des messages : OK.\n", fichierErreur);
    fputs("Determination des dimensions des images et des messages : OK.\n", fichierErreur);
 
    Mix_CloseAudio(); //Fermeture du son
    LiberationImages(&Jeton, NbImagesMax);
    /*  TTF_CloseFont(police.normal); // Fermeture de la police, doit être fermée avant TTF_Quit()
      TTF_CloseFont(police.soulignee); // Fermeture de la police, doit être fermée avant TTF_Quit()
      TTF_Quit();
      SDL_Quit();*/
 
    QuitSDL(&Window, &Renderer, police,SUCCES);
 
    return EXIT_SUCCESS; //on quitte le jeu avec succes
}
void initSDL(SDL_Window **window, SDL_Renderer **renderer)
{
    time_t temps;
 
    fprintf(fichierErreur, "Chargement des windows, renderer, sdl, ttf,... : en cours.\n");
 
    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO )!=0)//si chargement = erreur
    {
        fprintf(fichierErreur, "Problème pour charger SDL_Init_Video et SDL_Init_AUDIO : %s\n", SDL_GetError()); //Si l'initialisation de la SDL a échoué, on retourne faux
        temps=time(NULL);
        fprintf(fichierErreur, "\n%s\n", ctime(&temps));
        fclose(fichierErreur);
        exit(EXIT_FAILURE); //quitter le programme
    }
    else fprintf(fichierErreur, "Chargement de SDL_Init (video et audio) : OK.\n");
 
    if(SDL_CreateWindowAndRenderer(EcranLarg, EcranHaut, SDL_WINDOW_SHOWN, window, renderer)!=0)//si creation = erreur
    {
        fprintf(fichierErreur, "Problème pour charger SDL_CreateWindowAndRenderer : %s\n", SDL_GetError()); //Si l'initialisation de Window et Renderer a échoué, on retourne faux
        temps=time(NULL);
        fprintf(fichierErreur, "\n%s\n", ctime(&temps));
        fclose(fichierErreur);
        exit(EXIT_FAILURE); //quitter le programme
    }
    else fprintf(fichierErreur, "Chargement de Window et Renderer  : OK. \n");
 
    if(TTF_Init()==-1)//si initialisation = erreur
    {
        fprintf(fichierErreur, "Problème pour charger TTF_Init : %s\n", SDL_GetError()); //Si l'initialisation de la TTF_Init a échoué,
        temps=time(NULL);
        fprintf(fichierErreur, "\n%s\n", ctime(&temps));
        fclose(fichierErreur);
        SDL_DestroyRenderer(*renderer);//fermeture renderer, window, sdl
        SDL_DestroyWindow(*window);
        SDL_Quit();
        exit(EXIT_FAILURE); //quitter le programme
    }
    else fprintf(fichierErreur, "Chargement de TTF_Init  : OK.\n");
}
 
/**********************************/
void QuitSDL(SDL_Window **window, SDL_Renderer **renderer,Police police, int etat)
{
    time_t temps;
 
    temps=time(NULL);
    fprintf(fichierErreur, "\nAu revoir \n%s\n", ctime(&temps));
    fclose(fichierErreur);
    SDL_DestroyRenderer(*renderer); //Fermeture renderer, window, sdl
    SDL_DestroyWindow(*window);
    TTF_CloseFont(police.normale);
    TTF_CloseFont(police.soulignee);
    Mix_CloseAudio();// quit SDL_mixer
    TTF_Quit();
    SDL_Quit();
    if (etat==ERREUR) exit(EXIT_FAILURE); //quitter le programme avec ERREUR
    else exit(EXIT_SUCCESS);
}
 
/**********************************/
Police ChargementPolice(SDL_Window **window, SDL_Renderer **renderer)
{
    Police police;
    time_t temps;
 
    police.normale=TTF_OpenFont("./Ressources/times.ttf", 30);
    if(police.normale==NULL) //si erreur d'allocation de police
    {
        fprintf(fichierErreur, "Erreur de chargement de la police normale : %s\n", SDL_GetError()); //Si l'initialisation de la police normale a échoué,
        temps=time(NULL);
        fprintf(fichierErreur, "\n%s\n", ctime(&temps));//et fermer le prog
        fclose(fichierErreur);
        SDL_DestroyRenderer(*renderer);//fermeture renderer, window, sdl
        SDL_DestroyWindow(*window);
        TTF_Quit();
        SDL_Quit();
        exit(EXIT_FAILURE); //quitter le programme
    }
    else
    {
        fprintf(fichierErreur, "Chargement de la police normale : OK.\n");
 
        police.soulignee=TTF_OpenFont("./Ressources/times.ttf", 30);//Sinon charger la police soulignée
        TTF_SetFontStyle(police.soulignee, TTF_STYLE_UNDERLINE);
        if(police.soulignee==NULL) //si erreur d'allocation de police
        {
            fprintf(fichierErreur, "Erreur de chargement de la police soulignee : %s\n", SDL_GetError()); //Si l'initialisation de la police soulignee a échouée,
            temps=time(NULL);
            fprintf(fichierErreur, "\n%s\n", ctime(&temps));//et fermer le prog
            fclose(fichierErreur);
 
            TTF_CloseFont(police.normale);//il faut libérer la police normale qui a été bien chargée
 
            SDL_DestroyRenderer(*renderer);//fermeture renderer, window, sdl
            SDL_DestroyWindow(*window);
            TTF_Quit();
            SDL_Quit();
            exit(EXIT_FAILURE); //quitter le programme
        }
        else
        {
            fprintf(fichierErreur, "Chargement de la police soulignée : OK.\n");
            fprintf(fichierErreur, "Chargement des polices : OK.\n");
            fprintf(fichierErreur, "Chargement des images : en attente \n");
        }
    }
    return police;
}
 
/**********************************/
SDL_Texture *ChargementImages(SDL_Renderer *renderer, const char *file,Uint8 r, Uint8 g, Uint8 b)
{
    SDL_Texture *texture = NULL;//Texture à renvoyer
    SDL_Surface *surface = IMG_Load(file);//surface intermédiaire
 
    if(surface==NULL)//si image non chargée
    {
        fprintf(fichierErreur, "Chargement de l'image %s : probleme. %s\n",file, SDL_GetError());
        return NULL;
    }
    else//on crée la transparence pour UNE couleur precise de la texture
    {
        fprintf(fichierErreur, "Chargement de l'image %s : OK\n",file );
 
        if(SDL_SetColorKey(surface,SDL_TRUE,SDL_MapRGB(surface->format, r,g,b))!=0)//couleur transparent SANS Alpha, avec sdl_surface
        {
            fprintf(fichierErreur, "Problème pour charger la transparence d'une couleur de l'image : %s\n", SDL_GetError());
            return NULL;
        }
        else //creation de la texture
        {
            texture = SDL_CreateTextureFromSurface(renderer, surface);
            if(texture == NULL )
            {
                fprintf(fichierErreur, "Problème pour transformer la Surface en Texture : %s\n", SDL_GetError());
                return NULL;
            }
            else
            {
                SDL_FreeSurface(surface);//liberation de la surface devenue inutile
                return texture;//renvoi de la texture
            }
        }
    }
}
 
/**********************************/
void LiberationImagesPions(Images *Jeton, int NbImagesChargees, int NbPionsCharges)//Libération des images+pions
{
    int i;
 
    SDL_FreeSurface(Jeton->Icone);//liberation de icone (icone est une surface, pas une texture)
    fprintf(fichierErreur, "Liberation icone : OK \n");//Si NbImagesChargees==0, il faut juste liberer l'icone
 
    if (NbImagesChargees!=0)//Si NbImagesChargees!=0, il faut liberer les autres images
    {
        for (i=0; i<NbImagesChargees; i++)
        {
            SDL_DestroyTexture(Jeton->Image[i]);
            fprintf(fichierErreur, "Liberation image n°%d : OK \n", i);
        }
    }
 
    if (NbPionsCharges!=0)//Si NbPionsCharges!=0, il faut liberer les autres pions
    {
        for (i=0; i<NbPionsCharges; i++)
        {
            SDL_DestroyTexture(Jeton->Pion[i]);
            fprintf(fichierErreur, "Liberation pion n°%d : OK \n", i);
        }
    }
}
 
/**********************************/
SDL_Texture *ChargementMessages(SDL_Renderer *renderer, const char *file, Police police)
{
    SDL_Texture *texture = NULL;//Texture à renvoyer
 
    texture = SDL_CreateTextureFromSurface(renderer, TTF_RenderText_Blended(police.normale, file, couleurTexteNoir));//ecris le texte directement dans une Texture
 
    if(texture == NULL )
    {
         fprintf(fichierErreur, "Problème pour charger le texte \" %s \"en texture: %s\n",file, SDL_GetError());
        return NULL;
    }
    else
    {
        fprintf(fichierErreur, "Chargement du texte \" %s \": OK\n",file );//ecrire \" pour afficher le guillemet en texte
        return texture;//renvoi de la texture
    }
}
/**********************************/
SDL_Texture *ChargementMessagesBouton(SDL_Renderer *renderer, const char *file,int i, Police police)
{
    SDL_Texture *texture = NULL;//Texture à renvoyer
 
    if(i!= NbMessagesBoutonMax)//revoir la limite
    {
        switch (i%5)
        {
        case 0 : // noir, normal
            texture = SDL_CreateTextureFromSurface(renderer, TTF_RenderText_Blended(police.normale, file, couleurTexteNoir));//texte, normal, noir
            break;
        case 1: // noir souligne
            texture = SDL_CreateTextureFromSurface(renderer, TTF_RenderText_Blended(police.soulignee, file, couleurTexteNoir));//texte, souligné, noir
            break;
        case 2 : // noir normal
            texture = SDL_CreateTextureFromSurface(renderer, TTF_RenderText_Blended(police.normale, file, couleurTexteNoir));//texte, normal, noir
            break;
        case 3 :// gris souligné
            texture = SDL_CreateTextureFromSurface(renderer, TTF_RenderText_Blended(police.soulignee, file, couleurTexteGris));//texte, souligné, gris
            break;
        case 4 :// gris normal
            texture = SDL_CreateTextureFromSurface(renderer, TTF_RenderText_Blended(police.normale, file, couleurTexteGris));//texte, normal, gris
            break;
        }
    }
    else //si dernier message cad  ""
        texture = SDL_CreateTextureFromSurface(renderer, TTF_RenderText_Blended(police.normale, file, couleurTexteNoir));//texte, noir
 
    if(texture == NULL )
    {
        fprintf(fichierErreur, "Problème pour charger le texte \" %s \" en texture: %s\n",file, SDL_GetError());
        return NULL;
    }
    else
    {
        fprintf(fichierErreur, "Chargement du texte \" %s \": OK\n",file );//ecrire \" pour afficher le guillemet en texte
         return texture;//renvoi de la texture
    }
}
 
/**********************************/
void LiberationMessages(Images *Jeton, int NbMessagesCharges)//Libération des images
{
    int i;
 
    if (NbMessagesCharges!=0)//Si NbMessagesCharges!=0, il faut liberer les autres messages
    {
        for (i=0; i<NbMessagesCharges; i++)
        {
            SDL_DestroyTexture(Jeton->Message[i]);
            fprintf(fichierErreur, "Liberation message n°%d : OK \n", i);
        }
    }
}
/**********************************/
int ChargementImagesMessages(SDL_Renderer *Renderer, Images *Jeton,Police police)
{
    time_t temps;
    char *ListeImage[] = {"./Ressources/image-BoutonConfigDimension.bmp","./Ressources/image-BoutonConfigType.bmp","./Ressources/image-CaseGrise.bmp","./Ressources/image-CoupeGrande.bmp","./Ressources/image-CoupePetite.bmp","./Ressources/image-Curseur.bmp","./Ressources/image-CurseurAxe.bmp","./Ressources/image-CurseurCroix-Gris.bmp","./Ressources/image-CurseurCroix-Noir.bmp","./Ressources/image-Musique.bmp","./Ressources/image-Titre.bmp"};//liste des fichiers d'images à charger
    char *ListePion[] = {"./Ressources/image-Jeton-0.bmp","./Ressources/image-Jeton-1.bmp","./Ressources/image-Jeton-2.bmp","./Ressources/image-Jeton-3.bmp","./Ressources/image-Jeton-4.bmp","./Ressources/image-Jeton-5.bmp","./Ressources/image-Jeton-6.bmp","./Ressources/image-Jeton-7.bmp","./Ressources/image-Jeton-8.bmp","./Ressources/image-Jeton-9.bmp","./Ressources/image-Jeton-10.bmp","./Ressources/image-Jeton-11.bmp","./Ressources/image-Jeton-12.bmp","./Ressources/image-Jeton-13.bmp","./Ressources/image-Jeton-14.bmp","./Ressources/image-Jeton-15.bmp","./Ressources/image-Jeton-16.bmp","./Ressources/image-Jeton-17.bmp","./Ressources/image-Jeton-18.bmp","./Ressources/image-Jeton-19.bmp","./Ressources/image-Jeton-20.bmp","./Ressources/image-Jeton-21.bmp","./Ressources/image-Jeton-22.bmp","./Ressources/image-Jeton-23.bmp "};//liste des fichiers d'images à charger
    char *ListeMessage[] = {"Pour jouer une partie de morpion classique, ","il suffit d'aligner (verticalement, horizontalement, ","ou diagonalement) trois jetons.","Ce bouton permet d'annuler plusieurs -----------> ","derniers coups joués. -------------------------------> ","Ce bouton permet de jouer contre l'ordinateur,","de choisir son jeton, de modifier la musique. -->","Ce bouton permet de changer le nombre ------->","de cases et le nombre de jetons à aligner. ------->","Ce bouton permet de définir un tournoi de -----> ","10 manches maximum. ---------------------------->","Manche ","Joueur 1", "Joueur 2","Dimensions"};//liste des textes a charger
    char *ListeMessageBouton[] = {"Annuler", "A", "nnuler","A", "nnuler","CoudPouS","C", "oudPouS","C", "oudPouS","Instruction","I", "nstruction","I", "nstruction","Nouveau","N", "ouveau","N", "ouveau","Quitter","Q", "uitter","Q", "uitter","Tournoi","T", "ournoi","T", "ournoi","Valider","V", "alider","V", "alider"," "};//liste des textes a charger
    int ErreurChargement=NON;//[0 : pas d'erreur][1 : erreur]
    int i;
 
    Jeton->Icone=IMG_Load("./Ressources/image-Icone.ico");// chargement de l'icone
    if(Jeton->Icone==NULL)//si image non chargée
    {
        fprintf(fichierErreur, "Chargement de l'icone : Probleme. %s\n", SDL_GetError());
        temps=time(NULL);
        fprintf(fichierErreur, "\n%s\n", ctime(&temps));
        fclose(fichierErreur);
        ErreurChargement=OUI;
        return ErreurChargement;//renvoi erreur
    }
    else  fprintf(fichierErreur, "Chargement de l'icone Icone.ico: OK \n");
 
    for (i=0; i<NbImagesMax; i++)// chargement des  images
    {
        Jeton->Image[i]=ChargementImages(Renderer,ListeImage[i],couleurImageBlanc);
        if(Jeton->Image[i]==NULL)//si pb de chargement
        {
            ErreurChargement=OUI;
            LiberationImagesPions(Jeton, i, 0);//liberation des images chargées (il y en a i), il ne restera plus que la SDL à libérer
            temps=time(NULL);
            fprintf(fichierErreur, "\n%s\n", ctime(&temps));
            fclose(fichierErreur);
            return ErreurChargement;//renvoi erreur
        }
        else
            SDL_QueryTexture(Jeton->Image[i], NULL, NULL, &(Jeton->DimensionImage[i]).w, &(Jeton->DimensionImage[i]).h);//determination dimension de l'image
    }
    fprintf(fichierErreur, "Nombre d'images correctement chargées : %d \n", i);//il y en a i images
 
    /**/
 
    for (i=0; i<NbImagesPionMax; i++)// chargement des pions
    {
        Jeton->Pion[i]=ChargementImages(Renderer,ListePion[i],couleurImageBlanc);
        if(Jeton->Pion[i]==NULL)//si pb de chargement
        {
            ErreurChargement=OUI;
            LiberationImagesPions(Jeton,NbImagesMax, i);//liberation des images chargées (il y en a i), il ne restera plus que la SDL à libérer
            temps=time(NULL);
            fprintf(fichierErreur, "\n%s\n", ctime(&temps));
            fclose(fichierErreur);
            return ErreurChargement;//renvoi erreur
        }
        else
            SDL_QueryTexture(Jeton->Pion[i], NULL, NULL, &(Jeton->DimensionPion[i]).w, &(Jeton->DimensionPion[i]).h);//determination dimension de l'image
    }
    fprintf(fichierErreur, "Nombre de pions correctement chargés : %d \n", i);//il y en a i pions
 
 
    for (i=0; i<NbMessagesMax; i++)// chargement des messages
    {
        Jeton->Message[i]=ChargementMessages(Renderer,ListeMessage[i],police);
        if(Jeton->Message[i]==NULL)//si pb de chargement
        {
            ErreurChargement=OUI;
            LiberationImages(Jeton, NbImagesMax);//liberation de toutes images
            LiberationPions(Jeton,NbImagesPionMax);
  //          LiberationMessageBouton(Jeton,NbMessagesBoutonMax);
            LiberationMessages(Jeton, i);//liberation des messages chargés (il y en a i), il ne restera plus que la SDL à libérer
            temps=time(NULL);
            fprintf(fichierErreur, "\n%s\n", ctime(&temps));
            fclose(fichierErreur);
            return ErreurChargement;//renvoi erreur
        }
        else
            SDL_QueryTexture(Jeton->Message[i], NULL, NULL, &(Jeton->DimensionMessage[i]).w, &(Jeton->DimensionMessage[i]).h);
    }
    fprintf(fichierErreur, "Nombre de messages Texte correctement chargés : %d \n", i);//il y en a i messages
 
    for (i=0; i<NbMessagesBoutonMax; i++)// chargement des textes Bouton
    {
        Jeton->MessageBouton[i]=ChargementMessagesBouton(Renderer,ListeMessageBouton[i],i,police);
        if(Jeton->MessageBouton[i]==NULL)//si pb de chargement
        {
            ErreurChargement=OUI;
            LiberationImages(Jeton, NbImagesMax);//liberation de toutes images
            LiberationPions(Jeton,NbImagesPionMax);
            LiberationMessages(Jeton, NbMessagesMax);
   //         LiberationMessagesBouton(Jeton, i);//liberation des messages chargés (il y en a i), il ne restera plus que la SDL à libérer
            temps=time(NULL);
            fprintf(fichierErreur, "\n%s\n", ctime(&temps));
            fclose(fichierErreur);
            return ErreurChargement;//renvoi erreur
        }
        else
            SDL_QueryTexture(Jeton->MessageBouton[i], NULL, NULL, &(Jeton->DimensionMessageBouton[i]).w, &(Jeton->DimensionMessageBouton[i]).h);
    }
    fprintf(fichierErreur, "Nombre de messages correctement chargés : %d \n", i);//il y en a i messages
 
    return ErreurChargement;
}

**chamludo** · 16/11/2024, 00h58

Mon fichier est ouvert en début de programme, vidé de son contenu, rempli au fur et à mesure, puis fermé une seule fois en fin de programme.
Aurais-je plutôt intérêt à l'ouvrir et le fermer à chaque fois que j'ai besoin d'écrire ?

**Mat.M** · 16/11/2024, 12h53

Envoyé par chamludo

Aurais-je plutôt intérêt à l'ouvrir et le fermer à chaque fois que j'ai besoin d'écrire ?

bonjour il y a deux modes d'écriture d'un fichier soit en mode "append", le texte est généré et écrit avec fprintf en fin de fichier.
L'autre mode c'est en écriture totale et le texte que contient le fichier jusqu'à sa réouverture est écrasé.
Ensuite j'ai une queston j'ai un peu parcouru le code

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
SDL_Texture *ChargementImages(SDL_Renderer *renderer, const char *file,Uint8 r, Uint8 g, Uint8 b)
{
    SDL_Texture *texture = NULL;//Texture à renvoyer
    SDL_Surface *surface = IMG_Load(file);//surface intermédiaire
 
    if(surface==NULL)//si image non chargée
    {
        fprintf(fichierErreur, "Chargement de l'image %s : probleme. %s\n",file, SDL_GetError());
        return NULL;
    }
    else//on crée la transparence pour UNE couleur precise de la texture
    {
/////////
//////////////////////////////////////////////////////////////////
            {
                SDL_FreeSurface(surface);//liberation de la surface devenue inutile
                return texture;//renvoi de la texture
            }
        
    }
}

pourquoi appeler SDL_FreeSurface en chargeant les images ?
C'est une opération à effectuer lorsque le programme est terminé et que l'on efface tous les objets crées,il me semble ?
une surface est associée à une image.En fait matériellement une SDL_Surface c'est la mémoire écran où la bitmap est affichée par une opération de "blitting".

p.s. pour éviter d'imbriquer trop de else on peut utiliser l'instruction return (une valeur)

**chamludo** · 16/11/2024, 18h38

J'avais cru comprendre que l'on devait afficher des Textures, avec SDL_RenderPresent.
Et que les Surfaces n'étaient là que pour passer des images aux Textures ainsi que déterminer une couleur transparente.
Qu'ensuite, les surfaces de servaient plus à rien.
Je suis parti du principe qu'une fois mes Textures créées, je pouvais libérer les Surfaces.
Est-ce une erreur de libérer les Surfaces si tôt ?

**chamludo** · 16/11/2024, 18h46

Trouves tu que j'ai trop de else imbriqués ?

Il faut bien que je teste le chargement de l'image, la transparence, et le passage en texture.
Cela me fait donc 3 else.

As-tu une autre méthode plus "efficace" à me proposer ?

**Mat.M** · 16/11/2024, 20h08

bonsoir mes excuses mais oui d'après l'aide il faut libérer les surfaces SDL_Surface
Source ici

Pour ce qui est de l'imbrication des if else comme je 'ai écris avant on peut faire ainsi

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int fonction_faire_quelque_chose()
{
int nCodeRetour=-1;
if(erreur1) return nCodeRetour;
//....
if(erreur1) return nCodeRetour;
 
nCodeRetour=1;
/// tout s'est passé correctement.
return nCodeRetour;
 
}

Ensuite je suggère d'apprendre les bases du C++ et les rudiments de la programmation orientée objet en créant des classes parce que sinon vous serez vite perdu dans le code.
La POO permet de découper un projet en modules distincts et évite l'utilisation des variables globales.

**chamludo** · 16/11/2024, 21h01

merci de tes conseils.
Mais cela résout-il mon problème ?

**Mat.M** · 17/11/2024, 19h00

est-ce que vous avez essayé" en mode déboguage comme le recommande Littlewhite ?

**chamludo** · 18/11/2024, 17h23

Il me semble que je suis en mod debub.
Pour le choix Release/Debug, j'avais déjà sélectionné Debug
Dans le menu Debug -> ActivesDebuggers -> Target's default

remplissage d'un fichier txt

SDL

Discussions similaires

Partager

Partager