Discussion :

[kev484]

Bonjour,

Je dois réaliser en C un programme permettant à un joueur de poker d'avoir une aide. Avec mon binôme nous avons donc décider de faire une interface graphique lui permettant de faire apparaitre ses cartes en main, le flop, la turn et la river. Et faire dans des cadres autour de la table de poker un cadre pour la cote du pot, un autre pour son pourcentage de gagner le coup...

Est-ce possible de faire tout cela avec la SDL?

Merci d'avance

[coyotte507]

Parfaitement, mais le calcul de probabilité et tout ce sera pas la SDL qui le fera :p

Bonne chance

[kev484]

Oui j'ai pratiquement fini le programme en langage C "basique".

Merci de votre réponse

[SofEvans]

Si vous n'avez pas commencé a apprendre la SDL, je vous conseille de vous tourner vers la SFLM.

Sur le fond, c'est plus ou moins la meme chose : gestion 2D, mais la SDL et vielle et desfois lente (ca va dependre si vous fait beaucoup d'effet style rotation et compagnie) alors que la SFLM profite de l'acceleration materielle et est donc beaucoup plus rapide.

De plus, la SFLM est ecrite en C++, ce qui permet de profiter des constructeur/destructeur et autre joyeuseté.

Si vous souhaitait vraiment coller au C, SDL est un bon choix (quoique SFLM et C ne sont pas incompatible).

[kev484]

Merci pour cette piste que je vais scruter. Mon projet ne doit etre fait que en C.

Merci

[SofEvans]

Je pense m'etre mal fait comprendre.

Comme SFLM est ecrit en C++, il y aura besoins de faire appel a des fonction membre de classe en passant par l'operateur '.', ce qui aura pour effet de donner au code ce style :

Code :

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

1
2
// Ceci crée une fenêtre plein-écran
App.Create(sf::VideoMode(800, 600, 32), "SFML Window", sf::Style::Fullscreen);

C'est kuste que c'est destabilisant pour quelqu'un qui n'a jamais fait d'orienté objet, mais c'est pas un chemin de croix non plus.

Donc voila, apprendre la SDL peut etre une option, mais SFLM fait la meme chose (en plus simple et plus performant ^^).

[Mat.M]

Merci pour cette piste que je vais scruter. Mon projet ne doit etre fait que en C.

Merci

tu ne peux pas programmer SFML en C ; il faut utiliser des classes comme le dit SofEvans.
Sinon prendre SDL.
Mais perso je prendrais plutot directement Open GL quitte à afficher directement des cartes en 3d temps réel...
Ce sont de simples "quad" texturés donc pour qui connait Open GL un minimum c'est pas sorcier à faire.

[Franck.H]

Prend la SDL surtout si tu programmes en C ! On peut apprendre les bases de la SDL en un week-end et on peut déjà en faire quelques bons trucs. OpenGL bin c'est bien mais plus long à mettre en oeuvre sans compter le système de fenêtrage (quoique SDL permet aussi de programmer avec OpenGL tout en profiter des bibliothèques additionnelles pour charger des images, lire des sons, etc...)

SFML... s'il faut mélanger du C au C++ ca va pas le faire, surtout si le C est imposé !

[kev484]

Merci pour vos réponses mais je me suis lancé avec SDL. On verra bien.

Voial le premier truc que je souhaiterai afficher :

- ma fenêtre avec comme fond une table de poker. Pas de problemes ...

- dans ma fenètre, une série de carte de couleur coeurs enregistrées dans le dossier de mon projet. Voila mon 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
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
#include <stdlib.h>
#include <stdio.h>  
#include <SDL/SDL.h> // Librairie SDL
 
