Comment gérer un nombre inconnu d'objet ?

Bonjour a tous !
Le titre n'est pas trés explicite, mais je vais tenter de l'éclairer un peu .
Pour vous mettre dans le bain, je vais vous expliquer ma demarche :)

J'ai fait il a peu quelques groupes de classes destiné a être le squelete de mon aplication ( jeu ) .
Par exemple, je vient de finir une calsse destinée a receuillir les évènements clavier, et a les transcrire en quelquechose de plus " lisible" pour le reste de mon programme .

Mon prochain but est la cration d'une classe dont le funeste destin sera de me servir jusqu'a la fin de ses jour ( Mouhahahahaha ... dsl ), enfin plus sérieusement, cette classe aura pour but de permetre l'affichage a l'ecran selon des polices chargé précédement ( donc elle doit aussi permetre l'enregistrement de ces police dans le prog ; je doit pouvoir les retrouver a tout moment grace a un identifiant par exemple .... )

(Je n'ai pas encore vraiment regardé de pres la methode exacte pour afficher tu text; je sais juste qu'il y a 2 moyen ( bitmap et vectorielle je crois ) mais je verrai ca une fois mon probléme résolu . je précise , car si ca se trouve, je n'ai pas besoin de gérer tout ca de cette maniére ... mais le probléme reste alors ouvert pour gérer d'autre entité par exemple )

Ce que j'aimerai faire ?
-> Pouvoir chargé un nombre X d'objet ( "font" dans ce cas la, mais ca peut trés bien etre autre chose ... un personnage, un objet, une arme ect ... ) et y avoir accés aprés ( je ne sais aps trop comment faire ... )
Le nombre et le type d'objet n'ont pas d'importance , je me charge de récupérer les données correpondantes dans divers fichiers texte, et de les transformer en donnée interprétable par mon appli .

Le premier pb qui m'est venu a l'esprit, est que je devais pouvoir chargé un nombre indéterminé d'entité ...donc la methode : on prévoit X objet, qu'on initilise juste pour le plaisir et on les "active" vraiment dés que l'on doit les charger... on oublie :p

J'ai ensuite pensé a me servir d'un tableau ... bon, a priori, un tableau statique on oubli ( car le nbre d'netié est variable ), il nous reste donc un conteneur de type vector par ex ...

Imaginons ca ( un vector par type d'objet ( font / item / perso / arme ... ) )
Quand je parse mes fichier texte, pour savoir quoi chargé dans tel niveau , j'ajoute un objet dans le vector du bon type .
Si jamais 2 fois le MEME objet ( meme identifiant ) sont enregistré, j'ajoute un "2", "3" ect..a la fin du nouvel identifiant a ajouté ( avec un recherche ca ne devrait pas etre trés dur .
( hum je constate que je suis entrain de m'enmeller les pinceau ..j'étati parti sur un idée de vector d'objet et j'arrive sur un vector de string ...

Bon, ca doit vous paraitre trés confus ... mais si vous avez des idée ... et bien je prend :) merci

Perso j'ai pas très bien compris ce que tu voulais faire. Un genre de flyweight factory (truc à base de map<string, Objet*>) ? Du comptage de référence avec pointeur intelligent ? http://loulou.developpez.com/tutoriels/moteur3d/partie4 ?

Tu crees un type de base dont tous les objets heritent.
Des vectors qui chargent et maintienent des pointeurs sur ces objects.
????

Autrement Design Patterns : Factory.

Le temps d'aller me docu. un peu sur ce design Factory et je revient :)
marchi ^^

edit: me revoila !

Je vais prendre un exemple concret ( enfin pas si concret que ca ..car je n'ai rien implementé mais bon ... immaginons )
J'ai un fichier txt avec dedans :

Code:

---

1 2 3 4 5

ARME -> pistolet ARME -> sabre PERSO -> le gros robet ARME -> pistolet

---

Je fait mon affaire du chargement des données lié a ces identifiants ! ( il me suffit pour la prémier arme, de trouver le fichier pistolet.txt , et d'en tirer toute les caractéristique dont j'ai besoin .... force, taille, poid, chargeur , texture et animation associées ect ... ) .
Une fois que j'ai ceci, il me faut crée un objet de type cArme par exemple dans mon programme . Cet objet contiendra toutes les caractéristiques lu précédement dans le fichier txt.

Mon probléme est : ou et comment stocker cet objet, sachant que : ( pour le moment )
- je veut pouvoir a tout instant en lire les caractéristiques ; les modifier ( dans le jeu uniquement, pas dans le fichier txt bien sur ) ect ...

( j'avoue que je suis pas mal dans le flou moi même, car il me manque plus q'un maillion de la chaine ... j'ignore ce qui se trouve au bout du tunnel la ^^ )

Mon probleme ( enfin un de mes probléme ) a mon avis est que je n'ai pas envisagé les liens entre tout ces objet au niveau programation .
Il est en effet idiot de vouloir retrouver les caractéristique d'un pistolet si celui-ci n'est pas présent a un endroit précis dans le jeu !
Je pense a un pointeur du style.

Code:

---

1 2 3 4 5 6 7 8

cEquipement * ArmeCourante ; ArmeCourante = pistolet ;   ou   cItem * ObjetSurLaTable ; ObjetSurLaTable = pistolet ;

---

Enfin, ma vison des choses n'est peut-etre pas la bonne ...c'est juste idée que je vient d'avoir en répondant a ce message .

Apres il me reste encore a voir OU je stocke précisément ce "pistolet" .

J'ai regardé a qoi correspondait le factory design, je ne suis pas certain que ce soit ce que je cherche ( mais bon, j'irai re-jeter un oeil desus plus tard .. on sait jamais ^^ )
j'espére que vous y voyez un peu plus claire :)

Je pense vraiment qu'il te faut une flyweight factory.

En gros :

- Tu associes à chacun de tes objets un identifiant (entier, chaine de caractères, ...).
- Tu construis une flyweight factory qui va charger, décharger et stocker ces objets.
- Lorsque ton appli a besoin de manipuler un objet, elle le demande à la factory sous forme d'identifiant et récupère un pointeur.
- Lorsque plus personne n'a besoin d'une ressource (-> pointeurs intelligents avec comptage de référence) celle-ci peut être déchargée sans souci.
- Après tu peux peaufiner selon ton appli : prévoir un contrôle plus "manuel" pour précharger certaines ressources, ajouter un délai avant libération au cas où la ressource soit rechargée juste après, etc...
- Le fait d'associer chaque objet à un identifiant te permettra de manipuler ceux-ci facilement dans tes futurs scripts.

Evidemment, ceci est une solution générale, et peut-être qu'elle sera plus ou moins appropriée pour le type de ressource que tu manipules et l'utilisation que tu en fais.

Ensuite pour ce qui est du lien physique entre les objets dans le jeu, ça c'est plutôt le boulot d'un scenegraph :wink:

OKi doki :) je me replonge dedans dés que j'ai un peu de temps ^^
merci

Pour un jeu, j'opterai plus pour une version de chaine de responsabilités :

Un Monde contient des objets certains de ces objets sont des conteneurs et contiennent eux meme des objets.

Tu maintiens dans le cas des conteneurs des vectors d'items.

Tu as un certain nombre de methodes de bases (genre Render()).

Enfin, comme ca tu as la main sur le chargement d'objet et tu maintiens une hierarchie (un bonhomme et le pere de son arme, son armure, et d'une grenade; le monde est le pere des decors, de ton perso et des ennemis).

re coucou :)

Citation:

---

Ensuite pour ce qui est du lien physique entre les objets dans le jeu, ça c'est plutôt le boulot d'un scenegraph

---

Bon bah .... ce sera un boulot pour moi alors :D

> mtopoloff : Hum, en gros, une sorte d'arbre ?
Le principale avantage que j'y voit est pour le dessin des objet comme tu le dit ; il me suffirai d'y aller récurssivement et d'afficher tout les objet du premier vector ..puis tout ceux contenu dans ces premiers objets ect ...
Sinon je ne voit pas trop comment ca va régler mon probleme de chargement :) mais merci de l'idée !!

