Gérer les erreurs en sdl2

Version imprimable

Bonsoir, suite au plantage de mon ordi, je suis obligé d'installer la sdl2 et j'en profite pour améliorer mes programmes.
Pour l'instant, j'apprivoise juste les fonctions élémentaires dont j'aurais besoin pour modifier mes anciens programmes.

Dans mes anciens programmes, je faisais quelque chose du style :

Init{sdl, fenetre, audio, video, ttf, police}
InitImage{image1, image2, image3,...}
QuitSDL{fermeture de police, ttf, sdl_quit}
QuitImage{fermeture de image1, fermeture de image2, fermeture de image3,...}
main
{
si (Init=OK)
alors
---si(InitImage =ok)
---alors ......
---else QuitImage
else QuitSDL
}

Avec la sdl2, j'ai plutôt écris:
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 void initSDL(SDL_Window **window, SDL_Renderer **renderer, int w, int h, TTF_Font **PoliceSoulignee) { fprintf(fichierErreur, "Chargement des windows, renderer, sdl, ttf, police,... : en cours.\n"); //Si l'initialisation de la SDL a échoué, on retourne faux if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO )!=0) { 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 fclose(fichierErreur); exit(EXIT_FAILURE); //quitter le programme } else fprintf(fichierErreur, "Chargement de SDL_Init (video et audio) : OK.\n"); if(SDL_CreateWindowAndRenderer(w, h, SDL_WINDOW_SHOWN, window, renderer)!=0) { fprintf(fichierErreur, "Problème pour charger SDL_CreateWindowAndRenderer : %s\n", SDL_GetError()); //Si l'initialisation de Window et Renderer a échoué, on retourne faux fclose(fichierErreur); exit(EXIT_FAILURE); //quitter le programme } else fprintf(fichierErreur, "Chargement de Window et Renderer : OK. \n"); if(TTF_Init()==-1) { fprintf(fichierErreur, "Problème pour charger TTF_Init : %s\n", SDL_GetError()); //Si l'initialisation de la TTF_Init a échoué, 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"); *PoliceSoulignee=TTF_OpenFont("times.ttf", 30); if(*PoliceSoulignee==NULL)//si erreur d'allocation de police de soulignement { fprintf(fichierErreur, "Erreur de chargement de la police : %s\n", SDL_GetError()); //Si l'initialisation de la TTF_Init a échoué, 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 Police : OK. %s\n", SDL_GetError()); //Si l'initialisation de la SDL a échoué, on retourne faux TTF_SetFontStyle(*PoliceSoulignee, TTF_STYLE_UNDERLINE);//pour ecrire en souligné } }
car je ne détruis que ce que j'ai déjà créé avant l'apparition du problème.
J'ai crée un fichierErreur.txt, car je ne trouve pas où sont écrits les SDL_GetError.
Est-ce une bonne idée de mettre des exit(EXIT_FAILURE) sachant que j'ai normalement détruis tout ce que j'ai créé avant

J'ai crée une fonction QuitSDL qui ferme tout ce que est en rapport avec la SDL lorsque tout s'est bien ouvert (à utiliser en cours ou fin de programme prinicipal)
Code:

1 2 3 4 5 6 7 8 9 void QuitSDL(SDL_Window **window, SDL_Renderer **renderer, int w, int h, TTF_Font **Police) { fclose(fichierErreur); SDL_DestroyRenderer(*renderer);//fermeture renderer, window, sdl SDL_DestroyWindow(*window); TTF_CloseFont(*Police); TTF_Quit(); SDL_Quit(); }
De même pour les images: j'ai envie de faire :
chargement image 1
si ok, chargement de l'image 2
si probleme avec l'image 2, destruction de l'image 1+QuitSDL (mais je serais obligé de lui passer police en paramètre alors que je n'en ai pas besoin pour charger une image)
si ok avec l'image2, chargement de l'imagfe3
si probleme avec l'image 3, destruction des images 2 et 1+QuitSDL

Mais si j'ai 50 images, est-ce la bonne solution de traiter individuellement le cas de chargement pour chaque image ?
Je pourrais bien faire un tableau d'images et si l'image 23 n'est pas chargée correctement, désinstaller les images 1->22.
Mais dans ce cas les images vont s'appeler image[i]. Comment faire si mes images s'appellent fourchette, cuillère, couteau,...
De plus, pour charger une image, j'ai 3 risques d'erreurs (avec la surface, la texture, la transparence). (
Je suis un peu perdu pour trouver une bonne méthode.
Comment me conseillez-vous de traiter la vérification des bons chargements et leur destruction en cas de problème ?

Merci à ceux qui voudront bien me conseiller
ChamLudo

17/03/2022, 01h42
Kannagi

Citation:

Mais si j'ai 50 images, est-ce la bonne solution de traiter individuellement le cas de chargement pour chaque image ?
Je pourrais bien faire un tableau d'images et si l'image 23 n'est pas chargée correctement, désinstaller les images 1->22.
Mais dans ce cas les images vont s'appeler image[i]. Comment faire si mes images s'appellent fourchette, cuillère, couteau,...

1) il faut mieux avoir un tableau.
2) il y'a deux façon de faire , la façon la plus simple et tout simplement de renommer vos fichier
L'autre est de faire un petit langage de script qui gère les ressources
3) avoir 50 image est une mauvaise idée , en général on va avoir une grosse image (ou plusieurs grosse image ) et on va découper avec SDL_Rect

Citation:

Comment me conseillez-vous de traiter la vérification des bons chargements et leur destruction en cas de problème ?

Le plus simple , c'est de ne pas faire du C :aie:
Le C est assez mauvais pour les gestions d'erreurs ,sinon ben on regarde si l'adresse est valide tout simplement , après c'est libre au programmeur de faire ce qu’il veut avec (comme stopper tout simplement le programme est indiquer l'erreur "manque tel ressource" ).
17/03/2022, 08h54
chamludo