void pause();
 
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *imageDeFond = NULL, *cartesCoeurs[] = {NULL};
    SDL_Rect positionFond;
    SDL_Rect positionCartesCoeurs;
    int i;
 
    positionFond.x = 0;
    positionFond.y = 0;
 
    positionCartesCoeurs.x = 600;
    positionCartesCoeurs.y = 300;
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE);
    SDL_WM_SetCaption("Chargement d'images en SDL", NULL);
 
    /* Chargement d'une image Bitmap dans une surface */
    imageDeFond = SDL_LoadBMP("Table Poker.bmp");
    /* On blitte par-dessus l'écran */
    SDL_BlitSurface(imageDeFond, NULL, ecran, &positionFond);
 
    /* Chargement des immages de Couleur Coeur */
 
    cartesCoeurs[1] = SDL_LoadBMP("image1.bmp");
    cartesCoeurs[2] = SDL_LoadBMP("image2.bmp");
    cartesCoeurs[3] = SDL_LoadBMP("image3.bmp");
 
    /* On blitte par-dessus l'écran */
    for( i = 1 ; i <= 3 ; i++){
        SDL_BlitSurface(cartesCoeurs[i], NULL, ecran, &positionCartesCoeurs);
        positionCartesCoeurs.x = positionCartesCoeurs.x + 3;
   }
 
    SDL_Flip(ecran);
    pause();
 
    SDL_FreeSurface(imageDeFond); /* On libère la surface */
    SDL_FreeSurface(cartesCoeurs);
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}

Si je ne mets pas sa cela marche très bien :

/* Chargement des immages de Couleur Coeur */

cartesCoeurs[1] = SDL_LoadBMP("image1.bmp");
cartesCoeurs[2] = SDL_LoadBMP("image2.bmp");
cartesCoeurs[3] = SDL_LoadBMP("image3.bmp");

/* On blitte par-dessus l'écran */
for( i = 1 ; i <= 3 ; i++){
SDL_BlitSurface(cartesCoeurs[i], NULL, ecran, &positionCartesCoeurs);
positionCartesCoeurs.x = positionCartesCoeurs.x + 3;
}

J'ai un écran noir avec. Ou est mon erreur?

Merci d'avance

[Franck.H]

As-tu des erreurs lors de la compilation ou des warning ? Déjà pour le tableau de cartes je ferais plutôt:

Code :

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

SDL_Surface *cartesCoeurs[3] = { NULL };

Je ne sais pas si tu programmes en C99 ou une version du C antérieur mais il faut préciser la dimension de ton tableau en C89/C90 !


EDIT:
Ceci également est faux:

Code :

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

SDL_FreeSurface(cartesCoeurs);

il faut faire:

Code :

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

1
2
3
4
for (i = 0; i < 3; i++)
{
   SDL_FreeSurface (cartesCoeurs[i]);
}

EDIT 2:
Faux:

Code :

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

1
2
3
4
5
    /* Chargement des immages de Couleur Coeur */
    
    cartesCoeurs[1] = SDL_LoadBMP("image1.bmp");
    cartesCoeurs[2] = SDL_LoadBMP("image2.bmp");
    cartesCoeurs[3] = SDL_LoadBMP("image3.bmp");

Code :

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

1
2
/* On blitte par-dessus l'écran */
    for( i = 1 ; i <= 3 ; i++){

Un tableau commence en C à l'index 0 non 1 !

[kev484]

Exact c'est un oubli de ma part. Merci beaucoup l'effet souhaité fonctionne maintenant. Je pense revenir rapidement vers vous pour d'autres questions.

[Mat.M]

Si je ne mets pas sa cela marche très bien :

J'ai un écran noir avec. Ou est mon erreur?

Merci d'avance

C'est normal il faut que le programme boucle continuellement sur SDL_BlitSurface(nom_de_surface) et Flip(Ecran) !
A l'heure actuelle ton programme boucle dans ta fonction pause..
il faut faire une fonction render().
Regarde dans les tutos de Developpez il y a des tutos de Loka je crois sur SDL je te conseille de t'en inspirer.

[kev484]

J'ai finalement fait comme cela

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
#include <stdlib.h>
#include <stdio.h>  
#include <SDL/SDL.h> // Librairie SDL
 
void pause();
int afficher_cartes(ecran);
 
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *imageDeFond = NULL;
    SDL_Rect positionFond;
 
    positionFond.x = 0;
    positionFond.y = 0;
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE);
    SDL_WM_SetCaption("Chargement d'images en SDL", NULL);
 
    /* Chargement d'une image Bitmap dans une surface */
    imageDeFond = SDL_LoadBMP("Table Poker.bmp");
    /* On blitte par-dessus l'écran */
    SDL_BlitSurface(imageDeFond, NULL, ecran, &positionFond);
 
    afficher_cartes(ecran);
 
    SDL_Flip(ecran);
    pause();
 
    SDL_FreeSurface(imageDeFond); /* On libère la surface */
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}
 