Sinon, je vient de me repencher sur le DP : factory , et voila ce que j'en ai comprit / comment je pense l'utiliser , dites-moi ce que vous en pensez .

On commence par une classe Factory ( singleton d'apres ce que j'ai lu ) .

Le principe :
- cette classe va se charger de stocker tout les objets ( pas des pointeurs ) du jeu
- pour se faire on cré un nouvel item ( une classe cItem dont vont dérivée toutes les classes fille représentant mes divers objets dans le jeu ) que j'ajoute dans un conteneur ( vector par ex )
- pour supprimer un objet, il suffira d'appeler une fonction detruire(), avec en paramétre l'identifiant ( unique ) de l'item a détruire .
-pour récupérer un objet, on apelle une fonction get(), avec en param l'identifiant de l'objet, et on récupére un pointeur sur un l'objet contenu dans une case de mon vector en question .

Enfin voila en gros ce que j'ai compris :D j'espére ne pas etre trop loin de la vérité ;)

Citation:

---

> mtopoloff : Hum, en gros, une sorte d'arbre ?
Le principale avantage que j'y voit est pour le dessin des objet comme tu le dit ; il me suffirai d'y aller récurssivement et d'afficher tout les objet du premier vector ..puis tout ceux contenu dans ces premiers objets ect ...
Sinon je ne voit pas trop comment ca va régler mon probleme de chargement :) mais merci de l'idée !!

