ARE_Dynamic_2017/ARE-DYNAMIC.py

# -*- coding:utf-8 -*-
############################
### ARE-DYNAMIC.py
###
### Auteurs:
###     Julian Barathieu (3670170)
###     Lucie Hoffmann (3671067)
###     Nicolas Boussenina (3670515)
###     Constance Poulain (3671006)
###
### Projet: Théorie des Jeux, Dilemne du Prisonier
### ARE-DYNAMIC 2016-2017 UPMC MIPI
###

######################
### Importations

import copy
import random
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from tkinter import *
from tkinter.ttk import *

######################
### Variables Globales

# taille de la grille
TailleGrilleX = 15
TailleGrilleY = 15

# la grille
Grille = np.ndarray((TailleGrilleX, TailleGrilleY))

# historique des grilles aux itérations précédentes
# utilisé durant l'affichage dynamique
HistoriqueGrilles = list()

# chaque StratsResultats[i] est un triplet [nb_utilisations, total_ans_prisons, utilisation_detail] avec:
#       i = index de la stratégie en question
#       nb_utilisations = nombre total d'utilisations de la stratégie
#       total_ans_prisons = total d'années de prisons subies par les utilisateurs de la stratégie
#       utilisation_detail[i] = une liste de triplets [utilisateurs, utilisations, prisons]
#           utilisateur = nombre d'utilisateurs de la stratégie a la FIN de l'iteration i
#           utilisations = le nombre de fois que la fonction stratégie a été appelée au course de l'itération i
#           prisons = nombre total d'années de prisons pris par les utilisateurs de la stratégie au course de l'itération i
StratsResultats = list()

# liste des stratégies (fonctions Joueur^2 -> {0, 1} décidant si un joueur nie ou non en fonction de son adversaire)
ListeStrategies = list()

# liste des fonctions génératrices de grille
ListeGenGrille = list()

# génératrice de grille à utiliser
TypeGrilleInitiale = 3

# itération actuelle
Iteration = 0

# nombre max d'itérations
MaxIterations = 4

# stratégie par défaut
StratParDefaut = 0

# affichage dynamique
AffichageDynamique = True

# nécessaire pour matrice_init_pourcents_choisis()
ListePourcents = list()

# couleurs des stratégies (pour l'affichage dynamique)
CouleursStrat = ['b','r','black','g']

# Vitesse de défilement des images dans l'affichage dynamique en millisecondes
Vitesse = 1

# Fonction pour le GUI
def saisir_les_pourcentages():
    """
        S'il y a eu clic sur le bouton du
        type 4, affiche 5 entry box pour
        saisir les pourcentages voulus
    """

    Label(fenetre, text="% stratégie0:").grid(row=9, column =0)
    per0 = IntVar()
    Entry(fenetre, textvariable=per0, width=3).grid(row=9, column=1)

    Label(fenetre, text ="% stratégie1:").grid(row=10, column=0)
    per1 = IntVar()
    Entry(fenetre, textvariable=per1, width=3).grid(row=10, column=1)

    Label(fenetre, text ="% stratégie2:").grid(row=11, column=0)
    per2 = IntVar()
    Entry(fenetre, textvariable=per2, width=3).grid(row=11, column=1)

    Label(fenetre, text ="% stratégie3:").grid(row=12, column=0)
    per3 = IntVar()
    Entry(fenetre, textvariable=per3, width=3).grid(row=12, column=1)

    global ListePourcents
    ListePourcents = [per0.get(), per1.get(), per2.get(), per3.get(), per4.get()]

#####################################
# Types:
#    Coord = tuple(x, y)
#    Joueur = dict("x", "y", "etat", "historique_etats", "strategie", "annees_de_prison", "historique_strategies")
#    GrilleJoueurs = matrice2d(Joueur)

#####################################
### Génération de la matrice initiale

def gen_matrice_initiale():
    return (ListeGenGrille[TypeGrilleInitiale])()

##############################
### Execution des tours / jeux

