Discussion :

[czar1983]

Salut .
voila j'explique rapidement mon problème en fait j'ai déclaré des pointeurs sur mes variables et j'utilise SDL-Rect afin de placer mes sprites .
j'utilise donc les -> afin de modifier mes positions . mais depuis mon code ne marche plus , le problème vient peut-être quand j'utilise SDL_BlitSurface car a la base je n'utilisai pas de pointeur sur SDL_rect je modifiai donc mes positions via le point (.x ou .y) .
Donc dois je utiliser le signe & dans SDL-BlitSurface pour faire référence à ma position. Voici mon Code Merci

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
#ifdef __cplusplus
#include <cstdlib>
#else
#include <stdlib.h>
#endif
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL_image.h>
#include "Heasders_Collision.h"
#include "SDL/SDL_ttf.h"
#include "SDL/SDL_mixer.h"
int main(int argc, char *argv[])
 
{
    int y;
    int x;
    int continuer = 1 ;
 
 
    SDL_Event event;
    SDL_Surface *ecran = NULL ;
    const SDL_Surface *marioBas = IMG_Load("mario_bas.gif");
    const SDL_Surface *marioHaut = IMG_Load("mario_haut.gif");
    const SDL_Surface *marioDroite = IMG_Load("mario_droite.gif");
    const SDL_Surface *marioGauche = IMG_Load("mario_gauche.gif");
    const SDL_Surface *test_collision = IMG_Load("explosion.jpg");
    SDL_Rect explosion;
    explosion.x = 100;
    explosion.y = 100;
    SDL_Surface *mur , *caisse, *caisse_ok;
    SDL_Rect *position_mur;
    position_mur->h = 34;
    position_mur->w = 34 ;
    position_mur->x  = 34 ;
    position_mur->y =  34 ;
    SDL_Rect *positionmario ;
    positionmario->y = 408/2;
    positionmario->x = 408/2;
    positionmario->h = 34;
    positionmario->w = 34;
 
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
    ecran = SDL_SetVideoMode(408, 408, 32, SDL_HWSURFACE);
    SDL_WM_SetCaption("sobokan", NULL);
    SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
 
    SDL_BlitSurface(marioBas,NULL,ecran,&positionmario);
    SDL_BlitSurface(mur,NULL,ecran,&position_mur);
 
    // de SDL _ Surface pour mes sprites de mario
    SDL_Flip(ecran);
 
    while (continuer)
 
    {
        SDL_WaitEvent(&event);
        switch (event.key.keysym.sym)
        {
        case SDL_QUIT :
            continuer = 0 ;
            break;
        case SDLK_ESCAPE :
            continuer = 0;
            break;
        case SDLK_DOWN :
            positionmario->x = positionmario->x ;
            positionmario->y = positionmario->y + 5;
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            SDL_BlitSurface(mur,NULL,ecran,position_mur);
            SDL_BlitSurface(marioBas,NULL,ecran,positionmario);
            SDL_Flip(ecran);
            break;
        case SDLK_UP :
            positionmario->y = positionmario->y - 5;
            positionmario->x = positionmario->x;
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
 
            SDL_BlitSurface(marioHaut,NULL,ecran,positionmario);
            SDL_BlitSurface(mur,NULL,ecran,position_mur);
            SDL_Flip(ecran);
            break;
        case SDLK_RIGHT :
            positionmario->x = positionmario->x + 5;
            positionmario->y = positionmario->y;
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
 
            SDL_BlitSurface(marioDroite,NULL,ecran,positionmario);
            SDL_BlitSurface(mur,NULL,ecran,position_mur);
            SDL_Flip(ecran);
            break;
 
        case SDLK_LEFT :
            positionmario->x = positionmario->x - 5 ;
            positionmario->y = positionmario->y;
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            SDL_BlitSurface(mur,NULL,ecran,position_mur);
 
            SDL_BlitSurface(marioGauche,NULL,ecran,positionmario);
 
            SDL_Flip(ecran);
            break;
        }
    }
 
    SDL_FreeSurface(ecran);
    SDL_Quit();
    return EXIT_SUCCESS;
}