---

C'est justement ça un scenegraph, et effectivement ça a très peu à voir avec le chargement des ressources.

Citation:

---

Sinon, je vient de me repencher sur le DP : factory , et voila ce que j'en ai comprit / comment je pense l'utiliser , dites-moi ce que vous en pensez .

---

C'est à peu près ça. Sauf que ce n'est pas une factory qu'il te faut, mas une flyweight factory (la différence en gros c'est que la flyweight n'ira pas recharger une ressource si celle-ci l'est déjà).
Ensuite tu as une contradiction : tu veux stocker des objets polymorphiques (dérivant d'une même classe), mais pas sous forme de pointeur. Problème. -> Dans ce cas tu ne peux pas te passer de pointeurs. Et pour finir, pas besoin de faire une classe de base (imagine que tu stockes des objets complétement différents : texture, mesh, material, ...), cf. mon tutoriel n°4. Et dis toi bien qu'il n'y aura que des cItem* qui sortiront de ta fabrique, est-ce que tu pourrais manipuler tous tes objets via leur classe de base dans ton jeu ? :wink:

Un petit coucou matinal :)

Bon tout d'abord il va faloir que je me renseigne sur les ficelle du scene-graph-ing ^^ ...

Concernant la différence entre la flyeight factory et la factory normale, je m'interoge encore . En effet, si le principe de la flyweight est de ne PAS charger 2 fois la meme ressource, je ne susi pas sur que ce soit ca que je veuille .
Par contre, je ne chargerai pas 2 fois la meme texture pour des objets identique ( mais ca c'est mon TextureManager qui s'en occupe )
Ensuite, si je veut faire par exemple un niveau ou il y a 2 ennemis dont l'identifiant est " chien"
J'hesite encore sur la procédure a suivre ... car si dans mon fichier j'ai qquchose comme ca :

Code:

---

1 2 3 4

[COMBAT NUMERO 4] MONSTRE -> chien MONSTRE-> chien

---

Je risque aprés de m'enbrouiller pour retrouver lequel est lequel ( par exemple dans le cilage du "chien" dans les combat ... et meme en les ajoutant en tant ue "chien" et "chien2"

Sinon, je peut faire qquchose du style :

Code:

---

1 2 3 4

[COMBAT NUMERO 4] MONSTRE -> chien ( m_chien ) MONSTRE-> chien (m_chien2 )

---

Et ainsi je les enregistre selon un identifiant différent ; le mot clé chien, servant juste a m'indique ou trouver le fichier contenant leur caractéristiques ..

Enfin je n'ai pas les idées trés claires la dessus pour le moment :/