def partie1v1(joueur, adversaire):
    """
        Joueur^2 -> int^2

        Effectue une partie à deux joueurs
        Renvoie: paire (prison_joueur, prison_adversaire)
    """

    stratj = ListeStrategies[joueur["strategie"]]
    strata = ListeStrategies[adversaire["strategie"]]

    etatj = stratj(joueur, adversaire)
    etata = strata(adversaire, joueur)

    # 1 = avouer
    # 0 = nier
    if etatj == 0:
        if etata == 0:
            # nie-nie
            ans_prison = (2, 2)
        else:
            # nie-avoue
            ans_prison = (10, 0)
    else:
        if etata == 0:
            # avoue-nie
            ans_prison = (0, 10)
        else:
            # avoue-avoue
            ans_prison = (5, 5)

    StratsResultats[joueur["strategie"]][0] += 1
    StratsResultats[joueur["strategie"]][1] += ans_prison[0]
    StratsResultats[adversaire["strategie"]][0] += 1
    StratsResultats[adversaire["strategie"]][1] += ans_prison[1]

    StratsResultats[joueur["strategie"]][2][Iteration][1] += 1
    StratsResultats[joueur["strategie"]][2][Iteration][2] += ans_prison[0]
    StratsResultats[adversaire["strategie"]][2][Iteration][1] += 1
    StratsResultats[adversaire["strategie"]][2][Iteration][2] += ans_prison[0]

    joueur["historique_etats"].append(etatj)
    adversaire["historique_etats"].append(etata)

    joueur["historique_strategies"].append(stratj)
    adversaire["historique_strategies"].append(strata)

    joueur["etat"] = etatj
    adversaire["etat"] = etata

    joueur["annees_de_prison"] += ans_prison[0]
    adversaire["annees_de_prison"] += ans_prison[1]

    return ans_prison

def partie8tours(x,y):
    """
        Coord -> NoneType

        Effectue huit parties 1v1 entre le joueur et chacun de ses voisins l'un après l'autre
    """
    for i in range (-1,2):
        for j in range (-1,2):  #(i,j) sont les coordonnées de l'adversaire
            if (0 <= x+i and x+i < TailleGrilleX) and (0 <= y+j and y+j < TailleGrilleY) and i != 0 and j != 0:
                partie1v1(Grille[x][y], Grille[x+i][y+j])

def partie_globale():
    """
        Effectue une partie de huit par joueur
    """

    global Grille

    for i in range(TailleGrilleX):
        for j in range(TailleGrilleY):
            partie8tours(i,j)

    # Changement des stratégies

    # On parcourt une copie de la grille pour avoir accès aux anciennes stratégies et non pas aux nouvelles adoptées

    copie_grille = np.copy(Grille)
    for x in range(len(copie_grille)):
        for y in range(len(copie_grille[0])):
            #(x,y) : joueur dont on va modifier la stratégie, si besoin
            min_prison = copie_grille[x][y]["annees_de_prison"]
            new_strat = copie_grille[x][y]["strategie"]
            for i in range (-1,2):
                for j in range (-1,2):  #(x+i,y+j) : adversaires autour de (x,y)
                    if (0 <= x+i and x+i < TailleGrilleX) and (0 <= y+j and y+j < TailleGrilleY) and i != 0 and j != 0:
                        if min_prison > copie_grille[x+i][y+j]["annees_de_prison"]:
                            new_strat = copie_grille[x+i][y+j]["strategie"]
            Grille[x][y]["strategie"] = new_strat   # on modifie la stratégie du joueur dans la Grille et pas dans la copie

    # Réinitialisation du nb d'années de prison
    for i in range(TailleGrilleX):
        for j in range(TailleGrilleY):
            Grille[i][j]['annees_de_prison'] = 0

    return Grille



#####################################
### Fonction génératrices de matrices

def matrice_init_vide():
    """
        Crée une matrice contenant des dicts vides {}
    """

    return [[dict() for x in range(TailleGrilleX)] for y in range(TailleGrilleY)]

def matrice_init_meme_strat():
    """
        Index: 0

        Crée la matrice des joueurs où chacun a la même stratégie
        mais commence avec des états différents, générés aléatoirement
    """

    histo_strat = [StratParDefaut]
    matrice = matrice_init_vide()


    for i in range(TailleGrilleY):
        for j in range(TailleGrilleX):
            etat = random.randint(0, 1)
            matrice[i][j] = {'x' : i, 'y':j, 'etat' : etat, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
            'historique_strategies' : histo_strat, 'historique_etats' : [etat]}

    return matrice