[Invité]

Bonjour,

Si tu souhaites utiliser des pointeurs, qui je pense est un mal non nécessaire, il faudra penser à les initialiser. Ici tu fixes les valeurs de position_mur et positionmario sans les initialiser.

Code :

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

1
2
positionmario = malloc(sizeof *positionmario);
position_mur = malloc(sizeof * position_mur);

puis évidemment les libérer à la fin :

Code :

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

1
2
free(positionmario );
free(position_mur)

Attention de plus aux lignes 47-48 au & en trop :

Code :

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

1
2
    SDL_BlitSurface(marioBas,NULL,ecran,&positionmario);
    SDL_BlitSurface(mur,NULL,ecran,&position_mur);

Autre chose : tu utilises SDL_Surface *mur ligne 48 sans jamais l'avoir fixé.

N'hésite pas à bien étudier attentivement les messages d'avertissement qu'a dû te donner ton compilateur.

[edgarjacobs]

Si tu souhaites utiliser des pointeurs, qui je pense est un mal non nécessaire,

Je suis de l'avis de Winjerome, il n'y a aucun avantage à utiliser des pointeurs plutot qu'une structure.
Sauf, éventuellement
1) si tu passes ta structure en paramètre, et que l'appelé est supposé mettre à jour un des membres de la structure,
2) tu veux pouvoir tester dans la fonction appelée si une structure à été passée ou non (paramètre à NULL). C'est ce que fait, entre autre, SDL_BlitSurface.