Merci de ta réponse.
En fait, j'ai déjà des images contenant plusieurs autres images et je n'en colle qu'une sélection.
Par exemple : Image assiette (pleine +vide), verre (plein+vide), cuillère (petite, grosse), couteau (fromage, pain, beurre). De plus la dimension n'est pas la même (rectangle carré, gros/petits. Est-ce gênant ?).
Si je veux mettre le couteau.beurre à droite de assiette.vide et devant verre.plein, cela me semble plus facile à comprendre que de mettre Image[1] à droite de Image[2] et devant Image[3].
Serait-ce une bonne idée de tout regrouper en une seule image (donc un seul chargement + transparence) pour obtenir une texture générale(Image) puis séparer ensuite ma texture en textures plus petites (Assiette, verre, couteau, de texture a texture, il y a moins de vérifications a faire il me semble) puis choisir la bonne sélection dans ces petites textures.

Ou alors me conseilles-tu de tout regrouper en une seule image ? et d'utiliser Image [i] pour sélectionner la bonne partie, quitte à perdre le sens de l'image que je colle ?
17/03/2022, 09h47
Kannagi

Alors je te préconise cette solution :

Citation:

Serait-ce une bonne idée de tout regrouper en une seule image (donc un seul chargement + transparence) pour obtenir une texture générale(Image) puis séparer ensuite ma texture en textures plus petites (Assiette, verre, couteau, de texture a texture, il y a moins de vérifications a faire il me semble) puis choisir la bonne sélection dans ces petites textures.

Enfin la séparation peut se faire seulement avec SDL_Rect :)
donc une grosse image qui contient tout , et ensuite SDL_Rect pour l'affichage.

Citation:

De plus la dimension n'est pas la même (rectangle carré, gros/petits. Est-ce gênant ?)

Nullement

Citation:

Si je veux mettre le couteau.beurre à droite de assiette.vide et devant verre.plein, cela me semble plus facile à comprendre que de mettre Image[1]

Sauf si tu as des algo spécifique pour chaque , je pense pas que ça soit nécessaire de savoir ce que c'est exactement comme type d'image (après tu peux très bien y'aller en define : image[ASSIETE_PLEINE
Mais je te conseille de faire seulement une grosse image :)
17/03/2022, 22h30
chamludo

Merci de tes conseils. Je vais essayer quand j'aurai un moment
23/03/2022, 21h26
chamludo

