Discussion :

[SofEvans]

Bonsoir,

mon titre n'étant pas clair, je vais vous expliquer mon probleme :

Je code en C++ mais je n'utilise pas la POO. J'utilise encore les structure.
Voici mon probleme :

Je veux creer un jeu dans lequel on controle un vaisseau.

Le vaisseau possede des arme (differente) et les arme utilise des munition (differente elle aussi). Cepandant, une arme ne possede qu'un seul type de munition.

Afin de ne pas faire des SDL_LoadBMP pour chaque arme (alors que plusieurs d'entre elle utilise le même type de munition), j'ai creer un tableau de type Projectile récapitulant les differentes munitions.

STRUCTURE DU PROJECTILE

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
 
typedef enum NomProjectile
{
    BALLE,
    MISSILE,
    AUCUNE,
    NombreProjectile = 3
 
};
 
 
typedef struct DefinitionProjectile
{
    /* Caracteristiques fixe de la munition */
    SDL_Surface *image;
    float vitesse;
    int dommage;
    int dureeDeVie;
 
    /* Caracteristiques données par l'arme */
    float angle;
    float debutX;
    float debutY;
    float positionX;
    float positionY;
 
    /* Gestion de la liste chainée */
    struct DefinitionProjectile *precedent;
    struct DefinitionProjectile *suivant;
 
}Projectile, *pProjectile;

CREATION DU TABLEAU

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
 
void CreationListeProjectiles(Projectile *ListeProjectile)
{
    /* Cette surface servira a charger les image des projectile afin que
      la conversion au BPP de l'ecran puisse ce faire */
    SDL_Surface *temporaire;
 
 
    if ((temporaire = SDL_LoadBMP("./Ressources/Projectile/Balle.bmp")) == NULL)
    {
        cerr << "Impossible de charger l'image \"Balle\" du dossier \"Ressources/Projectile\" : " << SDL_GetError() << ".\n";
        exit(EXIT_FAILURE);
    }
    if ((ListeProjectile[BALLE].image = SDL_DisplayFormat(temporaire)) == NULL)
    {
        cerr << "Probleme lors de la conversion de l'image \"Balle\" du dossier \"Ressources/Projectile\" : " << SDL_GetError() << ".\n";
        exit(EXIT_FAILURE);
    }
    cout << "Image \"Balle\" du dossier \"Ressources/Projectile\" completement initialisé.\n";
    ListeProjectile[BALLE].vitesse = 150;
    ListeProjectile[BALLE].dommage = 3;
    ListeProjectile[BALLE].dureeDeVie = 700;
 
 
    if ((temporaire = SDL_LoadBMP("./Ressources/Projectile/Missile.bmp")) == NULL)
    {
        cerr << "Impossible de charger l'image \"Missile\" du dossier \"Ressources/Projectile\" : " << SDL_GetError() << ".\n";
        exit(EXIT_FAILURE);
    }
    if ((ListeProjectile[MISSILE].image = SDL_DisplayFormat(temporaire)) == NULL)
    {
        cerr << "Probleme lors de la conversion de l'image \"Missile\" du dossier \"Ressources/Projectile\" : " << SDL_GetError() << ".\n";
        exit(EXIT_FAILURE);
    }
    if ((SDL_SetColorKey(ListeProjectile[MISSILE].image, SDL_SRCCOLORKEY | SDL_RLEACCEL, 0xFF00FF)) == -1)
    {
        cerr << "Probleme lors de l'introduction de la transparence pour l'image \"Missile\" du dossier \"Ressources/Projectile\" : " << SDL_GetError() << ".\n";
        exit(EXIT_FAILURE);
    }
    cout << "Image \"Missile\" du dossier \"Ressources/Projectile\" completement initialisé.\n";
    ListeProjectile[MISSILE].vitesse = 90;
    ListeProjectile[MISSILE].dommage = 15;
    ListeProjectile[MISSILE].dureeDeVie = 400;
 
 
    ListeProjectile[AUCUNE].image = NULL;
    ListeProjectile[AUCUNE].vitesse = 0;
    ListeProjectile[AUCUNE].dommage = 0;
    ListeProjectile[AUCUNE].dureeDeVie = 0;
 
    SDL_FreeSurface(temporaire);
}

Ce tableau est utilisé pour la creation des armes, definie ci dessous :

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
 
typedef enum NomArme
{
    LANCE_ROQUETTE,
    LANCE_MISSILE,
    UF_45,
    RAPTOR,
    VIDE,
    NombreArme = 5
 
};
 
 
typedef struct DefinitionArme
{
 
    /* Caracteristique fixe de l'arme */
    std::string nom;
    Projectile munition;
    float cadence;
    /*
    int munition;
    int tempsRechargement;
    */
 
    /* Caracteristique fixé en debut de round */
    /* Angle de tir en radian */
    float angleDeTir;
 
}Arme, *pArme;

Une arme a donc une munition, et non un pointeur de munition.


CREATION DE LA LISTE D'ARME

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
 
void CreationListeArmes (Arme *ListeArme)
{
    /* On obtient les differentes munitions possible */
    Projectile ListeProjectile[NombreProjectile];
    CreationListeProjectiles(ListeProjectile);
 
 
    /* On creer toutes les armes */
    ListeArme[LANCE_ROQUETTE].nom = "Lance Roquette";
    ListeArme[LANCE_ROQUETTE].munition = ListeProjectile[MISSILE];
    ListeArme[LANCE_ROQUETTE].cadence = 80;
 
 
    ListeArme[LANCE_MISSILE].nom = "Lance Missile";
    ListeArme[LANCE_MISSILE].munition = ListeProjectile[MISSILE];
    ListeArme[LANCE_MISSILE].cadence = 20;
 
 
    ListeArme[UF_45].nom = "UF 45";
    ListeArme[UF_45].munition = ListeProjectile[BALLE];
    ListeArme[UF_45].cadence = 990;
 
 
    ListeArme[RAPTOR].nom = "Raptor";
    ListeArme[RAPTOR].munition = ListeProjectile[BALLE];
    ListeArme[RAPTOR].cadence = 678;
 
 
    ListeArme[VIDE].nom = "vide";
    ListeArme[VIDE].munition = ListeProjectile[AUCUNE];
    ListeArme[VIDE].cadence = 0;
 
 
 
    //DestructionListeProjectiles(ListeProjectile);
 
    /* Les surface sont totalement desalloue :/
    SDL_BlitSurface(ListeProjectile[MISSILE].image,NULL,SDL_GetVideoSurface(),NULL);
    SDL_Flip(SDL_GetVideoSurface());
    Sleep(2000);*/
 
}

Le probleme vient du fait que lorsque je libere l'image (avec la fonction DestructionListeProjectiles(ListeProjectile); qui est commenter ) des munitions, seule l'image de la balle peut etre blitter, mais pas celle du missile.

Voici (enfin) mes question :


* Si je libere (avec DestructionListeProjectiles(ListeProjectile)) les SDL_Surface, est que cette liberation affectera egalement les armes ?

** Si oui, comment faire un sorte que cela n'arrive pas ? Doit on faire une sorte de duplicata ?

* Pourquoi une des deux image seulement n'est plus disponible ? Pourquoi les deux image n'agissent pas de la meme maniere ??

Voila, merci de m'avoir lu.

[GR3lh442kR]

peut on avoir le code de DestructionListeProjectiles ?

edit:
ton projectille contient un pointeur vers une SDL_Surface, quand tu copie ton projectile dans ton arme, tu copie le pointeur! si tu détruit ta ListeProjectile et aussi tes SDL_Surface, tes pointeurs vont pointer sur un bout de mémoire dont on ne connait pas le contenue... il y a donc un problème a ce niveau là.

tu pourrais conserver ta liste de projectiles et la désallouer à la fin du programme, et utiliser un pointeur vers la munition dans la description de ton arme.
ou alors ( j'suis pas sur de mon coup là ) tu ne libère pas les surface dans DestructionListeProjectiles mais plutôt au moment de la destruction des armes.

[coyotte507]

Sinon, quand tu fais une copie du pointeur,

tu peux faire surface->refcount++, et comme ça il faudra faire deux SDL_FreeSurface() pour libérer la mémoire (au lieu d'un).

Tu peux faire ça autant de fois que tu as de copies, mais il faudra bien faire un SDL_FreeSurface à chaque fois. Tu peux même implémenter cette gestion automatique dans une classe!

[GR3lh442kR]

bonne astuce coyotte507, merci!

[SofEvans]

Merci beaucoup ^^

Je crois que je vais revoir la structure de mon programme, comme le suggère bebaijhi. Sinon, je le connaissait pas le coup de surface->refcout++;, c'est bon a savoir.

Merci a vous deux !

[coyotte507]

Je ne sais pas si ça peux t'intéresser,

mais j'ai fait une classe "safe" qui permet de copier les surfaces sans se soucier de leur destruction (compteur de référence):

Code intervideo.hpp :

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
#ifndef INTERFACE_HPP_INCLUDED
#define INTERFACE_HPP_INCLUDED
 
#include <SDL/SDL.h>
 
namespace interface
{
 
class Surface;
 
struct Rect : public SDL_Rect
{
    Rect(Sint16 x=0,Sint16 y=0, Uint16 w=0, Uint16 h=0);
    bool isNull() const;
};
 
struct Color : public SDL_Color
{
    //Set everything to base
    Color (Uint8 base=0);
    //Normal
    Color(Uint8 r, Uint8 g, Uint8 b=0);
    /* interne */
    Uint32 map(const Surface &s) const;
};
 
typedef Color ColorKey;
 
class Surface
{
public: /* Privé! ou risqué */
    void create (SDL_Surface *ext);
    explicit Surface (SDL_Surface *ext);
public: /* safe */
    mutable SDL_Surface *s;
 
    /** METHODES **/
    Surface();
    Surface(const Surface &s);
    Surface(const char *filename, bool raw = false);
    Surface(const char *filename, const Color & colorkey, bool raw = false);
    Surface(Uint16 bpp, Uint16 w, Uint16 h, Sint32 flags=0);
    Surface(SDL_RWops *rw_data, bool close_the_RW);
    ~Surface();
    Surface &operator = (const Surface &s);
    operator bool ();
 
    //charger -- avec ou sans optimisations par rapport au format de l'écran
    //le sans optimisation peut être parfois nécessaire pour certains formats d'images
    void raw_load(const char * filename);
    void raw_load(const char * filename, const Color & colorkey);
    void load(const char * filename);
    void load(const char * filename, const Color & colorkey);
    void load(SDL_RWops *rw_data, bool close_the_RW);
 
    //créer -- et bien sûr détruire l'ancienne surface
    void create(Uint16 bpp, Uint16 w, Uint16 h, Sint32 flags=0);
 
    //s'adapter au format d'affichage
    void adapt();
 
    //copier à partir d'une autre surface
    void shareFrom (const Surface &s);
 
    //avoir le ref count
    size_t refcount() const;
 
    //Et se libérer
    void free();
 
    //accesseurs
    Uint16 w();
    Uint16 h();
 
    //dessiner
    void blitTo(Surface &dest_surf, const Rect &clip_src=Rect(), const Rect &clip_dest=Rect());
    void fill(const Rect &dest = Rect(), const Color &col = Color());
 
    //transparence et colorkey
    void alpha(Uint8 alpha);
    void colorkey(const Color &colorkey);
};
 
class Window : public Surface
{
public:
    Window();
    Window(Uint16 bpp, Uint16 w, Uint16 h, Sint32 flags);
    ~Window();
 
    void create(Uint16 bpp, Uint16 w, Uint16 h, Sint32 flags=0);
 
    //Retourne l'écran ;)
    void flip();
 
    //Diverses fonctions pour updater l'écran qu'en partie
    void update_rect(const Rect &r);
    template <class iterator>
    void update_rects(iterator debut, iterator fin);
};
 
}//namespace interface
 
#endif // INTERFACE_HPP_INCLUDED

Code intervideo.cpp :

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
//!@file interface.cpp
 
#include "intervideo.hpp"
#include "exception.hpp"
#include <string>
#include <SDL/SDL_image.h>
 
using std::string;
 
namespace interface
{
 
Rect::Rect(Sint16 x, Sint16 y, Uint16 w, Uint16 h)
{
    this->x = x, this->y = y, this->w = w, this->h = h;
}
 
bool Rect::isNull() const
{
    return x==0 && y==0 && w==0 && h==0;
}
 
Color::Color(Uint8 base)
{
    r=base, g=base, b=base;
}
 
Color::Color(Uint8 r, Uint8 g, Uint8 b)
{
    this->r = r, this->g = g, this->b = b;
}
 
Uint32 Color::map(const Surface &s) const
{
    return SDL_MapRGB(s.s->format, r,g,b);
}
 
void Surface::create (SDL_Surface *ext)
{
    free();
    s = ext;
}
 
Surface::Surface(SDL_Surface *ext)
{
    s = ext;
    if (s == NULL)
    {
        throw InterfaceException("Surface::Surface(SDL_Surface*) : surface NULL passée en paramètre!");
    }
}
 
Surface::Surface() : s(NULL)
{
    ;
}
 
Surface::Surface(const Surface &s) : s(NULL)
{
    shareFrom(s);
}
 
Surface::Surface(const char *filename, bool raw) : s(NULL)
{
    if (raw)
        raw_load(filename);
    else
        load(filename);
}
 
Surface::Surface(const char *filename, const ColorKey &colorkey, bool raw) : s(NULL)
{
    if (raw)
        raw_load(filename, colorkey);
    else
        load(filename, colorkey);
}
 
Surface::Surface(SDL_RWops *rw, bool close_the_RW) : s(NULL)
{
    load(rw, close_the_RW);
}
 
Surface::Surface(Uint16 bpp, Uint16 w, Uint16 h, Sint32 flags) : s(NULL)
{
    create(bpp,w,h,flags);
}
 
Surface::~Surface()
{
    free();
}
 
Surface& Surface::operator = (const Surface &s)
{
    shareFrom(s);
    return *this;
}
 
//charger
void Surface::raw_load(const char *filename)
{
    free();
 
    s = IMG_Load(filename);
 
    if (!s)
        throw InterfaceException(string() + "Surface::raw_load() -- loading failed: " + filename);
}
 
void Surface::raw_load(const char *filename, const Color &colorkeys)
{
    raw_load(filename);
    colorkey(colorkeys);
}
 
void Surface::load(const char * filename)
{
    raw_load(filename);
    adapt();
}
 
void Surface::load(SDL_RWops *ops, bool close_the_RW)
{
    free();
 
    SDL_Surface *temp = IMG_Load_RW(ops, close_the_RW);
    if (temp == NULL)
    {
        throw InterfaceException(string() + "Surface::load() with RWops -- loading failed");
    }
    s = SDL_DisplayFormat(temp);
    SDL_FreeSurface(temp);
    if (s == NULL)
    {
        throw InterfaceException("Surface::load() -- SDL_DisplayFormat failed");
    }
}
 
void Surface::load(const char * filename, const ColorKey &colorkey)
{
    raw_load(filename, colorkey);
    adapt();
}
 
//créer
void Surface::create(Uint16 bpp, Uint16 w, Uint16 h, Sint32 flags)
{
    free();
    s = SDL_CreateRGBSurface(flags,w,h,bpp,0,0,0,0);
    if (s == NULL) throw InterfaceException("Surface::create(bpp,w,h,flags) -- error with SDL_CreateRGBSurface");
}
 
//s'adapter
void Surface::adapt()
{
    if (s == NULL)
        return;
 
    SDL_Surface *s2 = SDL_DisplayFormat(s);
 
    if (s2 == NULL)
        throw InterfaceException("Surface::adapt -- error with SDL_DisplayFormat");
 
    free();
    s = s2;
}
 
void Surface::fill(const Rect &r, const Color &color)
{
    Uint32 c = color.map(*this);
 
    if (r.isNull())
    {
        if (SDL_FillRect(s, 0, c) < 0)
            throw InterfaceException("Surface::fill -- error with SDL_FillRect");
    } else
    {
        Rect r2(r);
        if (SDL_FillRect(s, &r2, c) < 0)
            throw InterfaceException("Surface::fill -- error with SDL_FillRect");
    }
}
 
//partager à partir d'une autre surface
void Surface::shareFrom (const Surface &ext)
{
    if (s == ext.s)
        return;
    free();
    s = ext.s;
    if (s != NULL)
    {
        //On utilise une fonctionnalité SDL qui permet d'avoir un compteur de références
        s->refcount++;
    }
}
 
//Se libérer
void Surface::free()
{
    SDL_FreeSurface(s);
    s = NULL;
}
 
//L'alpha
void Surface::alpha(Uint8 alpha)
{
    if (SDL_SetAlpha(s,SDL_SRCALPHA|SDL_RLEACCEL,alpha) < 0)
        throw InterfaceException("Surface::alpha -- error");
}
 
/* Change le colorkey de la surface avec la nouvelle couleur */
void Surface::colorkey(const Color &color)
{
    if (SDL_SetColorKey(s,SDL_SRCCOLORKEY|SDL_RLEACCEL, color.map(*this)) < 0)
        throw InterfaceException("Surface::colorkey -- error");
}
 
//accesseurs
Uint16 Surface::w()
{
    return s->w;
}
 
Uint16 Surface::h()
{
    return s->h;
}
 
//dessiner
void Surface::blitTo(Surface &dest_surf, const Rect &clip_src, const Rect &clip_dest)
{
    /* Si le rectangle est de coordonnées nulles on fournit NULL, qui veut dire "toute la surface" */
    Rect * clip_s = clip_src.isNull() ? NULL : const_cast<Rect *>(&clip_src);
    Rect * clip_d = clip_dest.isNull() ? NULL : const_cast<Rect *>(&clip_dest);
 
    if (SDL_BlitSurface(s, clip_s, dest_surf.s, clip_d) < 0)
        throw InterfaceException("Surface::blitTo -- error with SDL_BlitSurface)");
}
 
//refcount
size_t Surface::refcount() const
{
    if (s)
        return s->refcount;
    else
        return 0;
}
 
Surface::operator bool ()
{
    return (s);
}
 
Window::Window()
{
}
 
Window::Window(Uint16 bpp, Uint16 w, Uint16 h, Sint32 flags)
{
    create(bpp,w,h,flags);
}
 
Window::~Window()
{
}
 
void Window::create(Uint16 bpp, Uint16 w, Uint16 h, Sint32 flags)
{
    free();
    s = SDL_SetVideoMode(w,h,bpp,flags);
 
    if (s == NULL)
        throw InterfaceException("Window::create() -- Error with SDL_SetVideoMode");
 
    //little hack because actually its SDL that should free the surface
    s->refcount++;
}
 
//Retourne l'écran ;)
void Window::flip()
{
    SDL_Flip(s);
}
 
//Diverses fonctions pour updater l'écran qu'en partie
void Window::update_rect(const Rect &r)
{
    SDL_UpdateRect(s,r.x,r.y,r.w,r.h);
}
 
template <class iterator>
void Window::update_rects(iterator debut, iterator fin)
{
    SDL_UpdateRects(s, debut, fin-debut);
}
 
} //namespace interface

bien sûr tu peux enlever le namespace, mettre les fonctions en inline pour optimiser (et ça pèsera moins lourd) et aussi rajouter l'opérateur pour convertir une Surface en SDL_Surface * (je ne l'utilise pas dans mon code donc il n'est pas là) comme ça tu n'auras pas vraiment besoin de changer le reste de ton code.

Code :

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

1
2
3
4
5
6
7
class Surface
{ 
   ...
   operator SDL_Surface * () {
          return s;
   }
};

Enfin j'ai aussi un RessourceManager qui te permet d'éviter de charger plusieurs fois la même image, si ça t'intéresse

Sinon ...