Discussion :

[0nn2belle]

Bonjour, j'ai déjà posté pour un problème hier que j'ai réussi à résoudre, mais me revoilà bloquée sur un autre point !
Je m'explique, débutante dans le C++, dans le cadre de mes études je dois réaliser un PacMan en c++.
Là je bosse sur l'apparition des fruits en sdl, tout mon code fonctionne correctement, c'est juste que je reste bloquée sur le fait d'effacer la surface qui contient mon image au bout de 7 secondes.
J'ai compris qu'il fallait que j'utilise SDL_FillRect pour remplacer ma surface par une surface de couleur. Donc ça, ça va, je comprends le fonctionnement.
En revanche, je ne trouve pas comment utiliser le SDL_FillRect.
Voici 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
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
#include <stdlib.h> //En-tête nécessaire pour l'utilisation de exit() et atexit()
#include <stdio.h>
#include <iostream>
#include <windows.h>
#include <time.h>
#include <SDL\SDL.h> //En-tête nécessaire pour l'utilisation de la sdl
 
////////////////////////////////////////////////////////////////////////////////////////
 
SDL_Surface *screen = NULL; //SDL_Surface est utilisé pour une surface d'écran
SDL_Surface *fruit = NULL;
SDL_Surface *fruiti = NULL;
SDL_Surface *background = NULL;
 
//Les attributs de notre écran
const int SCREEN_WIDTH = 600;
const int SCREEN_HEIGHT = 521;
const int SCREEN_BPP = 32;
 
 
//Fonction de chargement d'image
SDL_Surface *load_image(std::string filename)
    {
        SDL_Surface* loadedImage = NULL; //Surface tampon qui nous servira pour charger l'image
        SDL_Surface* optimizedImage = NULL;//L'image optimisée qu'on va utiliser
        loadedImage = SDL_LoadBMP(filename.c_str());//Charge l'image au format bitmap et la met dans la variable tampon
 
        if (loadedImage != NULL) //Si le chargement se passe bien
            {
                optimizedImage = SDL_DisplayFormat( loadedImage ); //Création de l'image optimisée dans le même format que l'écran
                SDL_FreeSurface(loadedImage); //Libération de l'ancienne surface
            }
 
        return optimizedImage; //On retourne l'image optimisée
    }
////////////////////////////////////////////////////////////////////////////
 
//Fonction de blitting
void apply_surface(int x, int y, SDL_Surface* source, SDL_Surface* destination)
    {
        SDL_Rect offset;//SDL_BlitSurface() accepte seulement les offsets dans un SDL_RECT
        offset.x = x;
        offset.y = y;
        SDL_BlitSurface(source, NULL, destination, &offset); //On blitte la surface
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
int main (int argc, char* args[])
{
 
	if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 ) //Initialisation de tous les sous-systèmes de SDL
                                                //Si SDL ne peut pas initialiser il retourne -1
        {
            return EXIT_FAILURE; //EXIT_FAILURE termine le programme si erreur
        }
 
    screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE ); //Mise en place de l'écran
                                                              //SDL_SWSURFACE crée la surface écran dans la mémoire système
    if( screen == NULL ) //Si il y a une erreur dans la création de l'écran
        {
            return EXIT_FAILURE;
        }
 
    SDL_WM_SetCaption( "Hello World", NULL ); //Mise en place de la barre caption (légende sur le haut de la fenêtre)
 
    //Chargement des images
	fruit = load_image("fruita.bmp"); //On utilise la fonction load_image
	fruiti = load_image("fruitb.bmp");
	background = load_image("background.bmp");
 
    apply_surface(0, 0, background, screen); //On applique le fond sur l'écran
 
 
    time_t time_depart; //On crée la variable e qui contient le temps de départ
    time(&time_depart); //On récupère le temps
 
    srand(time(NULL));//Amorçage de rand() //(rdtsc())
    int nbcase = 2;
    int nbrand[nbcase];
    int i; //Je déclare ma variable i
 
    for(i=0; i<nbcase; i++)//Pour i allant de 0 à 2 en croissant
        {
 
            nbrand[i] = ((rand()%10)+(i*20));//Je crée un tableau de taille i contenant les valeurs aléatoires
            std::cout << nbrand[i] << std::endl;
        }
 
    while(true)
    {
        time_t time_actuel; //On crée une 2ème variable qui contient du temps
        time(&time_actuel); //On récupère le temps de la boucle en cours
        int d = time_actuel - time_depart; //La différence entre le temps actuel et le temps de départ
        if (d == nbrand[0])
            {
                apply_surface(0, 1, fruit, screen); //On applique le message sur l'écran
 
            }
 
        if (d == nbrand[1])
            {
                apply_surface(100, 100, fruiti, screen);
                //Pour effacer on utilise SDL_FillRect//
 
            }
        if(d == 40) break;
        if(SDL_Flip(screen) == -1 )//Mise à jour de l'écran
            {
                return EXIT_FAILURE;
            }
        Sleep(100);//Fais une pause dans la boucle (1000 millisecondes)
 
    }
 
 
 
    SDL_Delay (5000);//On attends 5s
 
    //Libération des surfaces
	SDL_FreeSurface (fruit);
	SDL_FreeSurface (fruiti);
	SDL_FreeSurface (background);
 
	//On quitte SDL
	SDL_Quit();
}

Je reprécise que je suis débutante, donc tout ce qui est thread etc. je n'ai pas encore vu, mais si vous avez d'autres idées bien expliquées pour ce qui est d'effacer l'image, je suis prenante !
Merci d'avance !!

[Arzar]

Bonjour,
La SDL c'est du C pas du C++...
Tu auras probablement plus de réponse sur le forum C.

Edit :

En revanche, je ne trouve pas comment utiliser le SDL_FillRect.

D'après la doc, il faut passer en premier paramètre un pointeur vers la surface à colorier, NULL en deuxième paramètre pour colorier toute la surface, et la couleur en troisième paramètre.

Edit 2 : OK, c'est vrai que c'est bien galère pour la couleur
Apparemment, il faut utiliser SDL_MapRGB qui prend en entrée les trois octets (donc de 0 à 255) R, G, et B de la couleur que l'on souhaite et qui donne en sortie un unique Uint32 qu'on peut ensuite passer à SDL_FillRect.