Bonsoir, me voici de retour.
Dans mon précédent message j'avais 3 images Pièce jointe 616058 et Pièce jointe 616059 et Pièce jointe 616056.
pour un rendu Pièce jointe 616060
J'avais une fonction qui chargeait image1, image2,...avec la couleur blanche transparente. Puis j'affichais la coupe, puis guizmo (en bas-droite, en transparent alpha), puis guizmo (sélection en bas-gauche, non transparent), puis guizmo légèrement au dessus (grand guizmo réduit, ce qui dégrade l'image).

Comme conseillé, j'ai tout regroupé en une seule image, avec la même fonction qui charge et rend le blanc transparent. J'introduis plusieurs SDL_Rect pour sélectionner les morceaux à coller afin de retrouver l'équivalent de mes anciennes images. Sommes-nous bien d'accord que les SDL_QueryTexture ne servent plus a rien car je suis obligé de les connaitre avant pour sélectionner le bon rectangle?
Voici l'image finale :Pièce jointe 616057
Cependant j'ai maintenant un problème avec les 2 dernières images qui ne doivent plus être transparente alpha. J'ai utilisé SDL_SetRenderDrawBlendMode(Renderer,SDL_BLENDMODE_NONE). Or comme vous pouvez le voir, le blanc n'est plus transparent.
Dois-je refaire appel à ma fonction qui charge l'image (IMG_Load + SDL_SetColorKey + SDL_CreateTextureFromSurface et retester les bons chargements ? ) ou y a t il un moyen plus rapide de remettre le blanc transparent.
Pièce jointe 616061
Ma méthode est-elle globalement bonne ou y a-t-il des choses que je n'ai pas compris.

Y a-t-il moyen de coller une texture sur une autre texture ?
24/03/2022, 13h14
Kannagi

Les pieces jointe ne marche pas chez moi.

Mais j'ai une question pourquoi ne pas gérer l'alpha directement dans votre image ?

En effet, aucune image n'est visible, je ne sais pas pourquoi. Lorsque j'ai écrit le message tout allait bien bien mais maintenant, plus.

Du coup, je vais te décrire les images :
j'avais 3 images : Logo CB (code block,dimension 150*120, fond noir) + une Coupe (jaune sur fond blanc, dimension 200*200) + Guizmo (deux images sur fond blanc, une grande 200*200 et une petite 150*150 dans des carrés juxtaposés pour une dimension totale de 350*200)
J'avais une fonction qui chargeait image1, image2,...avec la couleur blanche transparente. Puis j'affichais dans une fenêtre 640*480 de fond gris, la coupe (en haut à gauche), puis guizmo (les 2, en bas-droite, en transparent alpha), puis guizmo (sélection du petit en bas-gauche, non transparent alpha).

Comme conseillé, j'ai tout regroupé en une seule image (700*200), avec la même fonction qui charge et rend le blanc transparent. J'introduis plusieurs SDL_Rect pour sélectionner les morceaux à coller afin de retrouver l'équivalent de mes anciennes images.
Sommes-nous bien d'accord que les SDL_QueryTexture ne servent plus à rien car je suis obligé de les connaitre avant pour sélectionner le bon rectangle?
Dans l'image finale, j'ai bien mon fond gris, la coupe OK, mes guizmo en bas à droite transparent et sans blanc OK. Par contre, mon guizmo en bas à gauche n'est plus transparent, mais il est entouré de blanc car il me semble que SDL_SetRenderDrawBlendMode(Renderer,SDL_BLENDMODE_NONE) a désactivé la couleur blanc en transparent.

Voici ce que j'ai écrit pour la transparence alpha :
Code:

1 2 3 4 5 6 7 8 9 10 11 SDL_SetRenderTarget(Renderer, Jeton.Texture1);//on travaille sur la texture et plus sur le renderer SDL_SetTextureBlendMode(Jeton.Texture1, SDL_BLENDMODE_BLEND);// texture transparente SDL_SetTextureAlphaMod(Jeton.Texture1, 8);//affichage de la texture3 avec une transparence de 8 /255 SDL_SetRenderTarget(Renderer, NULL);//on retourne sur le renderer et plus sur la texture SDL_RenderCopy(Renderer, Jeton.Texture1, &selection3, &position3);//on colle la texture sur le renderer SDL_RenderPresent(Renderer);//actualisation du renderer // SDL_SetTextureAlphaMod(Jeton.Texture1, 0);//affichage de la texture3 avec une transparence de 8 /255 SDL_SetTextureBlendMode(Jeton.Texture1, SDL_BLENDMODE_NONE);// fin texture transparente //pbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb SDL_RenderCopy(Renderer, Jeton.Texture1, &selection3a, &position4);//on colle la texture dans le coin en bas a gauche et uniquement une selection, reduite SDL_RenderPresent(Renderer);//actualisation du renderer
selection3 correspond aux deux guizmo, ceux qui seront en transparence alpha (8/255)
selection3a correspond au guizmo que je veux afficher en couleur normale sauf le blanc

Concerant ta question " pourquoi ne pas gérer l'alpha directement dans votre image ?".
Si je définis le blanc en transparent, cela le fait pour toute l'image ainsi que les sélections. C'est ce que je veux.
Si je définis la transparence alpha, cela va s'appliquer à toute l'image ainsi que les sélections alors que je veux des sélections couleur normale, et d'autres transparentes. A moins que je me trompe.

05/05/2022, 07h38
LittleWhite

Bonjour,

Je ne sais pas pourquoi vous avez regroupé les trois images, mais c'est un détail (je n'ai pas relu la discussion).
Par contre, je sais que vous pouvez gérer toutes la transparence directement dans l'image (avec le format PNG (il faut SDL_Image pour ça) et peut être BMP 32bits). C'est bien plus simple et ainsi, avec Gimp (ou autre) vous faites exactement l'image que vous voulez (c'est-à-dire : si vous voulez de la transparence, vous placez des pixels transparents, sinon, vous placez la couleur que vous voulez).
Autrement, n'hésitez pas à nous montrer ce que vous voulez obtenir avec des images :P

