Structure de programmation de jeu

Question

Je suis en train de programmer en C++ depuis un moment et je suis très familier avec la syntaxe. J'essaie d'utiliser Allegro pour faire un jeu de cartes. Je comprends tout ce que je dois faire pour la logique du jeu et ce n'est pas le cas. Ce qui me laisse perplexe est de savoir comment conduire le jeu. Je suis un peu nouveau pour les applications en boucle. Je me suis habitué à la programmation basée sur les événements dans VB .Net. Je ne suis pas sûr de la bonne façon de par exemple changer de joueur et élever des "événements" sans avoir beaucoup de "ifs" et "bools". Aussi en ce moment j'ai un tableau de bool pour vérifier quelle carte est en jeu. Et mon jeu se répète à chaque fois à travers le tableau des booléens et cela me semble désordonné. Aussi, si je veux passer de ma boucle de menu à ma boucle de paramètres, comment cela se fait-il sans un gros bool? Merci

Answer 1

La plupart des cadres de jeu fournir deux méthodes dont vous avez besoin pour mettre en œuvre (les deux sont appelés dans une boucle):

• Mise à jour
• Dessine

Le Update est l'endroit où vous devriez mettre tout cela, qui devrait vérifier l'entrée de l'utilisateur, les changements d'état, les actions intervallées, etc. Les exemples seraient Physique, Butto nAppuyez sur, etc. Rien ne vous empêche de travailler avec des événements ici (jetez un oeil à BoostLibrary Signals).

void Game::update() { 
    if(pushedButton) { 
     this->cardsOnTable->add(this->hand->remove(0)); 
     this->activePlayer = nextPlayer(); 
    } 
} 

Le Draw doit simplement rendre l'état actuel, sous-jacente à l'écran. Vous devez donc vous assurer que votre état/modèle sous-jacent est facile d'accès.

void Game::render() { 
    this->table->render(); 
    this->cardsOnTable->render(); 
    this->hand->render(); 
    // ... 
    flipBuffers(); 
} 

Vous pouvez résoudre votre menu/problème avec Scenes et menu Réglages un SceneManager (qui peut être une pile). Donc, au lieu de mettre la logique dans le Game directement, vous le mettez dans Scenes. Et vous pouvez pousser/afficher des scènes depuis/vers le gestionnaire.

void Game::update() { 
    this->sceneManager->activeScene->update(); 
} 

void MenuScene::update() { 
    if(settingsMenuItemSelected) { 
    game->sceneManager->push(new SettingsMenuScene)); 
    // now the next time Game::update() is called 
    // the active scene of the SceneManager will be 
    // the settings menu. And once it is closed/cancelled 
    // it will pop itself from the manager and we are back 
    // in the regular menu 
    } 
} 

Si vous voulez commencer avec plus de choses avancées, vous pouvez essayer de stocker des « événements » dans une liste énorme et tirer tous les événements lorsque vous entrez dans la méthode Game::update - c'est comment VB veille à ce que vous pouvez » t modifier les contrôles d'un autre thread que le thread UI - mais je ne pense pas que ce soit quelque chose que vous feriez en utilisant C++.

Answer 2

Voici de nombreuses questions différentes. Mes premières suggestions seraient de chercher du code source en ligne pour des jeux similaires. Si vous avez besoin d'aide avec le code, postez-le avec la question.

Answer 3

Vous aurez probablement besoin d'avoir un tas de ifs et des boucles allant quelque chose comme ceci:

while(1){ 
    initYourLevel(); 
    while(levelNotOver){ 
    //do things 
    } 
} 

Ensuite, tout dépend de ce que vous essayez de faire et votre question est une sorte de flou pour moi. Commencez à regarder tutorials pour comprendre comment les gens font les choses. Il y a beaucoup d'exemples de code là-bas!

espoir qui aide

Answer 4

En général, vous voudrez peut-être consulter un livre sur la programmation des idiomes et des modèles de conception, qui sont déjà discutés dans d'autres questions ici. Même s'ils ne sont pas directement liés aux jeux, ils vous aideront. Les Game-Engines sont un bon exemple de machines à états (état dans le jeu, paramètres d'état et sous-états) - vous pouvez tout faire avec des branchements conditionnels, etc., mais pour ne pas perdre la tête si elle devient plus grosse, il faut que tu résumes.
Il existe différentes approches pour la mise en œuvre des machines d'état en C++, basé sur les classes polymorphes (consultez votre favori C++ modèle livre), basé sur un modèle (boost.statechart), ...
Ce qui est est courant, lors de l'utilisation d'une boucle centrale vous des événements avant à un gestionnaire (représentant des états ou des sous-états) qui fera ce qui convient à la situation actuelle. Vous devez changer de comportement (par exemple du jeu aux options)? Éteignez les gestionnaires.

Vous voudrez également envelopper et faire abstraction de l'état actuel du jeu - il n'est pas nécessaire de gérer explicitement, par ex. cartes dans tous les lieux. Envelopper les choses par exemple un gestionnaire de cartes ou de joueurs qui le gère en interne.
Utilisez également les conteneurs et les algorithmes que C++ vous offre gratuitement, vous pouvez par exemple. gérer les cartes ou les joueurs au std::map s ou std::set s. Lorsque vous atteignez les limites de la bibliothèque standard check out boost.