int afficher_cartes(ecran)
{
    SDL_Surface *cartesCoeurs[3] = {NULL};
    SDL_Rect positionCartesCoeurs;
    int i;
 
    positionCartesCoeurs.x = 300;
    positionCartesCoeurs.y = 500;    
 
/* Chargement des immages de Couleur Coeur */
 
    cartesCoeurs[0] = SDL_LoadBMP("image1.bmp");
    cartesCoeurs[1] = SDL_LoadBMP("image2.bmp");
    cartesCoeurs[2] = SDL_LoadBMP("image3.bmp");
 
  /*   On blitte par-dessus l'écran */
    for( i = 0 ; i < 3 ; i++){
        SDL_BlitSurface(cartesCoeurs[i], NULL, ecran, &positionCartesCoeurs);
        positionCartesCoeurs.x = positionCartesCoeurs.x + 30;
    }
}

Ce n'est pas propre?

[Franck.H]

Ce n'est pas propre?

Le problème n'est pas à la propreté du code, il est assez clair et lisible et présentable mais si ton programme va évoluer, s'agrandir et devenir donc plus complexe, l'organisation de ton code ne tiendra pas la route.

Par exemple, dans ta fonction afficher_cartes tu recharges à chaque appel les images, ce qui n'est pas souhaitable sans compter que tu ne libères pas les surfaces des cartes donc fuites mémoire lors de la fin du programme !

Le mieux si le programme va devenir plus complexe, c'est déjà de hiérarchiser tout ca en commencant par exemple avec une structure qui contiendrais toutes les images:

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
typedef struct
{
   SDL_Surface * cartesCoeurs [3]
   SDL_Rect positionCartesCoeurs
 
   /* Tu peux plus tard ajouter d'autres tableaux de cartes ici !! */
}
Cartes;
 
typedef struct
{
   SDL_Surface * ecran;
   SDL_Surface * imageDeFond;
 
   SDL_Rect positionFond;
 
   Cartes cartes;
}
Interface;

Cette façon de faire te permettra d'ajouter des choses comme ici des tableaux de cartes ou d'autres éléments d'interface dans un seul endroit, la base c'est ca. Cette structure tu la créées dynamiquement dans le main :

Code :

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

1
2
3
4
5
6
7
8
9
10
Interface * interface =  NULL;
 
/* ... */
 
interface = malloc (sizeof (* interface));
 
if (interface != NULL)
{
   /* ... */
}

Tu pourras également créer et c'est même obligé, une fonction de libération de la structure et de tous ses membres que tu appelleras à la fin du programme, cela te permettra d'avoir une seule fonction pour libérer l'interface !

Autre conseil qui peut t'être pratique également, si tu utilises plusieurs fois une même valeur comme ici 3 pour faire référence à la taille de ton tableau de cartes, le mieux serait d'utiliser une constante symbolique ce qui donnerais :

Code :

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

#define CARDS_ARRAY_SIZE 3

Donc partout où tu aurais cette valeur pour ton tableau tu la remplacerais par le nom de cette constante. Dans le cas où ton tableau devrait s'agrandir plus tard, tu n'aurais qu'à changer la valeur de la constante et nulle part d'autre, pratique pour la maintenance du code

Voici en gros quelques conseils et suggestions


Bon courage

[Mat.M]

Salut je crois que je me suis fait mal comprendre

Ce n'est pas propre?

comme le dit Franck.H c'est pas une question de code "propre" ou non.
C'est une question de conception
Typiquement un programme SDL doit être ainsi

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
 