Bonjour LittleWhite,
Je viens, par hasard, voir que tu m’avais envoyé un message.
Pour faire un résumé, je suis passé de la sdl1 à la sdl2 (suite à un changement d’ordi), donc j’essaie de comprendre comment fonctionnent les modifications entre les deux sdl, afin de modifier/améliorer mes programmes existants.
Donc je me suis entrainé sur les images.
En fait j’avais 3 images séparées (logo CB pour CodeBlocks, coupe, Guizmo) que je voulais charger, afficher, libérer et gérer le problème si par exemple le 2eme chargement échoue (il faut libérer CB mais pas les 2 autres).
On m’avait conseillé de tout regrouper dans UNE seule image et de sélectionner les morceaux que je souhaite afficher. Mais j’avais un problème pour gérer la transparence alpha sur une partie : si je voulais sélectionner une partie d’image mais que je l’affiche une fois normalement, puis une fois transparente alpha, alors la totalité de l’image devient transparente. De plus, avec cette méthode on est obligé de connaitre la taille de l’image pour pouvoir sélectionner le bon rectangle, ce qui finalement pose plus de contrainte (à mon avis).
Finalement, ce n’est pas grave car j’ai trouvé une solution en gardant mes 3 images distinctes (que je nomme image1, image2, image3).
Merci de m’avoir indiqué le format png, avec une zone déjà transparente, je ne savais pas que cela fonctionnait et cela m’a l’air bien pratique sur mes quelques exemples effectués.