Conercant les obket polymorphique ... hum, je n'avais pas réfléchi a ca :)
Je vais revoir ma copie ( ce soir ) et je re-post ca :)
merci

coucou :)
Me revoila aprés une semaine de vacances ... rien de tel pour tout oublier :)
Je suis donc entrain de me mettre dans le bain et de me replancher sur ce petit pb .

Voici jusqu'alors mes conclusion ...et mes questions :p

Bon, je doit avouer que je suis un peu confus vis a vis des objets polymorphique , classe dérivée ect ... je ne vois plus trop ou étaient mes erreurs ;)
Enfin si j'ai bien comprit , je ne peut pas stocker de cItem directement ( car c'est une classe abstraite ) or, j'ai besoin de stocker des cItem et non pas des pointeur de cItem .... hum aïe :p

( parenthése : concernant le fait que tout mes objets ne partageraient pas tous les meme propriétés ect ... ( texture , anim , map ect ... ) ; je pensais juste faire une classe abstraite contenant un string ( l'indentifiant .. ) )

Bon, comment contourner la chose hummm , la j'avoue je bloque :/

quun a des idées ?

edit : une erreur de frappe dans la faq ou j'ai lu trop vite ?

Citation:

---

Base* Obj = new Derivee1;
Base* Obj = new Derivee2;

Base* Copy1 = Obj1->Clone(); // Copy1 pointe sur un objet de type Derivee1
Base* Copy2 = Obj2->Clone(); // Copy2 pointe sur un objet de type Derivee2

---

J'aurais mis :

Code:

---

1 2 3

Base* Obj1 = new Derivee1; Base* Obj2 = new Derivee2;

---

http://c.developpez.com/faq/cpp/?pag...es#CLASS_clone

Citation:

---

une erreur de frappe dans la faq ou j'ai lu trop vite ?

---

C'est d'ores et déjà corrigé dans la prochaine version de la FAQ. Merci quand même de l'avoir signalé :wink:

Pour ton problème... je crois qu'il fait que nous aussi on se remette dans le bain :D

En l'occurence tu peux détailler ce point ?

Citation:

---

Enfin si j'ai bien comprit , je ne peut pas stocker de cItem directement ( car c'est une classe abstraite ) or, j'ai besoin de stocker des cItem et non pas des pointeur de cItem .... hum aïe :p

---

en gros je ne peut pas avoir un

Code:

---

1 2	cItem tab[100] ;

---

hum , comme d'ab' je m'embrouille :p

il me suffit d'avoir un :

Code:

---

1 2	cItem * tab[100] ;

---

C'est possible ca , non ?
Mais je ne vois pas trés bien comment manipuler ca avec mes 3 fonctions get / load / free ...[/code]

Citation:

---

Envoyé par Clad3

en gros je ne peut pas avoir un

Code:

---

1 2	cItem tab[100] ;

---

hum , comme d'ab' je m'embrouille :p

il me suffit d'avoir un :

Code:

---

1 2	cItem * tab[100] ;

---

---

Salut,

j'ai pas lu tout ce qu'il y avait ce post, mais je corrige ceci

Code:

---

1 2	cItem tab[100] ;

---

ou

Code:

---

1 2 3

cItem * tab ; // tab = new cItem[100];

---

http://membres.lycos.fr/bigboomshaka...ar-gif-311.gif Enjoy yourself !

oula c'est des erreurs grave de ma parts ca ...

Code:

---

cItem tab[100]

---

-> représente un tableau dont chaque case contient une instance de la clase cItem c'est ca ?

Code:

---

cItem * tab

---

-> représente un pointeur sur un objet de type cItem

Hum .. pour moi

Code:

---

1 2	cItem * tab[100]

---

représente un tableau de pointeur sur des objet de type cItem
J'ai du louper qquchose :D

edit : heu je vais prendre le tps de relire ca ...car je crois que j'ai encore écrit une belle annerie ...

Utilise des smartpointeurs pour tes Items et génère une liste plutôt qu'un tableau...

Regarde les tutoriaux de Loulou24, ils sont super bien fait, il a super bien bossé dessus, appuie toi sur son code très propre !!

Concernant les smartpointeurs , j'en fais mon affaire ;)
Et pour le conteneur a utiliser, ce n'est qu'un exemple, je n'ai pas encore choisit celui qui me sera le plus adapté ; mais c'est un détail !

je trouve les tuto de loulou bien fait aussi; mais j'ai un peu de mal a rentrer dedans , et quand j'ai une idée en tête, j'aime bien la réaliser :p et je me suis mis en tête que la facons dont je vois ma factory n'est aps trop mauvaise pour le moment .... reste juste que je rame comme c'est pas possible pour l'implementation :)

