Le but du projet est d'améliorer nos compétences en C et en SDL afin de parvenir à créer nos propres jeux et animations.
Le projet se décompose en deux phases; la première phase consiste à réaliser plusieurs exercices personnels afin de faciliter la création d'un jeu de groupe.
Nous nous sommes réparti les taches, nous avons utilisé le système de versioning de git à travers les branches. Nous avons créé une branche pour chaque fonctionnalité du projet.
X_fenetre réalisé par Mathis en forme de V
Obtenir le code ici
X_fenetre réalisé par Paul en forme de X
Obtenir le code ici
X_fenetre réalisé par Rime en forme de V
Obtenir le code iciPour le jeu de la vie, nous avons commencé par proposer un menu.
Nous avons 4 options:
-Jeu en monde normal
-Jeu en mode torique
-Sauvegarde d'une configuration
-Chargement d'une configuration
Pour le monde normal, notre jeu est borné; les cellules ne peuvent pas dépasser les bords de la fenêtre.
Pour le monde torique, les cellules peuvent dépasser les bords de la fenêtre pour obtenir une configuration.
Le choix du type de monde se fait en appuyant sur n pour monde normal et t pour monde torique.
Pour sauvegarder une configuration, il faut appuyer sur la touche s. Pour charger une configuration, il faut appuyer sur c.
Dans les deux mondes, quand nous atteignons une configuration fixe, un message signalant une configuration fixe s'affiche à l'écran.
Afin de détecter une configuration fixe, nous faisons une comparaison entre notre grille actuelle et la grille de l'état suivant.
Pour le premier chef d'oeuvre, nous avons décidé de créer un jeu d'arcarde en 2D. Ce jeu implémente différentes contraines telles que les chaines de markov. Nous avons décidé que la matrice des transitions agirait sur le déplacement de personnages. Notre jeu consiste à ramasser le plus de diamant possible en évitant de se faire tuer. Dès que le personnage ramasse un diamant, un ennemi en plus arrive sur la map. Plus il y a d'ennemis, plus le jeu devient difficile jusqu'à mourir si un ennemi nous touche.
Notre matrice prend la forme
markov[4][10] = { {0,0,0,0,0,0,0,1,2,3},
{0,0,0,1,1,1,2,2,2,3},
{0,1,2,2,2,2,2,2,2,3},
{0,0,1,1,2,2,3,3,3,3} };
Ici une ligne correspond à une direction. Le 0 est pour up, le 1 pour right, le 2 pour down et le 3 pour left.
Dans le cas où notre ennemi est entrain d'aller vers le haut : on voit qu'il a 7/10
chance de continuer à aller vers le haut et 1/10 d'aller en bas, gauche, droite
Durant la première semaine, nous avons réalisé différents
exercices qui nous ont permis de développer nos compétences en C et en SDL.
A l'aide de ces acquis, nous avons dû réaliser un projet qui s'étend sur toute la deuxième semaine.
Ce projet consiste en la création d'un jeu qui utilise l'apprentissage par renforcement.
Nous avons donc créé un jeu dont l'entité apprend à jouer et à atteindre un objectif final par ses propres moyens.
Le principe de notre jeu se rapproche plus ou moins de celui d'un labyrinthe.
Comme nous l'avons expliqué précedemment, nous devons guider notre personnage de la case de
départ vers la case d'arrivée en passant par des téléporteurs.
Les téléporteurs sont liés deux à deux avec une couleur précise.
Quand le personnage arrive sur un téléporteur, nous remarquons comme sur l'image qu'il fait une animation qui le mène vers
le téléporteur correspondant.
Si notre personnage touche un trou, il est remis sur la position de départ.
Nous utilisons l'animation de téléportation. En effet, la mort du personnage le téléporte directement sur la case de départ.
Lorsque le personnage atteint la case finale, il effectue un petit saut en tournant sur lui-même.
Nos perceptions sont en fonction des positions x et y du personnage dans la map. Nous avons 529 états qui dépendent de 4 directions.
L’IA suit l’algorithme de Q-Learning. Ainsi notre QTable est une matrice 529x4.
Notre système de reward est simple: 1 si le personnage a atteint le point d’arrivée, 0 sinon.
Afin de déterminer les paramètres xi et gamma, nous avons réalisé différentes modélisations sur 500 000 générations.
Les meilleurs résultats sont pour xi = 0.8 et gamma = 0.93.
Le choix des actions est suivant l’algorithme E-greedy. Notre epsilon est une suite géométrique de paramètre 0.999.
Pour notre modélisation finale, cet epsilon décroit tous les 150 générations.
Une fois cette modélisation faite, on sauvegarde la QTable résultante et on la charge dans le programme global pour faire bouger notre personnage
avec l’expérience des générations précédentes.
Notre point d'arrivée correspond à l’état 265, les états 264 et 266 correspondent respectivement aux cases à gauche et droite de la case finale.
On remarque bien que les 1 dans les colonnes RIGHT et LEFT de chaque état.
Voici une démonstration du jeu en mode IA:
Ce projet nous a permis d'améliorer nos capacités à travailler en équipe, mais également notre autonomie grâce à une répartition des tâches.
De plus, nous avons chacun appris à utiliser git de manière approfondie.
Ce fut une expérience enrichissante, nous avons donc par conséquent acquis de bonnes bases pour les projets de la deuxième année.