def matrice_init_nie_sauf_un():
    """
        Index: 1

        Crée la matrice des joueurs tel que chaque joueurs
        nie, sauf un qui avoue. Chaque joueur à la même
        stratégie
    """

    histo_strat = [StratParDefaut]
    matrice = matrice_init_vide()

    for i in range(TailleGrilleY):
        for j in range(TailleGrilleX):
            matrice[i][j] = {'x' : i, 'y' : j, 'etat' : 1, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
            'historique_strategies' : histo_strat, 'historique_etats' : [1]}

    index_aleatoirex = random.randint(0,TailleGrilleX-1)
    index_aleatoirey = random.randint(0,TailleGrilleY-1)
    (matrice[index_aleatoirex][index_aleatoirey])['etat'] = 0

    return matrice

def matrice_init_avoue_sauf_un():
    """
        Index: 2

        Créer la matrice des joueurs tel que chaque joueur avoue,
        sauf un qui nie. Tous les joueurs ont la même strategie
    """

    histo_strat = [StratParDefaut]
    matrice = matrice_init_vide()

    for i in range(TailleGrilleY):
        for j in range(TailleGrilleX):
            matrice[i][j] = {'x' : i, 'y' : j, 'etat' : 0, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
            'historique_strategies' : histo_strat, 'historique_etats' : [0]}

    index_aleatoirex = random.randint(0,TailleGrilleX-1)
    index_aleatoirey = random.randint(0,TailleGrilleY-1)
    (matrice[index_aleatoirex][index_aleatoirey])['etat'] = 1

    return matrice

def matrice_init_equitable():
    """
        Index: 3

        Crée la matrice des joueurs tel que le probabilité d'apparition de chaque
        stratégie est équitable. Les états initiaux de chaque
        joueur sont aléatoires.
    """

    matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int)
    nb_de_joueurs_de_chaque = int((TailleGrilleX*TailleGrilleY)/len(ListeStrategies))

    places_vides = TailleGrilleX*TailleGrilleY
    for e in range(len(ListeStrategies)):
        count_joueurs = 0

        while count_joueurs <= nb_de_joueurs_de_chaque:
            index_aleatoirex = random.randint(0,TailleGrilleX-1)
            index_aleatoirey = random.randint(0,TailleGrilleY-1)
            if matrice_strat[index_aleatoirex][index_aleatoirey] != -1:
                if places_vides < 1:
                    break
                continue
            matrice_strat[index_aleatoirex][index_aleatoirey] = e
            count_joueurs += 1
            places_vides -= 1

    for i in range(TailleGrilleY):                #on vérifie qu'il n'y a pas d'index vides
        for j in range(TailleGrilleX):            #si oui, on le rempli avec une strat aléatoire
            if matrice_strat[i][j] == -1:
                matrice_strat[i][j] = random.randint(0, len(ListeStrategies))

    matrice = matrice_init_vide()

    for i in range(TailleGrilleY):
        for j in range(TailleGrilleX):
            etat = random.randint(0, 1)
            matrice[i][j] = {'x' : i, 'y' : j, 'etat' : etat, 'strategie' : matrice_strat[i][j], 'annees_de_prison' : 0,\
            'historique_strategies' : [matrice_strat[i][j]], 'historique_etats' : [etat]}

    return matrice