merci des conseils !

Citation:

---

Envoyé par Ti-R

Regarde les tutoriaux de Loulou24, ils sont super bien fait, il a super bien bossé dessus, appuie toi sur son code très propre !!

---

Merci :ave:

Pour ta fabrique dis nous tout ce que tu as déjà en tête, même si c'est encore un peu flou, peut-être qu'on pourra t'aider à y voir plus clair.

heu, juste une question, concernant mon cItem * tab[100] j'ai bon sur la signification ou pas ?

Enfin, je vais essayer de vous dire noir sur blanc ce que je souhaite avoir ... ( en essayant de passez les détail technique car c'est sur eux que je blocque )

une classe particuliére qui aura pour but unique de gérer TOUT les objets de mon jeu ( perso, monstre, map, item, animation,script en tout genre ect ... )

Cette classe possédera a priori 3 fonctions de base
- une qu'on apellera load ; dont le but sera uniquement de Créer un objet d'un type précis a partir d'information contenu dans des fichiers ( je me charge de la bonne récupération de ces info ... ) en mémoire et de le stocker qqupart .
- une qu'on apellera get() et qui prendra en paramétre un identifiant et me renvera un pointeur vers l'objet créer précédement en mémoire ayant cet identifiant . ( ce qui me premetra de manipuler ces objet dans le reste de mon programme )
( Tout les identifiant seront Unique ! )
- une qu'on nommera free() et qui se chargera juste de détruire de la mémoire un objet créer précédement ( prenant donc en paramétre l'identifiant de l'objet a détruire )

Je pense stocker tout ces objets dans un même conteneur ( la est peut-etre mon erreur ... ) .
Je pense faire de cette classe un singleton .

Et aprés ca ... je séche :/

Cela peut fonctionner, pas de problème la dessus, il faut juste que tous tes objets héritent de cItem.

Le problème est aussi qu'il faut que tu stocke un identifiant par class.

IDENTIFIANT_PERSO3D, IDENTIFINAT_ARME_FUSIL etc...

Pour chaque class, ce qui permet de charger facilement les éléments, lorsque tu vois l'identifiant 3 qui correspondrait à IDENTIFIANT_PERSO3D, tu créer la class CPerso3D, tu appels ta méthode Load(); avec un pointeur sur ton fichier en paramètre, et hop tu as loadé l'objet 3D :) etc...

Donc n'oublie pas dans CItem l'identifiant "int identifiant;" qui te permettra le chargement…

Heu, si j'ai comprit, tu me coseil de faire une classe par objet ?
Je pense plutot faire une classe par "type" d'objet . Mais je suis ouvert a toute proposition :p merci

Donc en fait ca revient a faire comme je l'avais évoqué avant : toutes mes classe dérivent de cItem qui contient juste un menbre du style

Code:

---

1 2	string identifiant ;

---

Et toi tu propose d'ajouter un deuxieme identifiant pour savoir quel type d'objet va être a chargé c'est cela ? oui c'est une idée :p mais je pense qu'un fois le gros du travail résolu, ca ira vite sur les petit sdétails comme ca ! mais merci quand meme !!!

Citation:

---

heu, juste une question, concernant mon cItem * tab[100] j'ai bon sur la signification ou pas ?

---

Oui :D

Tu as une solution très simple pour ton problème, qui est pratiquement similaire au gestionnaire de ressource que je décris dans mes tutos, à savoir :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

