Le jeu progresse !
Voici la première mise à jour d'une nouvelle série.
En effet, j'attaque maintenant l'ajout de fonctionnalité. Bon là, je triche un peu, car ce sont des choses qui été plus ou moins déjà présente.
Ainsi, aujourd'hui, j'ai un peu travaillé sur la classe MenuBox (qui affiche une boite de menu, avec plusieurs entrées) pour qu'elle soit prête à répondure à tout les cas que l'on a vu auparavant.
Effectivement, même si cette classe était déjà présente avant, il n'y avait pas de mécanisme afin d'afficher ou d'effacer certaine entrées non valides. Maintenant si.
J'utilise une nouvelle structure internet pour les entrées, qui contient 4 champs:
Comme vous pouvez le voir, il y a un booléan pour dire si l'entrée est active ou non. Si elle ne l'est pas, elle n'est ni affichée, ni prise en compte.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10 struct MenuItem { std::string actionName; /*!< id of the entry */ std::string displayName; /*!< name to display */ AnimatedSprite* pASprite; /*!< sprite to display */ bool enabled; /*!< true if this entry is displayed */ MenuItem(const std::string& actionName, AnimatedSprite* const pASprite, const std::string& displayName) :actionName(actionName),displayName(displayName),pASprite(pASprite),enabled(true) {} };
De plus, j'utilise maintenant un nom d'action (qui est aussi utilisé comme identifieur pour l'activation, désactivation de l'entrée) afin de pouvoir retournée une information cohérente pour enclecher une action selon l'entrée sélectionnée. Le mieux, ça serait un mécanisme utilisant des pointeurs de fonctions, mais je ne pense pas que ce serai une bonne idée.
Une autre idée qui me vient en tête en écrivant ce message, c'est l'utilisation de template. Il faudrait que je me penche là dessus.
Enfin, bref, pour le moment, cela suffit
L'autre ajout, ce sont les états du jeu. Ainsi, lorsque le joueur voit la carte / bouge le curseur c'est l'état Neutre. Chaque état à une classe correspondante. En ce moment, j'ai implémenté 4 états qui héritent tous de:
Le principe, assez simple, c'est que chaque état connait ce qu'il doit faire (une méthode de dessin et une méthode de mise à jour). La méthode update (de mise à jour) est intéressante, car elle se doit de renvoyer l'état qui va suivre (selon les différents choix de l'utilisateur).
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 enum IGState { IGS_Idle, IGS_Menu, IGS_Construction, IGS_UnitSelected, IGS_Quit }; class InGameState { protected: Map* pMap; const Camera* pCamera; Cursor* pCursor; public: InGameState(Map* pMap, const Camera* pCamera, Cursor* pCursor); virtual ~InGameState() {} virtual bool draw(NE::Renderer* pRenderer, unsigned int time)=0; virtual IGState update(NE::InputManager::ArrowsDirection direction, NE::InputManager::Buttons buttons, unsigned int time)=0; };
S'il n'y a pas de changement, la fonction retourne donc l'enum de l'état actuel. Sinon, on retourne le nouvel état.
Le changement d'état se fera dans la classe Game, automatiquement, grâce à l'utilisation d'une std::map (dont la clé est le IGState).
On pourra remarquer, que depuis cette mise à jour, les fonctions de la classe Game sont toutes simples . Donc l'introduction des états permet de faire une meilleure architecture (moins foulli) du code.
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 bool Game :: draw(NE::Renderer* pRenderer, unsigned int time) { bool bResult = true; // Drawing part bResult &= MapDrawer::draw(*pRenderer,pMap,*pCamera,time); bResult &= states[igState]->draw(pRenderer,time); return bResult; } bool Game :: update(NE::InputManager::ArrowsDirection direction, NE::InputManager::Buttons buttons, unsigned int time) { (void) time; pCamera->update(*pCursor,*pMap); igState = states[igState]->update(direction,buttons,time); if ( igState == IGS_Quit ) { return false; } return true; }
Voilà.
J'ai implémenté les états:
- Idle
- Construction d'unité
- Menu (un menu très simple pour le moment)
- Sélection d'unité (par encore complet, car il me faut faire une classe utilitaire)
Ce qui arrivera prochainement:
Une nouvelle classe qui contiendra les informations courantes sur le jeu (le joueur actuel (pour la gestion des factions) et les sous qu'il a (pour la construction)).
Et une autre classe qui aura surement des fonctions statiques (classe utilitaire) qui génèrera des surcouche pour la carte afin d'indiquer là ou le joueur peut attaquer ou se déplacer).
Partager