int main(int argc, char *argv[])
{
	SDL_Surface *Ecran;
	SDL_Surface *ImageFond;
	SDL_Surface *Image1;
 
	Uint32 tm1,deltatm;
	SDL_Event event;
	int quit=0;
	int x,y;
	if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
	{
		fprintf(stderr,
			"Impossible d'initialiser SDL: %s\n", SDL_GetError());
		exit(1);
	}
	atexit(SDL_Quit);
	SDL_WM_SetCaption("Jeu Poker", "Jeu Poker");
	Ecran=SDL_SetVideoMode(800,600, 24,SDL_SWSURFACE);
	int colorkey=SDL_MapRGB(m_Ecran->format, 255, 255, 0);
	ImageFond=SDL_LoadBMP("image_fond.bmp");
	Image1=SDL_LoadBMP("image1.bmp");
	SDL_SetColorKey(Image1,SDL_SRCCOLORKEY ,colorkey);
	tm1=deltatm=SDL_GetTicks();
	while( !quit )
	{	
		deltatm=SDL_GetTicks();
 
		SDL_BlitSurface(ImageFond,NULL,Ecran,NULL);
		SDL_BlitSurface(Image1,NULL,Ecran,NULL);
		SDL_Flip(Ecran);
		if( deltatm-tm1>50)// regler la tempo en ms au besoin
		{///faire action
			deltatm=SDL_GetTicks();
		}
		while( SDL_PollEvent( &event ) )
		 {
			switch( event.type )
			{
			  case SDL_KEYDOWN:
				  switch( event.key.keysym.sym )
				  {
					case SDLK_ESCAPE:
						quit=1;
					break;
				}
 
			}
		}
	}
 
	SDL_FreeSurface(ImageFond);
	SDL_FreeSurface(Image1);
	SDL_FreeSurface(Ecran);
	SDL_Quit();
	exit(0);
}

donc tu vois qu'il faut un while()..{render()}

[Mat.M]

Pour gérer les cartes tu peux utiliser des listes chainées

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
typedef struct stCarteJoueur
{
	SDL_Surface *Image = {NULL};
    SDL_Rect position;
};
 
typedef struct stListeCartes
{
	stCarteJoueur * element_suivant;
	stCarteJoueur * element_precedent;
};

Je te laisse écrire le code pour gérer cela

[SofEvans]

Salut je crois que je me suis fait mal comprendre


comme le dit Franck.H c'est pas une question de code "propre" ou non.
C'est une question de conception
Typiquement un programme SDL doit être ainsi

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
 
int main(int argc, char *argv[])
{
	SDL_Surface *Ecran;
	SDL_Surface *ImageFond;
	SDL_Surface *Image1;
 
	Uint32 tm1,deltatm;
	SDL_Event event;
	int quit=0;
	int x,y;
	if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
	{
		fprintf(stderr,
			"Impossible d'initialiser SDL: %s\n", SDL_GetError());
		exit(1);
	}
	atexit(SDL_Quit);
	SDL_WM_SetCaption("Jeu Poker", "Jeu Poker");
	Ecran=SDL_SetVideoMode(800,600, 24,SDL_SWSURFACE);
	int colorkey=SDL_MapRGB(m_Ecran->format, 255, 255, 0);
	ImageFond=SDL_LoadBMP("image_fond.bmp");
	Image1=SDL_LoadBMP("image1.bmp");
	SDL_SetColorKey(Image1,SDL_SRCCOLORKEY ,colorkey);
	tm1=deltatm=SDL_GetTicks();
	while( !quit )
	{	
		deltatm=SDL_GetTicks();
 
		SDL_BlitSurface(ImageFond,NULL,Ecran,NULL);
		SDL_BlitSurface(Image1,NULL,Ecran,NULL);
		SDL_Flip(Ecran);
		if( deltatm-tm1>50)// regler la tempo en ms au besoin
		{///faire action
			deltatm=SDL_GetTicks();
		}
		while( SDL_PollEvent( &event ) )
		 {
			switch( event.type )
			{
			  case SDL_KEYDOWN:
				  switch( event.key.keysym.sym )
				  {
					case SDLK_ESCAPE:
						quit=1;
					break;
				}
 
			}
		}
	}
 
	SDL_FreeSurface(ImageFond);
	SDL_FreeSurface(Image1);
	SDL_FreeSurface(Ecran);
	SDL_Quit();
	exit(0);
}

donc tu vois qu'il faut un while()..{render()}

