Gestion de scènes dans les jeux vidéo Flashcards
Qu’est-ce qu’une scène dans un jeu vidéo et à quoi peut-on la comparer?
Une scène dans un jeu est l’équivalent d’une fenêtre dans une application de gestion. Elle représente un état distinct du jeu avec ses propres éléments et logique.
Quelles sont les trois scènes de base que possède presque tout jeu vidéo?
- Un menu (ou une scène de titre)
- Une scène de jeu
- Une scène de fin de partie
Comment SFML gère-t-il les scènes par défaut?
Par défaut, SFML n’a pas de mécanisme de gestion des scènes. Il est du ressort du programmeur de s’assurer un bon découpage au niveau du code.
Quels sont les trois modèles possibles de gestion des ressources dans un système de scènes?
- Par la partie (Game)
- Par les scènes de manière individuelle
- Conjointement par la partie et les scènes (modèle hybride)
Quel modèle de gestion des ressources est probablement le plus efficace mais aussi le plus complexe?
Le modèle hybride, où les ressources sont gérées à la fois par la partie ET par les scènes, est probablement le plus efficace mais aussi celui qui demande le plus d’attention.
Quelles sont les méthodes virtuelles principales que devrait avoir une classe Scene de base?
virtual ~Scene();
virtual SceneType update() = 0;
virtual void draw(sf::RenderWindow& window) const = 0;
virtual void pause();
virtual void unPause();
virtual bool init() = 0;
virtual bool uninit() = 0;
virtual bool handleEvents(sf::RenderWindow& window);
Quelle structure de données est généralement utilisée pour gérer les scènes dans un jeu?
Une pile (stack) est généralement utilisée pour stocker les scènes. La scène au sommet de la pile est la scène active qui est mise à jour et affichée à chaque rendu.
Que se passe-t-il au démarrage d’un jeu utilisant une pile de scènes?
Au démarrage du programme, on place sur le dessus de la pile la scène représentant le menu principal.
Comment gère-t-on la fin d’un jeu dans un système de scènes basé sur une pile?
Si le joueur choisit de quitter le jeu, on éjecte (pop) le dessus de la pile. Si la pile devient vide, c’est la fin de l’application.
Comment détermine-t-on si le jeu doit se terminer dans la méthode update de la classe Game?
bool Game::update() {
bool gameMustEnd = scenes.empty();
// Mise à jour du jeu
return gameMustEnd;
}
Que se passe-t-il quand un joueur choisit de démarrer le jeu à partir du menu principal?
On ajoute la scène de jeu sur le dessus de la pile. Cette scène devient la nouvelle scène active qui sera mise à jour et affichée à chaque rendu.
Que retourne la méthode update d’une scène et comment cela affecte-t-il le système de scènes?
Chaque scène retourne dans son update le type de la prochaine scène devant être traitée. Si aucun changement n’est à apporter, la scène retourne son propre type. Si un changement est nécessaire, elle retourne le type de la scène à afficher ensuite.
Quels sont les deux cas possibles lorsqu’une scène active retourne un type de scène différent du sien?
- On veut ajouter une scène par-dessus la pile (ex. on démarre le jeu par-dessus le menu principal)
- On veut enlever une scène au-dessus de la pile (ex. le jeu se termine et on veut retourner au menu principal)
Comment ajoute-t-on une nouvelle scène au-dessus de la pile?
Pour ajouter une nouvelle scène, la scène active retourne le type de scène à ajouter. La partie doit alors:
Créer la nouvelle scène
Initialiser la nouvelle scène
Placer la nouvelle scène sur le dessus de la pile
Comment retire-t-on la scène active du dessus de la pile?
Pour retirer la scène active, celle-ci doit retourner une valeur spéciale (généralement SceneType::NONE) au terme de la méthode update.
Comment définit-on une valeur spéciale pour indiquer qu’une scène doit être retirée de la pile?
enum class SceneType {
NONE, // <== Valeur à retourner pour enlever la scène sur la pile
MAIN_MENU,
LEVEL01,
PAUSE_MENU,
};
Comment crée-t-on une nouvelle scène en fonction du type demandé?
Scene* Game::getNextScene(SceneType type) const {
Scene* scene = nullptr;
switch (type) {
case SceneType::PAUSE_MENU: {
scene = new PauseMenu();
break;
}
case SceneType::MAIN_MENU: {
scene = new MainMenu();
break;
}
case SceneType::LEVEL01: {
scene = new Level01();
break;
}
}
return scene;
}
Comment peut-on passer de l’information d’une scène à l’autre?
On peut utiliser un attribut statique dans la classe Scene, généralement de type SceneResult, qui peut contenir des informations spécifiques à chaque type de scène.
Qu’est-ce qu’un SceneResult et comment est-il généralement structuré?
SceneResult est généralement un union qui contient des structures spécifiques à chaque type de scène:
union SceneResult {
MainMenuResult mainMenuResult;
Level01Result level01Result;
};
Où MainMenuResult, Level01Result, etc. sont des structures contenant les informations à échanger.
Pourquoi utilise-t-on un union pour SceneResult plutôt qu’une autre structure de données?
L’utilisation d’un union permet d’atteindre l’objectif de partage d’informations efficacement, car un union n’alloue que l’espace nécessaire pour son plus grand membre, et permet d’accéder à différentes structures selon le contexte.
