Facebook Twitter Gplus RSS
magnify
Home Développement Créer une “IA” pour YaMeMo
formats

Créer une “IA” pour YaMeMo

Publié le 9 mai 2012 par dans Développement

Dans cet article j’évoque quelques mécanismes utilisés pour créer des joueurs artificiels pour le jeu de mémoireYaMeMo. Je ne suis absolument pas expert en intelligence artificielle mais j’espère qu’il y a quelques idées intéressantes à discuter. J’ai également tenté, lors du développement, de créer des adversaires qui se différencient par plusieurs critères. Je préfère donc parler de joueur artificiel plutôt que d’intelligence artificielle.

Moteur du jeu

Dans le jeu solo, le moteur réagit simplement aux événements déclenchés par l’utilisateur. Dans le cas d’un jeu avec un ou des adversaires artificiel, ou d’autres formes d’adversaires (ennemis dans les jeux d’action), le moteur doit solliciter le joueur artificiel.

Dans le cas d’un jeu d’action avec un nombre variable d’adversaires, on peut imaginer que le moteur demande à chaque adversaire de réaliser une action pendant la boucle principale du jeu (aussi souvent que possible). Dans un jeu basé sur des tours, c’est plus simple, le moteur n’a à appeler l’adversaire que lorsqu’il doit jouer. Pour rythmer le jeu, YaMeMo se base sur deux types d’événements:

  • entrées utilisateur : l’utilisateur à choisi une carte
  • fin d’animation (animationComplete): événement envoyé par un objet carte lorsque l’animation (carte couverte/carte découverte) est terminée

Le moteur utilise également deux états pour indiquer qui est en train de jouer (CPU_TURN / PLAYER_TURN), et des méthodes qui vérifient que la sélection est complète (deux cartes choisies) et si la sélection gagne (deux cartes identiques). Quelques exemples:

  • le joueur à choisi une carte / CPU_TURN : ne rien faire
  • animationComplete / CPU_TURN / sélection complète / sélection incorrecte : prochain tour même joueur
  • animationComplete / CPU_TURN / sélection incomplète : demander une deuxième carte au joueur artificiel

Personnalité vs Difficulté

Il semble assez naturel d’envisager plusieurs niveaux de difficulté dans un mode “versus”. Le plus simple dans ce cas semble être de simplement jouer sur la probabilité que l’adversaire “oublie” les carte qu’il a déjà vues. Ce paramètre est pertinent pour ajuster la difficulté, mais j’aime que la difficulté évolue sur plusieurs axes. Quand j’avais réalisé un Tetris en couleurs, la difficulté évoluait simultanément sur la vitesse du jeu, la complexité des blocs et le nombre de couleurs disponibles. J’ai essayé de retrouver ce style de mécanisme. J’en suis arrivé à parler de “personnalités” plutôt que simple niveaux de difficultés. J’ai donc déterminé plusieurs paramètres à faire varier:

  • l’ordre dans lequel sont retournées les cartes : différents joueurs, différentes approches
  • la tactique générale : YaMeMo permet de réaliser de gros scores en enchaînant les paires, certains joueurs vont tenter de faires des paires dès que possible, d’autres de faire des “combos”
  • la probabilité d’oublier : un seuil qui permet de régler le niveau de mémoire du joueur
  • la probabilité de faire des combos : un ensemble de seuils (croissants) qui permet de régler le nombre de paires consécutives que fera un joueur
  • le fait de retourner ou non les cartes retournées par l’adversaire

Une “Factory” permet au moteur de récupérer une instance d’ArticifialPlayer correctement configurée au commencement de la partie. Avec tous ces paramètres, une seule implémentation d’ArtificialPlayer est nécessaire. Pour l’ordre de parcours des cartes, différents itérateurs ont été créés:

Les différentes configurations des joueurs sont donc centralisées, un seul code permet de gérer les différents cas. Le moteur de jeu lui même n’a pas à savoir quel est le joueur artificiel, il lui demande juste de choisir une puis deux cartes à son tour.

Axes d’amélioration

Implémentation “naturelle”

Dans le modèle implémenté, le moteur passe tout le jeu au joueur artificiel. Le nombre de fois qu’une carte a été vue est stockée dans ce jeu. Le jouer détermine avec une simple probabilité s’il oublie ou non une carte déjà vue. Une implémentation plus naturelle serait de ne pas passer l’ensemble des cartes au joueur artificiel, mais de lui laisser gérer un tableau des cartes déjà vues. Ce tableau pourrait être “flouté” à chaque tour. Ainsi, comme c’est le cas souvent avec un joueur humain, si une carte déjà vue est oubliée, on va choisir celle d’à côté, parce qu’on se souvient qu’elle était “par là”. On ne va pas choisir n’importe quelle carte au hasard.

Stratégie

Si le joueur tente de faire des combos, il attend de connaître un certain pourcentage des cartes pour commencer à faire des paires. Ensuite il retombe sur un mode plus classique. Cet algorithme pourrait être amélioré en attendant de connaître N paires, de les faire, puis de recommencer. J’implémenterai peut être cette approche dans une prochaine version.

Configuration

Les configurations de joueurs pourraient être stockés dans un fichier de configuration plutôt que dans la “factory”, voire mis à jour par internet.

Expérience du joueur

En l’état, la meilleure tactique pour le joueur humain semble toujours être de faires les paires dès que possible. J’espère trouver un moyen pour qu’une tactique orientée “combo” soit récompensée.

Conclusion

Je me suis bien amusé à implémenter le mode versus et différents styles d’adversaires. J’ai joué avec les patterns Strategy et Factory, avec les itérateurs java. J’espère que le choix de joueurs artificiels proposé rend bien l’impression souhaitée. N’hésitez pas à commenter, j’attends vos retours sur ce post et sur ce que ça donne dans le jeu.

 
 Share on Facebook Share on Twitter Share on Reddit Share on LinkedIn
No Comments  comments 

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*

Vous pouvez utiliser ces balises et attributs HTML : <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

WordPress.org - Theme based on iFeature