Voici ce que j’ai fait pour charger les images:
- créer une structure contenant mes SDL_Texture *Image[4] et mes SDL_Rect Dimension[4].
- créer une fonction int ChargementImages(SDL_Renderer *Renderer, Images *Jeton, int *NbImagesChargees) qui charge mes images et attribue leur dimension
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 typedef struct Images Images; struct Images { SDL_Texture *Image[4];//tableau de 4 images SDL_Rect Dimension[4] ; //pour chaque image, dimensionner w et h }; /**********************************/ int ChargementImages(SDL_Renderer *Renderer, Images *Jeton, int *NbImagesChargees) { char *ListeNomFichier[] = {"image-cb.bmp","image-CoupeGrande.bmp","image-Guizmo.png","image-GuizmoT.png"};//liste des fichiers d'images à charger int chargement=0;//[0 : pas d'erreur][1 : erreur] int I; for (i=0; i<4; i++) { Jeton->Image[i]=Chargement(Renderer,ListeNomFichier[i],couleurImageBlanc);// chargement des autres image+transparence if(Jeton->Image[i]==NULL)//si pb de chargement { // LiberationImages(Jeton, NbImagesChargees); chargement=1; return chargement;//renvoi erreur } else {*NbImagesChargees=(*NbImagesChargees)+1; SDL_QueryTexture(Jeton->Image[i], NULL, NULL, &(Jeton->Dimension[i]).w, &(Jeton->Dimension[i]).h);} } fprintf(fichierErreur, "Nombre d'images correctement chargées %d \n :", *NbImagesChargees); return chargement; } /**********************************/

21/05/2022, 11h18
LittleWhite
Quelques remarques :
- l'histoire de regrouper les images dans une seule : c'est de la complexité pour rien. Je ne vois pas d'avantage (il peut y en avoir, mais là, je n'en vois pas) et cela apporte des difficultés supplémentaires. Toutefois, c'est une piste que vous pourriez avoir envie de recommencer, si vous souhaitez vous entraîner en programmation ;)
- c'est cool que vous ayez une fonction de chargement. Le chiffre 4, est un nombre magique. Vous pourriez la définir comme constante : static const unsigned int NB_IMAGES = 4 et utiliser cette constante au lieu d'avoir des 4 partout (cela évite des erreurs par la suite et rend le code un peu plus clair).
- la variable chargement pourrait être un enum pour augmenter le code en clarté (un int peut contenir n'importe quoi, un enum donne quelques clarifications sur son but)
21/05/2022, 22h25
chamludo

* Pour le 1er point, je suis d'accord avec vous, c'est pour cela que la solution qui m'était proposée de tout regrouper ne me convenait pas trop, surtout que les images n'ont pas toute la même dimension.

* pour le 2eme point, je le faisais déjà. En fait, mon dernier jeu était un jeu de morpion et j'avais un dossier de #define, enum,... dont un pour le nombre d'images.

* pour la variable chargement qui pourrait être un enum, c'est une bonne idée mais que j'utilise peu (mais un peu quand même) car il me semble qu'il ne puisse pas avoir le même mot clé dans deux enum. Imaginons que j'ai deux enum VIDEO et IMAGE ayant pour valeur VIDEO {vide, action, suspense, ...} et IMAGE {vide, paysage, animaux, ...}, il me semble que je ne puisse pas utiliser "vide" dans les deux listes et je trouve moche d'utiliser "vide", "Vide", "VIDE",...

* Pour revenir à mon jeu de morpion, qui ne fonctionne absolument plus car il est écrit en sdl1 et pas en sdl2, c'est pour cela que je faisais les tests postés pour pouvoir remplacer facilement les anciennes fonctions, il y a possibilité de choisir de choisir entre 24 images différentes pour les pions (rond, croix, ... , theme starwars, harry potter, grelins, mario,... ), associés à diverses musiques. jeu humain-humain, ordi-humain, ordi-ordi,... avec ou sans suggestion de meilleurs coups, annulation des coups précédents, ... et surtout, dimension modifiable de 3*3, jusqu'à 30*30, ainsi que le nombre de pions à aligner (de 3 à 5). Bien sur, selon le nombre de cases, la tailles des images est différentes donc j'ai plusieurs versions de la même image, puisque la simple réduction dégrade trop l'image.
J'étais en train de programmer un mode tournoi, jusqu'à 10 manches, complétement paramétrable, quand mon ordi m'a lâché.
Le seul problème, c'est pour l'IA de l'ordi, il me semble que à partir d'une taille trop importante, ca rame dur, normal car il y a trop de cas à analyser (pour le 20*20, il y a environ 400 cas à chaque fois), même si j'ai réussi à réduire le nombre de cas à analyser. Connaissez-vous une solution autre que le minmax et le alphabeta ?
22/05/2022, 10h20
LittleWhite

Citation:

Envoyé par chamludo

* pour la variable chargement qui pourrait être un enum, c'est une bonne idée mais que j'utilise peu (mais un peu quand même) car il me semble qu'il ne puisse pas avoir le même mot clé dans deux enum. Imaginons que j'ai deux enum VIDEO et IMAGE ayant pour valeur VIDEO {vide, action, suspense, ...} et IMAGE {vide, paysage, animaux, ...}, il me semble que je ne puisse pas utiliser "vide" dans les deux listes et je trouve moche d'utiliser "vide", "Vide", "VIDE",...

J'avoue, ici, je n'ai plus la certitude sur la bonne façon de faire. J'utilise maintenant majoritairement le C++ qui a réglé ce souci. En C, vous pourriez utiliser des define. Cela sera pas super beau en terme de vérification du type par le compilateur, mais au moins, le code sera un peu plus clair.

Citation:

* Pour revenir à mon jeu de morpion, qui ne fonctionne absolument plus car il est écrit en sdl1 et pas en sdl2, c'est pour cela que je faisais les tests postés pour pouvoir remplacer facilement les anciennes fonctions, il y a possibilité de choisir de choisir entre 24 images différentes pour les pions (rond, croix, ... , theme starwars, harry potter, grelins, mario,... ), associés à diverses musiques. jeu humain-humain, ordi-humain, ordi-ordi,... avec ou sans suggestion de meilleurs coups, annulation des coups précédents, ... et surtout, dimension modifiable de 3*3, jusqu'à 30*30, ainsi que le nombre de pions à aligner (de 3 à 5). Bien sur, selon le nombre de cases, la tailles des images est différentes donc j'ai plusieurs versions de la même image, puisque la simple réduction dégrade trop l'image.
J'étais en train de programmer un mode tournoi, jusqu'à 10 manches, complétement paramétrable, quand mon ordi m'a lâché.
Le seul problème, c'est pour l'IA de l'ordi, il me semble que à partir d'une taille trop importante, ca rame dur, normal car il y a trop de cas à analyser (pour le 20*20, il y a environ 400 cas à chaque fois), même si j'ai réussi à réduire le nombre de cas à analyser. Connaissez-vous une solution autre que le minmax et le alphabeta ?

Je crois que la SDL 2 est meilleure pour faire un redimensionnement lorsque la taille de destination ne correspond pas à la taille de la texture.
Je ne vois pas de raison qui vous empêche d'installer la SDL 1 sur votre nouveau PC.
Pour l'IA, je ne saurais répondre.
22/05/2022, 14h28
Tonton Nico

Salut,

Juste un point qui m'interpelle, quand tu dis

Citation:

Envoyé par chamludo

Le seul problème, c'est pour l'IA de l'ordi, il me semble que à partir d'une taille trop importante, ca rame dur, normal car il y a trop de cas à analyser (pour le 20*20, il y a environ 400 cas à chaque fois), même si j'ai réussi à réduire le nombre de cas à analyser. Connaissez-vous une solution autre que le minmax et le alphabeta ?

Cela veux dire que même pour un morpion 3x3 tu as fais toute les grilles/configuration possibles et donc déterminer 1 par 1 le mouvement de l'IA en réponse? ou j'ai mal compris ta façon de faire peut être ^^

cdt
22/05/2022, 23h20
chamludo

Pour LittleWhite, je connais bien les define et j'en utilise plein pour paramétrer les dimensions de ma fenêtre, de ma zone jeu, la position des boutons, la largeur des traits, les couleurs à rendre transparentes et pour écrire les textes, ...

Il existait en SDL1 une fonction pour réduire la taille d'une image mais le résultat final était flou.
J'ai essayé en sdl2 de faire :
- une image de dimension 200*200,
- une image presque identique 100*100
- afficher l'image 200*200 en normal
- afficher l'image 200*200 réduite en 100*100
- afficher l'image 100*100 en normale
Finalement, je trouve l'image réduite "moche", il y a des coupures, des traits qui apparaissent,...
C'est pour cela que dans mon jeu de morpion, chaque modèle de jeton est en 12 exemplaires (car j'ai 12 tailles possibles en largeur et en hauteur) et selon le nombre de cases voulues, de 3 à 30, je choisis la bonne taille.

