Duplicata de SDL_Surface

Version imprimable

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:

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:

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:

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:

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.

03/07/2009, 08h06
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.
03/07/2009, 13h11
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!
03/07/2009, 13h41
GR3lh442kR

bonne astuce coyotte507, merci!
04/07/2009, 00h32
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 !

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:

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:

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:

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 8-)

Sinon ... :aie:

05/07/2009, 20h50
SofEvans

:aie: Aouch :aie:

Je vais devoir regarder beaucoup plus attentivement ton code.
Je dois avouer que je n'y suis un peu perdu ( je connais pas encore les namespace et leur conséquence).
Si je te suis bien, tu redéfini la structure SDL_Surface (et toute ses composante), c'est bien ça ?

Ce que j'ai fait diffère grandement.
J'ai créer une structure qui récapitule tout les sprite que je vais utiliser.
Avant la boucle de jeu, j'appel une fonction qui initialise ma structure, c'est a dire qui charge convertie et insere la transparence dans les sprites. J'y fait aussi les decoupes de sprite.

Ensuite, à chaque initialisation de structure ayant besoins de sprite, je lui passe par parametre un pointeur vers ma structure de ressource.

A la fin, j'appel une fonction qui liberera toutes les Surface.

Qu'en pensez vous ? Cette methode est-elle au moins correct ?
Y-a t'il d'autre methode permettant simple afin de gerer les sprite (je crois qu'il y a le Manager ) ?
05/07/2009, 22h27
GR3lh442kR

tu devrais vraiment utiliser les classes, ça serait beaucoup plus simple je pense. et ton code serait aussi plus clair.

Ta méthode est correcte, et peut bien être mise en place, mais en utilisant les classes tu peux faire beaucoup de choses automatiquement et alléger le code.

Concernant ma classe, c'est un peu comme une SDL_Surface mais mise en classe (dans le type Surface) qui gère sa destruction et libération toute seule, ainsi que sa copie. De plus les opérations simples (duplicata, blit, création, chargement, fillRect, alpha, colorkey) sont prises en charge.

Ex:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 using namespace interface; int main(...) { ... Surface a ("Sprite1.bmp"); Surface b = a; //a et b partagent le même SDL_Surface * Surface c(32, a.w(), a.h(), SDL_HWSurface); a.blitTo(c); //copie de a dans c, c est donc la même image mais dans un nouveau SDL_Surface *; Window w (32, 800, 600, SDL_DOUBLEBUF); a.blitTo(w); //copie de a sur l'écran w.flip(); //SDL_Flip sur l'écran ... }
Mais si tu ne connais pas vraiment le C++ je crois que tu ferais mieux de ne pas utiliser cette classe et d'apprendre plus par toi-même notamment avec des tutoriels ou des articles du site, ça te permettra de comprendre les mécanismes petit à petit :)

En plus ça te paraîtra sûrement artificiel la façon dont c'est mis en place

05/07/2009, 23h31
SofEvans

Merci de tes explication coyotte507 :ccool:
sans oublier bebaijhi bien sur ;)

J'avais donc bien deviné :D

Je vais mettre ca de cote car c'est tres interressant.
Le seul probleme, c'est que personne m'apprend la POO.
Apprendre la POO tout seul, meme avec des tutos est .... plutot deroutant.
Le fait est que j'ai des base et des notions, mais franchement, je manque beaucoup trop de notion et d'experience pour faire ce petit jeux.
Apres, pour moi ce ne sont que des "test" afin d'acquerir des reflexion et des experience.
Le sujet de ce post en est un exemple.

Ensuite, si un jour je maitrise le C++, je ferai l'effort de réecrire le code.

En tout cas, merci de vos explication et de vos exemple, car j'assimile beaucoup mieux lorsque l'on met un code simple et commenter.
06/07/2009, 11h05
coyotte507

Citation:

Envoyé par SofEvans

Apprendre la POO tout seul, meme avec des tutos est .... plutot deroutant.

Rien de mieux qu'un bouquin pour débuter :)
Même si ça ne t'apprends pas tout, tu peux déjà faire plein de chose à la fin du bouquin.