Euh, je ne suis pas vraiment daccord. Normalement, (enfin, cela n'engage que moi, mais ...) le timer sert a gerer les action et le rafraichiseement d'image.
Or dans ton code, tu blit en dehors du timer, ce qui est illogique car comme tu ne fais aucune action, le blit sera toujours le meme. Et si une animation ne depend pas du timer, alors on perd toute utilité du timer.

Le schema que je propose est plus de ce style :

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
 
int main(int argc, char *argv[])
{
	if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
	{
		fprintf(stderr, "Impossible d'initialiser SDL: %s\n", SDL_GetError());
		exit(EXIT_FAILURE);
	}
 
	SDL_Surface *Ecran=SDL_SetVideoMode(800,600, 24,SDL_SWSURFACE);
        if (Ecran == NULL)
        {
		fprintf(stderr, "Impossible de creer la fenetre d'affichage : %s\n", SDL_GetError());
		exit(EXIT_FAILURE);   
        }
 
 
	Uint32 tempsPrecedent, tempsActuel;
 
	int continuer=1;
	while(continuer)
	{	
 
                /* Recuperation des controle */
	        SDL_Event event;
		while( SDL_PollEvent( &event ) )
			switch( event.type )
			{
			  case SDL_KEYDOWN:
				  switch( event.key.keysym.sym )
				  {
					case SDLK_ESCAPE:
						continuer=0;
					break;
				}
 
			}
 
 
                /* Recuperation du temps et action avec 60 FPS */
		tempsActuel=SDL_GetTicks();
                if (tempsActuel - tempsPrecedent > 1000/60)
                {
                    /* Action sur tout */
 
                    /* Blit de l'ecran en totalité */
		    SDL_Flip(Ecran);
                    tempsPrecedent = tempsActuel ;
                }
	}
 
 
	SDL_FreeSurface(Ecran);
	SDL_Quit();
	return EXIT_SUCCESS;
}

Voila, le code est presque le meme. Je tient juste a preciser que je prefere "coller" la recuperation du temps avec le test, car si une operation SDL est intercalé entre les deux, le compteur devient plus ou moins faux (meme si c'est pas d'une heure).

[kev484]

Merci pour toutes ces aides je vais essayer de prendre en compte le max de choses pour refaire mon programme. Voila ce que j'avais déjà fait

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
#include <stdlib.h>
#include <stdio.h>  
#include <SDL/SDL.h> // Librairie SDL
 
void pause();
int afficher_cartes(ecran);
 
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *imageDeFond = NULL;
    SDL_Rect positionFond;
 
    positionFond.x = 0;
    positionFond.y = 0;
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(900, 700, 32, SDL_HWSURFACE);
    SDL_WM_SetCaption("Chargement d'images en SDL", NULL);
 
    /* Chargement d'une image Bitmap dans une surface */
    imageDeFond = SDL_LoadBMP("Table Poker.bmp");
    /* On blitte par-dessus l'écran */
    SDL_BlitSurface(imageDeFond, NULL, ecran, &positionFond);
 
    afficher_cartes(ecran);
 
    SDL_Flip(ecran);
    pause();
 
    SDL_FreeSurface(imageDeFond); /* On libère la surface */
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}
 