Je ne suis pas resté en sdl1 pour une raison bien simple, elle ne fonctionne plus.
En changeant mon ordi qui m'a planté, je suis passé de windows 7 à windows 10 et de code block 17 à codeblock 20, et là impossible de réinstaller sdl1, donc je suis passé à la sdl2. De toute façon, il faut bien évoluer et ça me permet de modifier mes anciens jeu en corrigeant des choses que j'avais mal conçues à l'époque. Par exemple dans mes 1ers jeu, je chargeais les images à chaque fois que je voulais l'afficher, chose que je ne faisais plus dans mes jeux plus récents.

Pour Tonton Nico, voici ce que j'ai fait "en gros" :
- j'ai un plateau de jeu de taille 600*600pixels, partagé en 9 cases de 200px chacune et il faut aligner 3 pions.
- j'ai cherché les diviseurs de 600 qui me semblaient intéressants et j'en ai conservé 12 : 200, 150, 120, 100, 75, 60, 50, 40, 30, 25, 24, 20; d'où les 12 versions du même motif dont je parlais précédemment
- ce qui me donne un certain nombre de cases possibles : 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 25, 30
- en cours de jeu, je peux changer les dimensions du plateau et le vider, par exemple 5 cases sur 10 et comme aligner 3 jetons est trop facile dans ce cas, je décide d'aligner 3 ou 4 ou 5 jetons.
- à part certains cas bien particuliers, comme 3*4 où aligner 4 cases n'est possible qu'horizontalement (ou verticalement), le principe fonctionne assez bien.
- ensuite pour l'IA, en fonction du nombre de cases et du nombre de jetons à aligner, je définis une "zone de recherche" autour des jetons déjà joués (si on a commencé en haut à gauche, je ne vais pas essayer en bas à droite. Je sélectionne la place des jetons le plus en haut, en bas, à gauche, à droite et je rajoute/soustrait le nombre de jetons à aligner (sans sortir du jeu), au début de la partie, pour les grandes dimensions, cela réduit vraiment le nombre de cas à étudier.
Bien entendu, sur une grille 20*30 avec 5 jetons à aligner, si je joue la case 0 (tout en haut gauche alors je ne teste qu'un carré de 5 cases de coté autour soit 25 cases moins celle jouée mais si je joue la case environ 149 = 10*15 au centre du plateau, ma zone de recherche part de 5 vers la gauche sur 5 vers la droite et 5 vers le haut jusqu'à 5 vers le bas, soit environ un carré de 10*10 = 100 cases
- le nombre de coups étudié dépend du nombre de jetons à aligner : l'ordi calcule "puis-je gagner en 1 coup ?", si non, "l'adversaire peut-il gagner en 1 coup ?", si non "puis-je gagner en 2 coups ?",... A chaque question, le nombre de possibilité augmente. Bien entendu si un seul pion a été joué par l'ordinateur, il ne peut pas espérer gagner en jouant un seul coup, donc il passe dierectmtn à si je joue 2 coups. Bien sur, ça dépend du nombre de coups de l'adversaire qui a peut être commence la partie et qui lui peut peut-être gagner en 1 coup, donc il faudrait le contrer
- J'ai réduis le nombre de coups testés en faisant ceci :
Case du plateau:
1-2-3
4-5-6
7-8-9
O commence puis X
1-X-3
4-O-6
7-8-9
Comme il n'est pas possible de gagner en 1 coup pour O, il va tester en 1-3-4-6-7-8-9, puis la réplique de X puis les cases restantes pour O,...
Mais si O joue 1 puis 3, c'est comme s'il avait joué 3 puis 1, donc inutile de réétudier le coup, et ceci permet de réduire le nombre de cas.
En fait, j'ai fait déterminer et étudier à l'ordi toutes les combinaisons/permutations possible de 1 puis 2 puis 3 puis ... nombres dont le 1er, 3eme, 5eme nombre sont rangés dans l'ordre croissant et ainsi que le 2eme, 4eme, 6eme.

J'espère ne pas avoir été trop confus
Je ne sais pas trop si j'ai répondu à ta question que j'ai du mal à interpréter, mais je traite le cas 3*3 comme tous les autres cas, même si je sais qu'il y a des stratégies plus rapides pour le 3*3 comme "si le jeton est en ..., alors il faut jouer en ...", mais il faut avoir étudié les configurations avant