def matrice_init_pourcents_choisis():
    """
        Index: 4

        ListePourcents contient des float de 0.0 à 1.0.
        Crée la matrice des joueurs tel que le pourcentage de
        chaque stratégie est choisi. Les états initiaux sont
        choisis aléatoirement.
    """
    if (len(ListePourcents) != len(ListeStrategies)):
        print("Erreur: matrice_init_pourcents_choisis: liste_pourcent est de taille incorrecte!")

    matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int)

    list_nb_joueurs_de_chaque = list()
    for i in range(len(ListePourcents)):
        list_nb_joueurs_de_chaque.append((TailleGrilleX*TailleGrilleY)*ListePourcents[i])

    places_vides = TailleGrilleX*TailleGrilleY
    for e in range(len(ListePourcents)):
        count_joueurs = 0

        while count_joueurs <= list_nb_joueurs_de_chaque[e]:
            index_aleatoirex = random.randint(0,TailleGrilleX-1)
            index_aleatoirey = random.randint(0,TailleGrilleY-1)
            if matrice_strat[index_aleatoirex][index_aleatoirey] != -1:
                if places_vides < 1:
                    break
                continue
            matrice_strat[index_aleatoirex][index_aleatoirey] = e
            count_joueurs += 1
            places_vides -= 1

    for i in range(TailleGrilleY):                #on vérifie qu'il n'y a pas d'index vides
        for j in range(TailleGrilleX):            #si oui, on le rempli avec une strat aléatoire
            if matrice_strat[i][j] == 0:
                matrice_strat[i][j] = random.randint(0, len(ListePourcents))

    matrice = matrice_init_vide()

    for i in range(TailleGrilleY):
        for j in range(TailleGrilleX):
            etat = random.randint(0, 1)
            matrice[i][j] = {'x' : i, 'y' : j, 'etat' : etat, 'strategie' : matrice_strat[i][j], 'annees_de_prison' : 0,\
            'historique_strategies' : [matrice_strat[i][j]], 'historique_etats' : [etat]}

    return matrice

#######################
### Fonction stratégies

def strat_toujours_nier(joueur, adversaire):
    """
        Index: 0
        Toujours nier (coopération)
    """
    return 0    # 0 : coop

def strat_toujours_avouer(joueur, adversaire):
    """
        Index: 1
        Toujours avouer (trahir)
    """
    return 1    #1 : traître

def strat_altern(joueur, adversaire):
    """
        Index: 2
        Le joueur alterne entre nier et avouer
    """

    return 1 - joueur['etat']

def strat_precedent_adversaire(joueur, adversaire):
    """
        Index: 3
        Le joueur avoue/nie si durant la partie locale précédente, son adversaire avait avoué/nié (on utilise l'hisorique des états)
    """
    return adversaire['historique_etats'][len(adversaire['historique_etats'])-1] == 0

def strat_principal_adversaire(joueur, adversaire):
    """
       Index: 4
       Le joueur avoue/nie si l’adversaire avait majoritairement avoué/nié durant ses parties précédentes (on utilise l'hisorique des états)
       Si aucun état n’est majoritaire, la coopération l’emporte (le joueur nie)
    """

    s = 0 # somme des entiers représentant les états

    for i in adversaire['historique_etats']:
        s += i

    if len(adversaire['historique_etats']) == 0:
        return 0

    elif (s/len(adversaire['historique_etats'])) > 0.5:
        return 1

    else:
        return 0

def strat_meilleur_gain (joueur, adversaire):
    """
        Index : 5
        Le joueur adopte l'état de l'adversaire ayant obtenu le meilleur gain (= le moins d'années de prison)
    """
    max_gain = joueur['annees_de_prison']
    nveau_etat = joueur['etat']
    for i in range (-1,2):
        for j in range (-1,2): #(i,j) sont les coordonnées de l'adversaire
            x = joueur['x']
            y = joueur['y']
            if (0 <= x+i and x+i < len(Grille)) and (0 <= y+j and y+j < len(Grille[0])) and i != 0 and j != 0:
                if Grille[i][j]['annees_de_prison'] < max_gain :
                    max_gain = Grille[i][j]['annees_de_prison']
                    nveau_etat = Grille[i][j]['etat']
    return nveau_etat

######################
#INTERFACE GRAPHIQUE UTILISATEUR (GUI)
######################


# Initialise la fenetre principale
fenetre = Tk()
# Taille en abscisse de la matrice
X = IntVar(fenetre)

# Taille en ordonnée de la matrice
Y = IntVar(fenetre)

# Strategie definie pour le type 1
Strat = IntVar(fenetre)

# Type de matrice selectionné par l'user
Var_choix = IntVar(fenetre)

# Nombre d'itérations maximum
It = IntVar(fenetre)

# Vitesse de défilement des images dans l'affichage dynamique en millisecondes, pré-variable IntVar
Vit = IntVar()