int afficher_cartes(ecran)
{
    SDL_Surface *cartesCoeurs[13] = {NULL}, *cartesTrefles[13] = {NULL}, *cartesCarreaux[13] = {NULL}, *cartesPiques[13] = {NULL};
    SDL_Rect positionCartesCoeurs, positionCartesTrefles, positionCartesCarreaux, positionCartesPiques;
    int i;
 
    positionCartesCoeurs.x = 200;
    positionCartesCoeurs.y = 420;
 
    positionCartesTrefles.x = 200;
    positionCartesTrefles.y = 460;
 
    positionCartesCarreaux.x = 200;
    positionCartesCarreaux.y = 500;
 
    positionCartesPiques.x = 200;
    positionCartesPiques.y = 540;
 
 
/* ----------------Chargement des images de Couleur Coeur-------------------- */
 
    cartesCoeurs[0] = SDL_LoadBMP("imageCoeur1.bmp");
    cartesCoeurs[1] = SDL_LoadBMP("imageCoeur2.bmp");
    cartesCoeurs[2] = SDL_LoadBMP("imageCoeur3.bmp");
    cartesCoeurs[3] = SDL_LoadBMP("imageCoeur4.bmp");
    cartesCoeurs[4] = SDL_LoadBMP("imageCoeur5.bmp");
    cartesCoeurs[5] = SDL_LoadBMP("imageCoeur6.bmp");
    cartesCoeurs[6] = SDL_LoadBMP("imageCoeur7.bmp");
    cartesCoeurs[7] = SDL_LoadBMP("imageCoeur8.bmp");
    cartesCoeurs[8] = SDL_LoadBMP("imageCoeur9.bmp");
    cartesCoeurs[9] = SDL_LoadBMP("imageCoeur10.bmp");
    cartesCoeurs[10] = SDL_LoadBMP("imageCoeur11.bmp");
    cartesCoeurs[11] = SDL_LoadBMP("imageCoeur12.bmp"); 
    cartesCoeurs[12] = SDL_LoadBMP("imageCoeur13.bmp");
 
/*   On blitte par-dessus l'écran pour les Coeurs */
    for( i = 0 ; i < 13 ; i++){
        SDL_BlitSurface(cartesCoeurs[i], NULL, ecran, &positionCartesCoeurs);
        positionCartesCoeurs.x = positionCartesCoeurs.x + 30;
    }
/* -------------------Chargement des immges de Couleur Trefles----------------*/  
    cartesTrefles[0] = SDL_LoadBMP("imageTrefle1.bmp");
    cartesTrefles[1] = SDL_LoadBMP("imageTrefle2.bmp");
    cartesTrefles[2] = SDL_LoadBMP("imageTrefle3.bmp");
    cartesTrefles[3] = SDL_LoadBMP("imageTrefle4.bmp");
    cartesTrefles[4] = SDL_LoadBMP("imageTrefle5.bmp");
    cartesTrefles[5] = SDL_LoadBMP("imageTrefle6.bmp");
    cartesTrefles[6] = SDL_LoadBMP("imageTrefle7.bmp");
    cartesTrefles[7] = SDL_LoadBMP("imageTrefle8.bmp");
    cartesTrefles[8] = SDL_LoadBMP("imageTrefle9.bmp");
    cartesTrefles[9] = SDL_LoadBMP("imageTrefle10.bmp");
    cartesTrefles[10] = SDL_LoadBMP("imageTrefle11.bmp");
    cartesTrefles[11] = SDL_LoadBMP("imageTrefle12.bmp"); 
    cartesTrefles[12] = SDL_LoadBMP("imageTrefle13.bmp");
 
/*   On blitte par-dessus l'écran pour les  Trefles*/
    for( i = 0 ; i < 13 ; i++){
        SDL_BlitSurface(cartesTrefles[i], NULL, ecran, &positionCartesTrefles);
        positionCartesTrefles.x = positionCartesTrefles.x + 30;
    }
 
/* -------------------Chargement des immges de Couleur Carreaux---------------*/    
    cartesCarreaux[0] = SDL_LoadBMP("imageCarreaux1.bmp");
    cartesCarreaux[1] = SDL_LoadBMP("imageCarreaux2.bmp");
    cartesCarreaux[2] = SDL_LoadBMP("imageCarreaux3.bmp");
    cartesCarreaux[3] = SDL_LoadBMP("imageCarreaux4.bmp");
    cartesCarreaux[4] = SDL_LoadBMP("imageCarreaux5.bmp");
    cartesCarreaux[5] = SDL_LoadBMP("imageCarreaux6.bmp");
    cartesCarreaux[6] = SDL_LoadBMP("imageCarreaux7.bmp");
    cartesCarreaux[7] = SDL_LoadBMP("imageCarreaux8.bmp");
    cartesCarreaux[8] = SDL_LoadBMP("imageCarreaux9.bmp");
    cartesCarreaux[9] = SDL_LoadBMP("imageCarreaux10.bmp");
    cartesCarreaux[10] = SDL_LoadBMP("imageCarreaux11.bmp");
    cartesCarreaux[11] = SDL_LoadBMP("imageCarreaux12.bmp"); 
    cartesCarreaux[12] = SDL_LoadBMP("imageCarreaux13.bmp");
 
/* On blitte par-dessus l'écran pour les Carreaux */
    for( i = 0 ; i < 13 ; i++){
        SDL_BlitSurface(cartesCarreaux[i], NULL, ecran, &positionCartesCarreaux);
        positionCartesCarreaux.x = positionCartesCarreaux.x + 30;
    }
 
/* -------------------Chargement des immges de Couleur Piques-----------------*/    
    cartesPiques[0] = SDL_LoadBMP("imagePique1.bmp");
    cartesPiques[1] = SDL_LoadBMP("imagePique2.bmp");
    cartesPiques[2] = SDL_LoadBMP("imagePique3.bmp");
    cartesPiques[3] = SDL_LoadBMP("imagePique4.bmp");
    cartesPiques[4] = SDL_LoadBMP("imagePique5.bmp");
    cartesPiques[5] = SDL_LoadBMP("imagePique6.bmp");
    cartesPiques[6] = SDL_LoadBMP("imagePique7.bmp");
    cartesPiques[7] = SDL_LoadBMP("imagePique8.bmp");
    cartesPiques[8] = SDL_LoadBMP("imagePique9.bmp");
    cartesPiques[9] = SDL_LoadBMP("imagePique10.bmp");
    cartesPiques[10] = SDL_LoadBMP("imagePique11.bmp");
    cartesPiques[11] = SDL_LoadBMP("imagePique12.bmp"); 
    cartesPiques[12] = SDL_LoadBMP("imagePique13.bmp");
 
  /*   On blitte par-dessus l'écran pour les Coeurs */
    for( i = 0 ; i < 13 ; i++){
        SDL_BlitSurface(cartesPiques[i], NULL, ecran, &positionCartesPiques);
        positionCartesPiques.x = positionCartesPiques.x + 30;
    }
}

