Gestion des classes entre elles et organisation.

**Hybrix** · 16/08/2007, 21h32

Merci beaucoup,

J'ai enfin compris (corrigé moi si je me trompe) :
- myListener contient les "objets" qui souhaite recevoir les evenements
- On ajoute les objets souhaitant recevoir la liste des évènements à myListener
- On parcours la liste et on envoie les evenements a chaque membre de la liste.

J'aurais aimer savoir, l'architecture du .zip est-elle correct ? Est ce la bonne technique de faire hériter la classe Player de la classe GameEngine, graphicEngine, audioEngine, ... ?

**Laurent Gomila** · 17/08/2007, 08h34

J'aurais aimer savoir, l'architecture du .zip est-elle correct ? Est ce la bonne technique de faire hériter la classe Player de la classe GameEngine, graphicEngine, audioEngine, ... ?

Non absolument pas. Ton jouer n'est pas un moteur de jeu, ni un moteur graphique ou un moteur de son. Par contre, ton joueur utilise tout ça. Donc il va faire des appels à des fonctions des classes correspondantes, mais jamais en dériver.

**Hybrix** · 17/08/2007, 11h45

Non absolument pas. Ton jouer n'est pas un moteur de jeu, ni un moteur graphique ou un moteur de son. Par contre, ton joueur utilise tout ça. Donc il va faire des appels à des fonctions des classes correspondantes, mais jamais en dériver.

C'est la que je ne voit pas comment faire, si le joueur n'hérite pas des moteurs comment peut t-il accédé à leur fonctions ???

**Laurent Gomila** · 17/08/2007, 12h08

Il faut qu'il dispose de leurs instances, via un système de singleton ou autre. Tu ne comptes pas avoir 50 moteurs de jeu en même temps, un seul suffit on est bien d'accords ?

**Hybrix** · 17/08/2007, 14h47

J'ai lu des tutoriels sur le système Singleton, mais je n'en voit pas l'utilité, voilà ce que j'ai fait :

Singleton.hpp

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
 
/* ---------------------------------------------------------------------
   (c) Hybrix 2007
 
   Singleton ( Evite la création de plusieurs classes identiques )
   --------------------------------------------------------------------- */
 
#ifndef H_SINGLETON
#define H_SINGLETON
 
template<typename T> class Singleton
{
 
  public:
    static T* getInstance()
    {
        static T theSingleInstance;
        return & theSingleInstance;
    }
};
 
#endif

Player.hpp

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
 
/* ---------------------------------------------------------------------
   (c) Hybrix 2007
 
   Gestion du joueur et des évenements
   --------------------------------------------------------------------- */
 
#ifndef H_PLAYER
#define H_PLAYER
 
#include <iostream>
#include <string>
#include <vector>
 
#include <SFML/Window.hpp>
 
#include "../Others/Singleton.hpp"
#include "../Physic/Physic.hpp"
 
class Player : public Singleton<Player>
{
    friend class Singleton<Player>;
 
    public:
        Player();
        ~Player();
 
        bool Event(sfEvent &Event);
};
 
#endif

Non, les différents moteur sont déclarés une seul fois dans Game.cpp, après les autres classes doivent pouvoir les utilisés.

**Laurent Gomila** · 17/08/2007, 15h04

Les singletons ça sert pas à grand chose, sinon d'avoir une variable globale un peu mieux maîtrisée. D'ailleurs le tien n'est pas un singleton, il faut également empêcher la copie si tu veux être complet.

Le but de ma remarque c'était de te faire remarquer que si tu fais hériter Player de Game ou autre, tu vas créer une instance de Game particulière en même temps que ton Player. Or l'instance de Game doit être unique et globale.

**Hybrix** · 17/08/2007, 15h26

Je comprend mieux leur utilité, si je fait hérité Player du moteur graphique ça revenait à crée et utiliser un "nouveau" moteur graphique, ça ne reprenait pas celui existant. Les singletons évite donc ce problème de création multiple.

Mais je ne voit toujours pas comment faire communiquer le joueur avec les différents moteurs

.

**Laurent Gomila** · 17/08/2007, 15h34

Il faut juste que tu trouves un moyen de rendre les instances de tes moteurs accessibles globalement. Par exemple si tu as un singleton, tu feras juste "Graphics::GetInstance().TrucMuch();".

**Hybrix** · 17/08/2007, 17h49