def affichage_fenetre_infos():
    """
    S'il y a eu clic sur le bouton "Infos", affiche une fenetre contenant
    le détail de chaque stratégie et de chaque type de matrice de départ.
    """
    fenetre_infos = Tk()
    Label(fenetre_infos, text="INFORMATIONS").grid()
    Label(fenetre_infos, text=" ").grid(sticky=W)
    Label(fenetre_infos, text="STRATEGIES :").grid(sticky=W)
    Label(fenetre_infos, text="Stratégie 0 : Toujours nier.").grid(sticky=W)
    Label(fenetre_infos, text="Stratégie 1 : Toujours avouer.").grid(sticky=W)
    #Label(fenetre_infos, text="Stratégie 2 : Alterner entre avouer et nier.").grid(sticky=W)
    Label(fenetre_infos, text="Stratégie 2 : Choisis l'état de son adversaire précédent.").grid(sticky=W)
    Label(fenetre_infos, text="Stratégie 3 : Choisis l'état que son adversaire a majoritairement choisi avant.").grid(sticky=W)
    #Label(fenetre_infos, text="Stratégie 5 : Choisis l'état de son voisin ayant obtenu le meilleur gain.").grid(sticky=W)

    Label(fenetre_infos, text=" ").grid(sticky=W)

    Label(fenetre_infos, text="GRILLES DE DEPART :").grid(sticky=W)
    Label(fenetre_infos, text="Type 0 : La répartition des stratégies est équitable, les états de départs sont aléatoires.").grid(sticky=W)
    Label(fenetre_infos, text="Type 1 : Tous les joueurs nient sauf un qui avoue, même stratégie pour tous.").grid(sticky=W)
    Label(fenetre_infos, text="Type 2 : Tous les joueurs avouent sauf un qui nie, même stratégie pour tous.").grid(sticky=W)
    Label(fenetre_infos, text="Type 3 : Même stratégie pour tout le monde, les états sont aléatoires.").grid(sticky=W)
    Label(fenetre_infos, text="Type 4 : Les pourcentages de chaque stratégie sont choisis, les états de départ sont aléatoires.").grid(sticky=W)

    fenetre_infos.mainloop()

def affichage_combobox():
    """
        S'il y a eu clic sur le bouton,
        on affiche un combobox pour selectionner
        la stratégie par défaut voulue
    """
    global Strat
    Label(fenetre, text="Stratégie n°").grid(row=5, column=0, sticky=E)
    Combobox(fenetre, textvariable=Strat, values=(0, 1, 2, 3), width=3).grid(row=5, column=1, sticky=W)

def Interface():
    """
        Affiche l'interface graphique utilisateur
        qui permet de saisir les paramètres de la
        simulation
    """

    global X
    global Y
    global Var_choix
    global Vit

    Label(fenetre, text = "Paramétrage des variables").grid(row = 0, columnspan = 2)
    Label(fenetre, text = "Saisir la taille de la matrice souhaitée:").grid(row=1, columnspan = 2)
    Label(fenetre, text = "X =").grid(row = 2, column = 0, sticky=E)
    Entry(fenetre, textvariable = X, width = 3).grid(row = 2, column = 1, sticky = W)

    Label(fenetre, text = "Y =").grid(row=3, sticky = E, column=0)
    Entry(fenetre, textvariable=Y, width=3).grid(row=3, column=1, sticky = W)

    Label(fenetre, text="Choisir le type de la matrice initiale:").grid(row=4, columnspan = 2)


    Radiobutton(fenetre, text="Type 0", variable=Var_choix, value=0).grid(row=5, sticky=W)
    Radiobutton(fenetre, text="Type 1", variable=Var_choix, value=1, command=affichage_combobox).grid(row=6, sticky=W)
    Radiobutton(fenetre, text="Type 2", variable=Var_choix, value=2, command=affichage_combobox).grid(row=7, sticky=W)
    Radiobutton(fenetre, text="Type 3", variable=Var_choix, value=3command=affichage_combobox).grid(row=8, sticky=W)
    Radiobutton(fenetre, text="Type 4", variable=Var_choix, value=4, command=saisir_les_pourcentages).grid(row=9, sticky=W)
    Button(fenetre, text="Infos", command=affichage_fenetre_infos).grid(row=7, column=1, sticky=W)
    Label(fenetre, text="Saisir le nombre d'itérations:").grid(row = 15, columnspan=1)
    Entry(fenetre, textvariable=It, width=3).grid(row = 16)

    Label(fenetre, text="Saisir la vitesse de défilement des images en ms:").grid(row=17)
    Entry(fenetre, textvariable=Vit, width=3).grid(row=18)

    Button(fenetre, text="Continuer", command=fenetre.quit).grid(row=19, column=0)

    fenetre.mainloop()