[SofEvans]

C'est encore un peu flou. Cependant :

L'acces a l'espace disque est ce qui prend le plus de temps, donc on ne charge q'une fois les carte au debut, puis on les libere a la fin. De plus, il faut verifier si les images sont correctement chargé.

Pour plus de flexibilité, tu peux faire un tableau qui recapitule les cartes restantes dans le tas (enfin, je pense qu'il y a un tas au poker, je ne sais plus trop ... )
Si tu veux vraiment avoir une gestion dynamique, tu peux faire une liste chainé, sinon, un tableau statique ferai l'affaire.

Test le retour de la fonction SDL_SetVideoMode, si tu as fait une betise qui empeche l'affichage de l'ecran, tu sera au moins prevenue.

Apres, voici encore quelque "truc" :

La variable ecran de SDL_Surface* (donc ta fenetre) est une sorte de variable globale (deguisé certe, mais variable globale quand meme).
On peut donc recuperer cette Surface partout, sans pour autant avoir besoins de la passer par argument.
La fonction est SDL_GetVideoSurface();

Si tu veux blitter une image au point (0,0), tu peux mettre NULL au 4eme parametre de SDL_BlitSurface(..., ..., ..., NULL); Ca evite de declarer un SDL_Rect pour rien et ca allege donc le code.

[Mat.M]

Euh, je ne suis pas vraiment daccord. Normalement, (enfin, cela n'engage que moi, mais ...) le timer sert a gerer les action et le rafraichiseement d'image.
Or dans ton code, tu blit en dehors du timer, ce qui est illogique

tu as parfaitement raison ( c'est d'ailleurs l'intérêt de ce forum ) mais j'ai posté ce code d'un code que j'avais fait pour quelqu'un d'autre.
C'est certain qu'il faut le concevoir de manière optimale

Pour plus de flexibilité, tu peux faire un tableau qui recapitule les cartes restantes dans le tas (enfin, je pense qu'il y a un tas au poker, je ne sais plus trop ... )
Si tu veux vraiment avoir une gestion dynamique, tu peux faire une liste chainé, sinon, un tableau statique ferai l'affaire.

C'est le plus dur à faire
c'est cours sur les probas, terminale scientifique ; il faut revoir combinaisons,probabilités,permutations,arrangements bref de l'amusement en
perspective