J'ai modifié ma classe Singleton :

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
/* ---------------------------------------------------------------------
   (c) Hybrix 2007
 
   Singleton ( Evite la création de plusieurs classes identiques )
   --------------------------------------------------------------------- */
 
#ifndef H_SINGLETON
#define H_SINGLETON
 
template<typename T> class Singleton
{
public:
 
    static T* GetInstance(void)
    {
        if(singleton==0)
        {
            singleton = new T;
        }
        return singleton;
    }
 
    static void Kill()
    {
        if(singleton!=0)
        {
            delete singleton ;
 
        }
    }
 
    protected:
 
    int value;
 
    Singleton()
    {
        value = 0;
    }
 
    virtual ~Singleton()
    {
 
    }
 
    static T *singleton;
};
 
template <typename T> T* Singleton<T>::singleton = 0;
 
#endif

J'ai essayé de reproduire l'architecture du tuto "Architecture d'un jeux vidéo 3D", Mais j'ai l'impression qu'il manque certaine information, je nevoit pas dans quelle classe est déclaré le joueur.

J'ai essayé de refaire la classe engine, qui permet de lier les moteurs ensembles, il est ecrit :

Code :

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

1
2
3
4
5
 
	// let's link the engines together
	n->attach_game_engine(g);
	n->attach_graphics_engine(gfx);
	n->attach_sound_engine(s);

Mais la fonction se trouve dans la classe Engine qui est abstraite, je ne voit pas comment il peut contacté la classe engine alors qu'elle n'est pas dérivée.

Si je fait comme dans l'architecture, les moteurs communiqueront ensemble logiquement non ?

( Je ne sais plus trop quoi faire :s )

**Polyfructol** · 17/08/2007, 19h33

Et bien moi aussi je cherche une bonne solution pour lier les différentes classes de mon jeu. Après avoir jeté un oeil au tuto "Architecture d'un jeux vidéo 3D", je suis arrivé à ça :

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
#include <iostream>
 
using namespace std;
 
class Engine
{
    public:
        void showText(char *text) { cout << "Texte : " << text << endl << endl; }
        Engine* getInstance() { return this; };
};
 
class Player
{
    private:
        Engine *e;
    public:
        Player() { e = NULL; }
        Engine* getEngineInstance() { return e; }
 
        void attachEngine(Engine* engine_to_attach);
        void speak(char *text);
};
void Player::attachEngine(Engine* engine_to_attach)
{
    e = engine_to_attach;
}
void Player::speak(char *text)
{
    e->showText(text);
}
 
int main(int argc, char ** argv)
{
    Engine *e = new Engine;
 
    Player *player1 = new Player;
    player1->attachEngine(e);
 
    player1->speak("Hello");
 
    /* J'affiche l'adresse des 2 moteurs, pour vérifier 
       que le moteur est bien instancié qu'une seule fois */
    cout << "e->getInstance() : " << e->getInstance() << endl;
    cout << "player1.getEngineInstance() : " 
         << player1->getEngineInstance() << endl << endl;
 
    delete e;
    delete player1;
 
    system("pause");
}

La console rend :

Code :

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

1
2
3
4
Texte : Hello
 
e->getInstance : 0x3e3fb8
player1->getEngineInstance() : 0x3e3fb8

Le joueur a bien accès au moteur, moteur qui est instancié qu'une seule fois si je me trompe pas

.

Je n'ai pas utilisé le modèle singleton pour la classe engine, mais je pense que ça serait judicieux. Bon aussi j'avoue n'être pas totallement sûr de ce que j'ai fait, il se pourrait bien qu'il y ai des fautes dans le code, notamment au niveau du constructeur de player : Player() { e = NULL; }

(est-ce utile ?)

J'espère que ça t'aidera quand même.

Au passage bravo pour le travail déjà accompli sur ton jeu, continue comme ça

EDIT : Le même code à la sauce singleton

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
#include <iostream>
 
using namespace std;
 
class Engine
{
    private:
        static Engine * uniqueInstance;
    protected:
        Engine() { };
        ~Engine() { };
    public:
        static Engine* getInstance();
        static Engine* freeInstance();
 