###############################################################################

##############
### Simulation

def init_complete():
    """
        Rajoute à ListeStrategies toutes les fonctions stratégies
        Rajoute à ListeGenGrille toutes les fonctions de génération de grille
    """
    
    
    ListeGenGrille.append(matrice_init_equitable)           # 0
    ListeGenGrille.append(matrice_init_meme_strat)          # 1
    ListeGenGrille.append(matrice_init_nie_sauf_un)         # 2
    ListeGenGrille.append(matrice_init_avoue_sauf_un)       # 3
    ListeGenGrille.append(matrice_init_pourcents_choisis)   # 4

    ListeStrategies.append(strat_toujours_nier)         # 0
    ListeStrategies.append(strat_toujours_avouer)       # 1
   # ListeStrategies.append(strat_altern)                # 
    ListeStrategies.append(strat_precedent_adversaire)  # 2
    ListeStrategies.append(strat_principal_adversaire)  # 3
   # ListeStrategies.append(strat_meilleur_gain)         # 

    global Grille
    global StratsResultats

    global Vitesse
    Vitesse = Vit.get()

    global TailleGrilleX
    global TailleGrilleY
    TailleGrilleX=X.get()
    TailleGrilleY=Y.get()

    global TypeGrilleInitiale
    TypeGrilleInitiale=Var_choix.get()

    global StratParDefaut
    StratParDefaut=Strat.get()

    global MaxIterations
    MaxIterations=It.get()

    Grille = gen_matrice_initiale()

    for i in range(len(ListeStrategies)):
        StratsResultats.append([0, 0, [ [0, 0, 0] ]])
        for x in range(TailleGrilleX):
            for y in range(TailleGrilleY):
                if Grille[x][y]["strategie"] == i:
                    StratsResultats[i][2][0][0] += 1
    return Grille


def simulation():
    global Iteration
    global HistoriqueGrilles

    Iteration = 0

    while Iteration <= MaxIterations:
        HistoriqueGrilles.append(copy.deepcopy(Grille))

        Iteration += 1

        for i in range(len(StratsResultats)):
            StratsResultats[i][2].append([0, 0, 0])

        partie_globale()

        for i in range(len(StratsResultats)):
            for x in range(TailleGrilleX):
                for y in range(TailleGrilleY):
                    if Grille[x][y]["strategie"] == i:
                        StratsResultats[i][2][Iteration][0] += 1

    return Grille


###############################################################################
### Affichage dynamique et graphiques


def matRecup(i, param):
    """
        array*str-> array
        Récupère la grille avec seulement la valeur de la clef "stratégie" pour chaque joueur , à litération i voulue
    """

    # on initialise la matrice résultat avec que des 0
    matR = np.random.randint(0,1,(TailleGrilleX,TailleGrilleY))


    # on récupère la grille à l'itération i voulue
    matrice = HistoriqueGrilles[i]

    # on parcourt toute la grille
    for ligne in range (0,TailleGrilleX):  #int ligne
        for colonne in range (0, TailleGrilleY): #int colonne
            # on place à l'indice (ligne,colonne) de matR la valeur de la clef "stratégie" de la grille pour l'individu (ligne,colonne)
            matR[ligne][colonne] = matrice[ligne][colonne][param]

    return matR


def afficher_strat_dynamique():
    """
        Affichage dynamique de l'évolution de la stratégie dans une fenêtre, avec des couleurs
    """

    fig = plt.figure()
    fig.suptitle('Animation des stratégies')

    cmap = mpl.colors.ListedColormap(["b","r" ,"black" ,"g"])

    bounds = [0,1,2,3,4]
    norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
    img = plt.imshow(matRecup(0, 'strategie'), interpolation = "nearest", cmap = cmap , norm = norm)

    cb = plt.colorbar(img , cmap=cmap , norm=norm , boundaries = bounds , ticks=bounds)
    labels = np.arange(0, 4, 1)
    cb.set_ticklabels(labels)

    def update(next_iteration,*args):
        img.set_array(matRecup(next_iteration , 'strategie'))
        return [img]

    anim = animation.FuncAnimation(fig, update, frames=range(MaxIterations), interval=500, repeat = False)

    plt.show(block = True)