Mais je me pose une question (rien à voir avec le fait d'utiliser ou non les pointeurs): dans le code, on trouve

Code :

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

1
2
3
4
5
6
7
    const SDL_Surface *marioBas = IMG_Load("mario_bas.gif");
    const SDL_Surface *marioHaut = IMG_Load("mario_haut.gif");
    const SDL_Surface *marioDroite = IMG_Load("mario_droite.gif");
    const SDL_Surface *marioGauche = IMG_Load("mario_gauche.gif");
    const SDL_Surface *test_collision = IMG_Load("explosion.jpg");
    ...
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);(

Est-ce prudent de faire cette initialisation, alors que SDL_Init(...) n'a pas encore été appelé?

[czar1983]

Salut
Déja merci beaucoup je comprend mieux grace a vos explication MERCI BEAUCOUP .
pour les SDL_Surface pour est ce que ce n'est pas bon de creer les variable avant d'appeler INIT ? .
j'ai un autre probléme j'ai créer une fonction CoordonneesMur dans laquelle je positionne mon mur mais aussi d'autre sprite mais maintenant je gere les collisions et j'ai encore beaucoup de mal avec les fonctions en fait pour creer des fonctions avec des int ect c'est facile mais des qu'il s'agit d'un autre type je galere .
J'aimerai gerer les collisions donc entre mon mario et le mur et intéragir avec les aussi sprites ( caisse ) , le probleme c'est que mon mario est déclarer dans mon main et les sprites mur caisse sont déclarer et gerer dans ma fonction ,j'aimerai pouvoir accéder au mur en dehors de ma fonction comment puis-je faire ? return SDL_Rect ? voici mon main et ma fonction merci .

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
#ifdef __cplusplus
#include <cstdlib>
#else
#include <stdlib.h>
#endif
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL_image.h>
#include "Hearders.h"
#include "SDL/SDL_ttf.h"
#include "SDL/SDL_mixer.h"
int main(int argc, char *argv[])
 
{
    int y;
    int x;
    int continuer = 1 ;
    SDL_Rect positionmario ;
    SDL_Rect scra;
    SDL_Event event;
    SDL_Surface *ecran = NULL ;
    const SDL_Surface *scrat =  IMG_Load("scrat.jpg");
    const SDL_Surface *marioBas = IMG_Load("mario_bas.gif");
    const SDL_Surface *marioHaut = IMG_Load("mario_haut.gif");
    const SDL_Surface *marioDroite = IMG_Load("mario_droite.gif");
    const SDL_Surface *marioGauche = IMG_Load("mario_gauche.gif");
 
//position ( scra);
 
    positionmario.y = 408/2;
    positionmario.x = 408/2;
    positionmario.h = 34;
    positionmario.w = 34;
 
 
 
 
 
 
 
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
    ecran = SDL_SetVideoMode(408, 408, 32, SDL_HWSURFACE);
    SDL_WM_SetCaption("sobokan", NULL);
    SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
 
    CoordonneesMur(ecran); // Fonction pour remplir mon ecran avec des sprites mur
    // fonction qui charge un tableau de position , et un tableau
    SDL_BlitSurface(marioBas,NULL,ecran,&positionmario);
    SDL_BlitSurface(scrat,NULL,ecran,&scra);                                // de SDL _ Surface pour mes sprites de mario
    SDL_Flip(ecran);
 
    while (continuer)
 
    {
        SDL_WaitEvent(&event);
        switch (event.key.keysym.sym)
        {
        case SDL_QUIT :
            continuer = 0 ;
            break;
 
        case SDLK_ESCAPE :
            continuer = 0;
            break;
        case SDLK_DOWN :
            positionmario.x = positionmario.x ;
            positionmario.y = positionmario.y + 5;
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            CoordonneesMur(ecran);
            SDL_BlitSurface(marioBas,NULL,ecran,&positionmario);
            SDL_BlitSurface(scrat,NULL,ecran,&scra);
            SDL_Flip(ecran);
            break;
 
        case SDLK_UP :
            positionmario.y = positionmario.y - 5;
            positionmario.x = positionmario.x;
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            CoordonneesMur(ecran);
            SDL_BlitSurface(marioHaut,NULL,ecran,&positionmario);
            SDL_BlitSurface(scrat,NULL,ecran,&scra);
            SDL_Flip(ecran);
            break;
 
        case SDLK_RIGHT :
            positionmario.x = positionmario.x + 5;
            positionmario.y = positionmario.y;
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            CoordonneesMur(ecran);
            SDL_BlitSurface(marioDroite,NULL,ecran,&positionmario);
            SDL_BlitSurface(scrat,NULL,ecran,&scra);
            SDL_Flip(ecran);
            break;
 
        case SDLK_LEFT :
            positionmario.x = positionmario.x - 5 ;
            positionmario.y = positionmario.y;
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            CoordonneesMur(ecran);
            SDL_BlitSurface(marioGauche,NULL,ecran,&positionmario);
            SDL_BlitSurface(scrat,NULL,ecran,&scra);
            SDL_Flip(ecran);
            break;
        }
// GESTION DES COLLISIONS 
        if ( positionmario.x  < CoordonneesMur + CoordonneesMur)
        {
            positionmario.x = positionmario.x + 1;
            SDL_Flip(ecran);
        }
 
 
 
    }
    SDL_FreeSurface(ecran);
    SDL_Quit();
    return EXIT_SUCCESS;
}

FONCTION

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
#include"Hearders.h"
 
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL_image.h>
void CoordonneesMur(SDL_Surface *ecran)
{
 
 
    int tabposition[12] = {0};
 
 
 
    int j;
    int i;
    SDL_Surface *mur , *caisse, *caisse_ok;
    SDL_Rect position_mur;
    SDL_Rect position_caisse;
    SDL_Rect position_caisse_ok;
 
 
     for (i = 0 ; i<19;i++)
   {
       tabposition[i] = i*34;
   }
position_mur.h = 34;
position_mur.w = 34 ;
 
        mur = IMG_Load("mur.jpg");
        caisse = IMG_Load("caisse.jpg");
        caisse_ok = IMG_Load("objectif.png");
 
        position_mur.x = tabposition[5];
        position_mur.y =  tabposition[3];
        SDL_BlitSurface(mur,NULL,ecran,&position_mur);
    position_caisse.x = tabposition[5];
        position_caisse.y =  tabposition[4];
        SDL_BlitSurface(caisse,NULL,ecran,&position_caisse);
 
         position_caisse_ok.x = tabposition[4];
        position_caisse_ok.y =  tabposition[8];
        SDL_BlitSurface(caisse_ok,NULL,ecran,&position_caisse_ok);
        position_caisse_ok.x = tabposition[1];
        position_caisse_ok.y =  tabposition[3];
        SDL_BlitSurface(caisse_ok,NULL,ecran,&position_caisse_ok);
position_caisse_ok.x = tabposition[2];
        position_caisse_ok.y =  tabposition[3];
        SDL_BlitSurface(caisse_ok,NULL,ecran,&position_caisse_ok);
 
 
 
 
 
          position_mur.x = tabposition[5];
        position_mur.y =  tabposition[5];
        SDL_BlitSurface(mur,NULL,ecran,&position_mur);
 
 
 
           position_mur.x = tabposition[3];
        position_mur.y =  tabposition[5];
        SDL_BlitSurface(mur,NULL,ecran,&position_mur);
 
 
           position_mur.x = tabposition[0];
        position_mur.y =  tabposition[5];
        SDL_BlitSurface(mur,NULL,ecran,&position_mur);
 
           position_mur.x = tabposition[8];
        position_mur.y =  tabposition[4];
        SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        position_caisse.x = tabposition[9];
        position_caisse.y =  tabposition[4];
        SDL_BlitSurface(caisse,NULL,ecran,&position_caisse);
        position_caisse.x = tabposition[9];
        position_caisse.y =  tabposition[6];
        SDL_BlitSurface(caisse,NULL,ecran,&position_caisse);
 
 
 
          position_mur.x = tabposition[3];
        position_mur.y =  tabposition[3];
        SDL_BlitSurface(mur,NULL,ecran,&position_mur);
 
 
 for (j = 0 ; j < 1 ; j++) // position du mur en haut a gauche POSITION Y
 
    {
        for (i = 0 ; i < 4 ; i++) // POSITION X
        {
 
            SDL_Rect position_mur;
            position_mur.x  = i*34 ;
            position_mur.y =  tabposition[2]+j*34 ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
 
 
 
    for (j = 0 ; j < 2 ; j++) // position du mur en haut a gauche POSITION Y
 
    {
        for (i = 0 ; i < 5 ; i++) // POSITION X
        {
 
            SDL_Rect position_mur;
            position_mur.x  = i*34 ;
            position_mur.y =  j*34 ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
 
 
 for (j = 0 ; j < 2 ; j++) // position du mur en haut a gauche POSITION Y
 
    {
        for (i = 0 ; i < 2 ; i++) // POSITION X
        {
 
            SDL_Rect position_mur;
            position_mur.x  = tabposition[7]+i*34 ;
            position_mur.y =  tabposition[2]+j*34 ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
 for (j = 0 ; j < 1 ; j++) // position du mur en haut a gauche POSITION Y
 
    {
        for (i = 0 ; i < 4 ; i++) // POSITION X
        {
 
            SDL_Rect position_mur;
            position_mur.x  = tabposition[4]+i*34 ;
            position_mur.y =  tabposition[7]+j*34 ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
     for (j = 0 ; j < 1 ; j++) // position du mur en haut a gauche POSITION Y
 
    {
        for (i = 0 ; i < 2 ; i++) // POSITION X
        {
 
            SDL_Rect position_mur;
            position_mur.x  = tabposition[7]+i*34 ;
            position_mur.y =  tabposition[6]+j*34 ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
 
 
 
 
 
      for (j = 0 ; j < 1 ; j++) // position du mur en haut a gauche POSITION Y
 
    {
        for (i = 0 ; i < 4 ; i++) // POSITION X
        {
 
            SDL_Rect position_mur;
            position_mur.x  = tabposition[7]+i*34 ;
            position_mur.y =  j*34 ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
 
 
    for (j = 0 ; j < 4 ; j++) // position du mur en haut a gauche POSITION Y
 
    {
        for (i = 0 ; i < 1 ; i++) // POSITION X
        {
 
            SDL_Rect position_mur;
            position_mur.x  = tabposition[10]+i*34 ;
            position_mur.y =  tabposition[3] + j*34 ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
 
 
 
 
      for (j = 0 ; j < 9 ; j++) // position du mur en haut a gauche POSITION Y
 
    {
        for (i = 0 ; i < 1 ; i++) // POSITION X
        {
 
            SDL_Rect position_mur;
            position_mur.x  = tabposition[11]+i*34 ;
            position_mur.y =  j*34 ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
 
 
 
 
 
    for (j = 0 ; j < 6 ; j++) // position du mur N2 en bas a gauche
    {
        for (i = 0 ; i < 4 ; i++)
        {
 
            SDL_Rect position_mur;
            position_mur.x  = i*34 ;
            position_mur.y  = tabposition[6] + (j*34) ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
 
    for (j = 0 ; j < 3 ; j++) // position du mur N3 en bas a gauche
    {
        for (i = 0 ; i < 8 ; i++)
        {
 
            SDL_Rect position_mur;
            position_mur.x  = tabposition[4] + i*34 ;
            position_mur.y  = tabposition[9] + (j*34) ;
            SDL_BlitSurface(mur,NULL,ecran,&position_mur);
        }
    }
}

[Invité]

Effectivement bien vu edgarjacobs
Il vaut mieux en effet initialiser la SDL avant de vouloir utiliser ses fonctions.

Pour le reste il te suffit, comme tu l'as fait pour ecran, de faire passer ton mur en paramètre de la fonction CoordonneesMur().

Code :

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

void CoordonneesMur(SDL_Surface *ecran, SDL_Surface *mur)

Par contre étant donné que tu exécutes cette fonction en boucle, préfère effectuer ces chargements :

Code :

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

1
2
3
mur = IMG_Load("mur.jpg");
caisse = IMG_Load("caisse.jpg");
caisse_ok = IMG_Load("objectif.png");

en dehors.

[czar1983]

je viens de réussir a passer en parametre mes SDL_Surface * caisse , * caisse_ok MERCI maintenant j'ai fait comme tu m'as dit j'ai déclarer mes sprites dans mon main .

maintenant je vais essayer d'envoyer aussi mes SDL_Rect en parametre afin de pouvoir les utiliser dans ma gestion des collisions
Je laisse le Post ouvert ?
MERCI

[edgarjacobs]

Hello,

Je viens de parcourir ton code, et il y a plusieurs simplifications que tu peux faire:
1) Dans CoordonneesMur(...)
- lignes 86, 127, 139, 156: boucles à supprimer: j vaudra toujours 0
- lignes 173, 189: boucles à supprimer: i vaudra toujours 0
2) Dans main(...)
- lignes 66, 77, 87, 97: à supprimer (a=a)
- tu devrais utiliser les facilités d'écriture du C, et écrire plutot a+=3 plutôt que a=a+3

Ces modifications ne changeront sans doute rien au code généré par le compilateur (il est devenu très intelligent au fil du temps et a certainement optimisé le code pour toi ), mais pour la présentation du programme, cela fait une grosse différence....

PS: si il y a une logique à l'utilisation de tabposition[x], je ne l'ai pas comprise.

[czar1983]

Salut MERCI POUR TON AIDE
les tabposition[x] contiennent les coordonnées de mon ecran qui fait 408 sur 408 et chaque position dans le tableau me permet de positionner mes sprites ou éviter d’écrire mur.x = 102 je met mur=tabposition[2] car il contient la valeur 102 , tabposition[3] contient 136 car chaque sprite que j'ai fait 34

la j'essaye de gérer les collisions mais j'ai un problème mon programme s'ouvre et se referme aussitôt
Si je met * devant ma variable SDL_Rect position_mur mon mario ne bouge plus et si je l’enlève je peux de nouveau bouger mon mario .
Pourtant il y a des fonctions pour gérer les positions de mon mario et une fonction pour gérer la position de mon mur je ne comprend pas

Code :

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

 SDL_Rect position_mur;// FONCTIONNNE

SI J UTILISE

Code :

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

 SDL_Rect *position_mur; //NE  FONCTIONNNE PAS

main

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
#ifdef __cplusplus
#include <cstdlib>
#else
#include <stdlib.h>
#endif
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL_image.h>
#include "Hearders.h"
#include "SDL/SDL_ttf.h"
#include "SDL/SDL_mixer.h"
int main(int argc, char *argv[])
 
{
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_DOUBLEBUF);
 
    int continuer = 1 ;
    SDL_Event event;
    SDL_Surface *ecran = NULL ;
    SDL_Surface *marioBas = IMG_Load("mario_bas.gif");
    SDL_Surface *marioHaut = IMG_Load("mario_haut.gif");
    SDL_Surface *marioDroite = IMG_Load("mario_droite.gif");
    SDL_Surface *marioGauche = IMG_Load("mario_gauche.gif");
    SDL_Surface *mur = IMG_Load("mur.jpg");
    SDL_Surface *caisse = IMG_Load("caisse.jpg");
    SDL_Surface *caisse_ok = IMG_Load("objectif.png");
 
    SDL_Rect *positionmario ;
    SDL_Rect *position_mur;
 
 
    ecran = SDL_SetVideoMode(408, 408, 32, SDL_HWSURFACE);
    SDL_WM_SetCaption("sobokan", NULL);
    SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
 
    positionMur(&position_mur);
    positionMarioDepart(&positionmario );
    SDL_BlitSurface(marioBas,NULL,ecran,&positionmario);
    SDL_BlitSurface(mur,NULL,ecran,&position_mur);
    SDL_Flip(ecran);
    SDL_EnableKeyRepeat(10, 10);
 
    while (continuer)
 
    {
        SDL_WaitEvent(&event);
        switch (event.key.keysym.sym)
        {
        case SDL_QUIT :
            continuer = 0 ;
            break;
 
        case SDLK_ESCAPE :
            continuer = 0;
            break;
 
        case SDLK_DOWN :
            MarioDown(&positionmario);
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            SDL_BlitSurface(marioBas,NULL,ecran,&positionmario);
             SDL_BlitSurface(mur,NULL,ecran,&position_mur);
            SDL_Flip(ecran);
            break;
 
        case SDLK_UP :
            MarioUp(&positionmario);
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            SDL_BlitSurface(marioHaut,NULL,ecran,&positionmario);
             SDL_BlitSurface(mur,NULL,ecran,&position_mur);
            SDL_Flip(ecran);
            break;
 
        case SDLK_RIGHT :
            MarioRight(&positionmario);
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            SDL_BlitSurface(marioDroite,NULL,ecran,&positionmario);
             SDL_BlitSurface(mur,NULL,ecran,&position_mur);
            SDL_Flip(ecran);
            break;
 
        case SDLK_LEFT :
            MarioLeft(&positionmario);
            SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
            SDL_BlitSurface(marioGauche,NULL,ecran,&positionmario);
             SDL_BlitSurface(mur,NULL,ecran,&position_mur);
            SDL_Flip(ecran);
            break;
 
        }
        if (positionmario->x < position_mur->x + position_mur->h)
 
        {
            positionmario->x + 5;
        }
 
    }
    SDL_FreeSurface(ecran);
    SDL_Quit();
    return EXIT_SUCCESS;
}

reste des fonctions

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include"Hearders.h"
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL_image.h>
 
void positionMur(SDL_Rect *positionmur)
 
{
    positionmur->x = 0;
    positionmur->y = 0;
    positionmur->h = 34;
    positionmur->w = 34;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include"Hearders.h"
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL_image.h>
 
 
void positionMarioDepart(SDL_Rect *positionmariodepart )
 
{
    positionmariodepart->x = 408/2;
    positionmariodepart->y= 408/2;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include"Hearders.h"
 
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL_image.h>
 
void MarioRight(SDL_Rect *marioDroite)
 
          {
              marioDroite->x += 5;
            marioDroite->y  ;
 
          }

le reste des fonctions ressemble a celle du dessus sauf quelle modifie la position gauche haut et bas simplement .

[edgarjacobs]

Hello,

Pour commencer, SDL_DOUBLEBUF ne fait pas partie des flags d'initialisation de SDL_Init, mais bien des flags d'option dans SDL_SetVideoMode....

Ensuite, tu déclares

Code :

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

1
2
    SDL_Rect *positionmario ;
    SDL_Rect *position_mur;

Mais tu fais l'appel en utilisant l'adresse du pointeur:

positionMur(&position_mur);
positionMarioDepart(&positionmario );

Alors, de deux choses l'une:

A) tu continues à travailler avec des pointeurs (déconseillé, car n'apporte rien dans le cas présent), mais en ce cas tu dois
1) allouer de la mémoire (malloc) pour ces pointeurs,
2) supprimer le '&' dans l'appel des fonctions, et
3) faire un free pour libérer l'espace alloué lorsque tu n'as plus besoin de tes pointeurs

B) tu t'affranchis des pointeurs, et tu changes ta déclaration:

Code :

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

1
2
    SDL_Rect position_mur;
    SDL_Rect positionmario;

et tu ne changes rien à ton code.

Le reste m'a l'air ok, mais je n'ai pas particulièrement approfondi....

[czar1983]

OK si je comprend bien pas besoin d utiliser des pointeurs , mais comment je fait pour utiliser ma fonction sans pointeur? je pensai avoir compris que si tu veux utiliser une fonction il faut avoir un pointeur pour modifier ta variable et non creer une copie c'est bien ca?

[czar1983]

Mon mur ne s'affiche pas voici ce que je fait
Je declare ma variable

Code :

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

SDL_Rect position_mur;

Je creer la fonction

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include"Hearders.h"
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL_image.h>
 
void positionMur(SDL_Rect positionmur)
 
{
    positionmur.x = 0;
    positionmur.y = 0;
    positionmur.h = 34;
    positionmur.w = 34;
}

et j'utilise ma fonction

Code :

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

positionMur(position_mur);

et je Blit

Code :

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

SDL_BlitSurface(mur,NULL,ecran,&position_mur);

[Kannagi]

Normal faudra revisser les pointeurs

La bonne méthode serait ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void positionMur(SDL_Rect *positionmur)
 
{
    positionmur->x = 0;
    positionmur->y = 0;
    positionmur->h = 34;
    positionmur->w = 34;
}
 
//appel de la fonction :
positionMur(&positionmur);

[edgarjacobs]

je pensai avoir compris que si tu veux utiliser une fonction il faut avoir un pointeur pour modifier ta variable et non creer une copie c'est bien ca?

Oui c'est exactement ça. Je t'avais conseillé de changer uniquement la déclaration, et rien d'autre dans ton code. Tu déclares ta variable SDL_Rect position_mur, et pour pouvoir modifier ses membres dans une fonction, tu passes l'adresse de la variable à la fonction.

Regarde l'exemple de Kannagi.