struct cItem { string Id; };   class cTruc : public cItem { // ... }; class cMachin : public cItem { // ... };

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

class cItemManager { public :   template <class T> T* Get(const string& Id) const { // Recherche dans la map et renvoie du pointeur casté en T* }   void Add(cItem* Item, const string& Id) { Items[Id] = Item; }   void Remove(const string& Id) { Items.remove(Id); }   private :   map<string, cItem*> Items; };

---

Code:

---

1 2	cPerso* Gerard = cItemManager::Instance().Get<cPerso>("Gerard"); cMap* Village = cItemManager::Instance().Get<cMap>("Village");

---

Hypothèses : le gestionnaire d'items ne s'occupe que du stockage des objets, leur bon chargement est effectué par une autre classe.

Inconvénient : le type réel des objets est perdu, et retrouvé à l'aide d'un cast barbare. Si tu demandes "Maison" en tant que cBatiment alors que c'est un cCarte, le compilo n'y verra que du feu et tu te retrouveras avec un segfault pas facile à debusquer.

Avantages : c'est simple, ça fait parfaitement le job, et ça marche pour toute classe pour peu qu'elle dérive de cItem. Après tu peux automatiser la gestion / destruction des items, via la classe cItem, le comptage de références et des pointeurs intelligents améliorés.

Bien sûr c'est une vision des choses, mais qui je pense colle bien avec ce que tu souhaites. On pourrait très bien imaginer d'autres modèles : une fabrique plus "évoluée" qui prend en charge également l'importation automatique des ressources (cf. MediaManager dans mes tutos), ou encore un système plus classique avec un gestionnaire par classe de ressource.

Citation:

---

Envoyé par Clad3

Heu, si j'ai comprit, tu me coseil de faire une classe par objet ?
Je pense plutot faire une classe par "type" d'objet . Mais je suis ouvert a toute proposition :p merci

---

Non pas une classe par objet mais comme tu le dis une classe par type d'objet :)

String identifiant oui c'est comme le int identifiant, même principe.

Ouha :ave: un grand merci encore loulou ;)
J'étais justement entrain de me lancer dans le codage de tout ca pour voir de plus prés comment ca allait se goupiller !

Bon je vais détailler ca au fur et a mesur histoire de voir si j'ai bien tout pigé ... avant de continuer de coder la chose !

Citation:

---

struct cItem
{
string Id;
};

class cTruc : public cItem
{
// ...
};
class cMachin : public cItem
{
// ...
};

---

Pour l'instant on est d'accord, j'avais la même vision de la chose ! ( sauf que je cré une classe cItem et non une struct ... mais bon c'est juste que je suis allergique de naissance au struct ... allez savoir pourquoi lol !)

Concernant la classe cItemManager que tu décrit, je ne vois pas grand chose a y redire ... il me restera juste a l'implementer pour voir si des petit probleme persiste ... mais rien de bien méchant a mon avis .

Ensuite le détail qui me turlupine encore , et je crois que c'est ce que tu évoque en disant a la fin de ton message qu'on peut faire évolué cette factory en lui faisant importer ( donc créer ) automatiquement les ressources .

En fait, si je fait par exemple comme tu dit , c a d en créant une seconde classe pour le chargement même des données ( au fait, j'aime beaucoup l'idée de séparé le stockage et le chargement des items ^^ merci )
Je ne vois pas comment Créer l'item !!

Pour l'ajouter je suppose que ca ira :

Code:

---

1 2	cItemManager::instance().Add( &MonItem,"gerard" ) ;

---

Mais comment créer ce "MonItem" ... la je seche :/

Enfin, encore merci pour ce jolie post ... ca ma permis de bien mieux cerner les choses !

Citation:

---

sauf que je cré une classe cItem et non une struct ... mais bon c'est juste que je suis allergique de naissance au struct

---

Oui j'utilise souvent des struct dans mes exemples sur les forums, mais c'est simplement un raccourci, lorsqu'il y a peu de données et toutes publiques, pour ne pas écrire

Code:

---

1 2 3 4

class xxx { public : // ....

---

Ce qui est tout à fait équivalent. D'ailleurs... c'était inutile dans mon post précédent, car typiquement l'identifiant sera protegé ou privé :D
Bref.

Citation:

---

Pour l'ajouter je suppose que ca ira :

Code:

---

cItemManager::instance().Add( &MonItem,"gerard" ) ;

---

---

Tout à fait, au détail près que tu ajouteras un objet alloué dynamiquement et non l'adresse d'un objet automatique, donc pas de & (ok c'est un détail, mais sait-on jamais, parfois ça évite des erreurs bêtes).
Ou alors, comme l'identifiant est déjà associé aux instances de cItem (puisque c'est une donnée membre) tu peux automatiser l'ajout, dans le constructeur de cItem ou dans une fonction de chargement des cItem.

Citation:

---

Mais comment créer ce "MonItem" ... la je seche :/

---

Ca dépend, principalement de la manière dont tous tes objets vont être exprimés à l'exterieur de ton appli (dans des fichiers). Il va falloir préciser un peu cet aspect je pense, pour trouver une jolie solution.
Est-ce que 1 fichier = 1 objet ? 1 fichier = un niveau ? Est-ce que le contenu des fichiers sera + ou - similaire pour chaque type à charger ? ...
Mais bon, globalement il faudra une fabrique (une vraie), que tu pourras plus ou moins customiser selon tes besoins.

Oki, je pense qu'on est d'accord pour le &MonItem, en pratique on fera plutot un

cItem * MonItem ;

et

cItemManager::instance().Add( MonItem,"gerard" ) ;

C'est ca?

Ensuite, concernant le format de mes fichiers ... j'ai une idées en tête, rien de plus .
Surement un fichier / niveau ( enfin l'equivalent des niveau pour un jeu de plateforme par ex ) ou seront réparti tout les "item" a chargé .
Et je pense qu'il sera aussi necessaire d'en charger d'autre au fur et a mesur dans les niveaux ...
Heu sinon , oui je pense que le contenu des fichier seront a peu prés les meme pour plusieur item d'un meme type mais pas d'un type a l'autre . ( par contre, je pense que se sera dans tout les cas assez simple ; des valeurs associé a chaque caractére ; le tout permettant de décrire l'objet ... )
A mediter ^^

I'm back !
Re bonjour a tous !
Aprés une petite journée de méditation j'ai pensé a une solution pour gérer la création des item eux meme ... Bon ce n'est certainement ( surement ) pas une methode trés propre ni trés optimale ...mais c'est un début ...et je pense que ca peut marcher .... Je m'en vais vous comter son histoire :D

Il était une fois ....
Alors, on reprend nos classe précédente ( cItem et cItemManager )

Pour le chargement, on utilise une classe cLoader qui va procéder de la sorte .

( on va admetre que la récupération des données dans un fichier se fait de maniére inutuitive ... )

Elle possédera une methode init()
->Celle ci sera la methode principale, elle parcourera un fichier donné
et a chaque nouvel objet décrit, elle apellera une fonction précise, propre a chaque TYPE d'objet a charger . Et ce ainsi de suite, jusqu'a ce que tout les objets soit créer / stockés en mémoire .

Toute ses sous-fonction seront bati sur le meme principe .
Elle vont affecter les donnée caractérisant l'objet a des variables menbre d'une classe singleton représentant le type d'objet a créer .

ex:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

void BatimentLoader() { cBatimentModel::Instance().nom = maison de jean cBatimentModel::Instance().taille = 2 cBatimentModel::Instance().poid = 100 cBatimentModel::Instance().prix = 200 }   void ArmeLoader() { cArmeModel::Instance().nom = pistolet cArmeModel::Instance().puissance = 23 cArmeModel::Instance().portée = 2 }

---

En version simplifié car ces données ( maison de jean , 2, 100 ect...) seront lu a partir d'un fichier du style :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

[BATIMENT] nom = maison de jean taille = 2 100 prix = 200 [/BATIMENT]   [ARME] nom = pistolet puissance = 23 portée = 2 [/ARME]

---

Pourquoi faire comme ca ? Je sais pas trop ... ms je ne vois pas la version + simple ( j'aime bien les chose compliqué pr rien ^^ )

Ensuite , on a donc en mémoire les carac de notre objet accessible a tout instant . il ne nous reste plus qu'a le crée :

Dans les 2 fonctions décritent + haut, on ajoute qquchose du style :

Code:

---

1 2 3

cItemManager::instance().Add( new cBatiment() ,"maison de jean1" ) ; cItemManager::instance().Add( new cArme() ,"pistolet_debut" ) ;

---

Ensuite, dans chaque constructeur de cBatiment , cArme ect ... on apelle une fonction init() qui se charge d'affecter les valeur des variable de la cMaClasseModel a mon objet courant ( possédant exactement les meme variable menbre .

nous voila donc avec nos objets créer et stocker en mémoire ....

2 questions me viennent a l'esprit
1) L'idée est bonne? ( dans le sens : " ca peut marcher ?"
2) Comment on améliore cette horreur :D ?

A pluche les jeunes !

Si j'ai bien compris ce que tu as expliqué, j'ai déjà fait un truc quasi pareil, et cela fonctionne :)