def afficher_etat_dynamique():
    """
        Affichage dynamique de l'évolution des états des individus dans une fenêtre, avec des couleurs
    """

    fig = plt.figure()
    fig.suptitle('Animation des états')

    cmap = mpl.colors.ListedColormap(["black","white"])

    bounds = [0,1,2]
    norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
    img = plt.imshow(matRecup(0, 'etat'), interpolation = "nearest", cmap = cmap , norm = norm)

    cb = plt.colorbar(img , cmap=cmap , norm=norm , boundaries = bounds , ticks=bounds)
    labels = np.arange(0, 2, 1)
    cb.set_ticklabels(labels)

    def update(next_iteration,*args):
        img.set_array(matRecup(next_iteration , 'etat'))
        return [img]

    anim = animation.FuncAnimation(fig, update, frames=range(MaxIterations), interval=500, repeat = False)

    plt.show(block = True)


def affichage_strats_resultats_totaux():
    """
        Retourne les diagrammes en baton qui mettent en évidence le nombre moyen d'années
        de prison en fonction de la stratégie et le nombre d'utilisation de chaque stratégies
    """

    # initialisation des paramètres
    gain=[]
    stratUtili=[]

    #nb_utilisations
    utilisateurs=list()

    #utilisateurs[strat][iter] = nombre d'utilisateur d'une stratégie à une itération

    iteration=[]

    # on ajoute des 0 dans les listes gain() et stratUtili() autant qu'il y a de stratégies
    for i in range(4):
        gain.append(0)
        stratUtili.append(0)

    for i in range(0,len(ListeStrategies)): # on parcourt les stratégies
        stratUtili[i]=StratsResultats[i][0] # L'indice i de la liste stratUtili vaut le  nombre total d'utilisations de la stratégie i
        if StratsResultats[i][0]==0: # si la stratégie a été utilisée 0 fois
            pass # le gain ne change pas
        else:
            gain[i]=StratsResultats[i][1]/StratsResultats[i][0] #Sinon le gain pour la stratégie i vaut le nombre d'années de prison pour une stratégie divisée par son utilisation (pour avoir une moyenne)
        utilisateurs.append([]) # on initialise une liste vide dans la liste utilisateurs afin de s'en servir juste après

    for i in range(0,MaxIterations+1): # on parcourt toutes les itréations
        for j in range(0,len(ListeStrategies)): # on parcourt toutes les stratégies
            utilisateurs[j].append(StratsResultats[j][2][i][0]) # on ajoute à lindice j de la liste utilisateurs le nombre d'utilisateurs d'une stratégie donnée j à l'itération i

        iteration.append(i) #on ajoute à la liste itération l'indice i

    Strat=('0','1', '2','3')

    x_pos = np.arange(len(Strat))

    plt.subplot(221)
    plt.title("Nombre d'adoptions de chaque stratégie")
    plt.bar(x_pos, stratUtili, align='center' , color=CouleursStrat)

    plt.xlabel("Stratégies")
    plt.ylabel("Nombre individus ayant adopté stratégie")
    plt.xticks(x_pos,Strat)

    plt.subplot(222)
    plt.title("Nombre moyen d'années de prison de chaque stratégie")
    plt.bar(x_pos, gain, align='center', color=CouleursStrat )

    plt.xlabel("Stratégies")
    plt.ylabel("Nombre moyen d'années de prison ")
    plt.xticks(x_pos,Strat)

    plt.subplot(223)
    plt.title("Evolution du nombre d'utilisateurs de chaque stratégie au cours des itérations")
    plt.xlabel('Iterations')
    plt.ylabel("Nombre utilisateurs")

    for i in range(len(ListeStrategies)):
        plt.plot(iteration,utilisateurs[i], CouleursStrat[i] ,linewidth=5 ,label="Stratégie" + str(i))

    plt.show()
    plt.legend()

#######################
# SCRIPT
#######################

if __name__ == '__main__':
    Interface()
    init_complete()
    simulation()
    afficher_etat_dynamique()
    afficher_strat_dynamique()
    affichage_strats_resultats_totaux()