        void showText(char *text) { cout << "Texte : " << text << endl << endl; }
};
Engine* Engine::uniqueInstance = NULL;
Engine* Engine::getInstance()
{
    if (uniqueInstance == NULL)
        uniqueInstance = new Engine;
    return uniqueInstance;
}
Engine* Engine::freeInstance()
{
    if (uniqueInstance != NULL) {
        delete uniqueInstance;
        uniqueInstance = NULL;
    }
}
 
class Player
{
    public:
        void speak(char *text);
};
void Player::speak(char *text)
{
    Engine::getInstance()->showText(text);
}
 
int main(int argc, char ** argv)
{
    Player *player1 = new Player;
 
    player1->speak("Hello");
 
    delete player1;
    system("pause");
}

Là on tombe sur ce que Laurent te disait c'est à dire pour utiliser une fonction du moteur dans la class Player avec un singleton il suffit de faire : Engine::getInstance()->showText(text);

**Hybrix** · 20/08/2007, 11h32

Merci beaucoup pour votre aide

,

J'ai tout de même continué à suivre le tutorie sur "l'Architecture d'un moteur 3D", et je pense avoir enfin réussi à faire ce que je voulais

, ça m'a permis d'apprendre pas mal de nouveautés en C++.

Voici une archive de test (Que je vais ré-organisé bien sur

) : Ici

La variable test présente dans le moteur physique est accessible de partout

.

Je voudrais savoir si le code n'a pas de problèmes avant de continué.
Merci encore.

**Hybrix** · 21/08/2007, 14h00

Des avis sur mon architecture ?

**Polyfructol** · 21/08/2007, 14h34

Salut,

Tu ne devrais pas séparer tes fichiers d'entêtes de tes fichiers sources.

#include "../../Includes/Main/Game.hpp"

C'est assez lourd alors que bon, je vois pas le problème de faire juste un : #include "Game.hpp".

Aussi, je crois que ça se fait rarement d'ajouter un fichier d'entête au main.cpp, mais je me trompe peut-être.

Ensuite pour la séparation des modules par des répertoires, je trouve ça clair, mais si tu ne dois pas avoir plus d'un fichier par répertoire ce n'est peut-être pas utile, faut voir à l'utilisation

.

**Hybrix** · 21/08/2007, 14h43

Code :

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

1
2
3
4
5
Tu ne devrais pas séparer tes fichiers d'entêtes de tes fichiers sources.
 
#include "../../Includes/Main/Game.hpp"
 
C'est assez lourd alors que bon, je vois pas le problème de faire juste un : #include "Game.hpp".

J'ai préféré les séparé pour un point de vus organisation (apres les avoir inclues ça ne pose pas de problèmes ( Mon point de vue )

Code :

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

Ensuite pour la séparation des modules par des répertoires, je trouve ça clair, mais si tu ne dois pas avoir plus d'un fichier par répertoire ce n'est peut-être pas utile, faut voir à l'utilisation .

Si si

, il y aura pas mal de fichiers par répertoires.

Merci d'avoir donné ton avis

.

**Hybrix** · 29/08/2007, 19h54

Bonjour,

Désolé pour a nouveau le remontage de topic, je préfère utiliser celui existant, sachant que mes questions sont sur le même sujet

.

J'ai continué l'architecture de mon jeu, mais au fur et à mesure de l'avancement je me pose des questions :

Actuellement tout les moteurs communiquent entre eux.

Gestion général :
- Comment doit-je gérer tout ça ?
Pour le moment, j'ai eu l'idée de crée un vector contenant tout les éléments du jeu (decors, objets, joueur, ...). Chaque moteur contient un vector pointant vers cette liste.

Exemple :

Classe Game :

Code :

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

1
2
 
std::vector<Level> level;

Moteur graphique :

Code :

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

1
2
3
4
5
6
7
8
 
void Graphic::Frame()
{
     unsigned int number = level.size();
 
     for(unsigned int i = 0; i < 0; i++)
         level[i].draw();
}

- j'ai eu l'idée de crée une classe abstraite Event, comme ça chaque classe souhaitant connaitre l'etat d'une touche aurait juste à en heriter, est-ce correct ?

Bref, je ne voit pas vraiment comment faire.

Soit le moteur graphique affiche chaque objet, ou ce que je pense etre correct, chaque element fait appelle au moteur graphique et non l'inverse.

J'ai regardé le code source de super tux, je ne le trouve pas très organiser

.

Gestion des classes entre elles et organisation.

Développement 2D, 3D et Jeux

Discussions similaires

Partager

Partager