Donc :ccool:

Voila ce que j'ai fait jusqu'a présent ... je n'ai aps encore testé, mais je pense qu'il n'y a pas trop d'erreur ... enfin ca compile ^^

citem.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#ifndef CLASSE_CITEM #define CLASSE_CITEM   #include <string>   /* --------------------------------------------------------------------------------- */ // Classe 'abstraite' représentant une entiée quelquonque dans le jeu . /* --------------------------------------------------------------------------------- */   class cItem { public : cItem (); ~cItem (); public : std::string id ; };   #endif

---

cItem.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include "cItem.h"   /* --------------------------------------------------------------------------------- */ // constructeur simple /* --------------------------------------------------------------------------------- */   cItem::cItem() {   }   /* --------------------------------------------------------------------------------- */ // destructeur simple /* --------------------------------------------------------------------------------- */   cItem::~cItem() {   }

---

cRessourcesManager.h

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

#ifndef CLASSE_CRESSOURCESMANAGER #define CLASSE_CRESSOURCESMANAGER   #include <string> #include <map> #include <iostream> #include "cItem.h"   /* --------------------------------------------------------------------------------- */ // Classe permettant de stocker en mémoire les différentes entitées du jeu . /* --------------------------------------------------------------------------------- */   class cRessourcesManager { private : cRessourcesManager (); public : ~cRessourcesManager(); static cRessourcesManager & GetInstance(); void add(const std::string & Id, cItem * item ); void remove(const std::string & Id); template < class T > T * get( const std::string & Id ) const { std::map<std::string, cItem *>::iterator it; if ( Items.find(Id) == Items.end() ) { std::cout << " Erreur ( classe cRessourcesManager ) " << std::endl ; } else { return (T *) * it; }   }   public : std::map<std::string, cItem*> Items ; };   #endif

---

cRessourcesManager.cpp

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

#include "cRessourcesManager.h"   /* --------------------------------------------------------------------------------- */ // constructeur simple /* --------------------------------------------------------------------------------- */   cRessourcesManager::cRessourcesManager() {   }   /* --------------------------------------------------------------------------------- */ // destructeur simple /* --------------------------------------------------------------------------------- */   cRessourcesManager::~cRessourcesManager() {   }   /* --------------------------------------------------------------------------------- */ // Un Handle sur notre instance /* --------------------------------------------------------------------------------- */   cRessourcesManager & cRessourcesManager::GetInstance() { static cRessourcesManager instance ; return instance ; }   /* --------------------------------------------------------------------------------- */ // Permet d'ajouter en mémoire une entitée dans notre conteneur . ( map ) /* --------------------------------------------------------------------------------- */   void cRessourcesManager::add(const std::string & Id ,cItem * item) { Items[Id] = item ; }   /* --------------------------------------------------------------------------------- */ // Permet de détruire la mémoire alloué à une entitée dans notre conteneur . ( map ) /* --------------------------------------------------------------------------------- */   void cRessourcesManager::remove(const std::string & Id ) { Items.erase(Id) ; }

---

et voila pour le moment :)