Ces codes permettent d'implémenter le jeu du Snake and Ladders, de déterminer différentes stratégies possible ainsi que d'analyser les résultats de celles-ci.
### tmc.py
### 1. tmc.py
Le fichier **tmc.py** définit une **class TransitionMatrixCalculator** qui calcule les matrices de transitions en fonctions des trois scénarios possible. Les règles de ce jeux diffèrent de celles traditionnellement utilisées, en effet à chaque étape le joueur à le choix entre trois dés : safe, normal ou risky. Ils ont une influence sur la suite du jeu, effectivement le choix du dé occassione ou non la présence de pièges sur le plateau de jeu.
### markovDecison.py
### 2. markovDecison.py
Le fichier **markovDecison.py** contient une **class MarkovDecisionProcess** qui définit les algorithmes de Value Iteration relatifs aux différentes stratégies. La fonction **solve** permet de calculer la politique optimale par l'algorithme de Value Iteration. Ceci est réalisé en faisant appel aux 3 fonctions **_compute_vi_safe**,**_compute_vi_normal**,**_compute_vi_risky** qui permettent de calculer pour chacun des dés la Value Iteration et de choisir le minimum d'entre toutes les valeurs. Ensuite, la fonction **markovDecision** faisant appel à la fonction **solve**, permet d'afficher la stratégie optimale (les dés devant être joué suivant un layout) et les coût théorique de chaque case en fonction d'un jeu cyclique ou acyclique.
### validation.py
### 3. validation.py
Ce fichier **validation.py** définit une **class validation** dans laquelle nous créons différentes fonctions de simulation du jeu et d'états. Cela va permettre d'obtenir le coût empirique de notre jeu (pour la fonction **simulate_rounds**) et le nombre de tour moyen nécessaire pour atteindre la case finale du jeu (pour la fonction **state_simulation**). Ensuite, nous implémentons des fonctions permettant de comparer les résultats empiriques, des simulations de jeu (dés safe, normal, risky et random), aux résultats théoriques attendus, obtenus par value iteration.
### plot.py
### 4. plot.py
Ce code permet de réaliser différents graphiques afin de comparer les résultats obtenus des stratégies. 4 graphiques peuvent être imprimés via 4 fonctions différentes dépendant d'un layout : **plot_strategy_comparison**,**plot_state_based_turns**,**plot_state_based_comparison**,**plot_state_based_comparison_once**. Le layout utilisé pour comparer nos stratégies est celui-ci : layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]. La fonction **plot_strategy_comparison** permet de comparer les différentes stratégies en fonction de leur average turns sur un histogramme. La fonction **plot_state_based_turns** renvoie un graphe permettant de comparer l'average turn pour chaque état. La fonction **plot_state_based_comparison** a été implémentée dans l'optique de comparer l'algorithme de Value Iteration (theorical cost) et différentes simulations (empirical cost : 100, 10.000 et 1000.000) permettant de montrer la précision obtenue en fonction du nombre de simulations. Enfin, la fonction **plot_state_based_comparison_once** permet de comparer le theorical cost et l'empirical cost basé sur un nombre de simulations définies.
