Add files via upload

ARE_FINISH.py

@@ -0,0 +1,850 @@
+# -*- 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
+
+# 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]
+#           représentant, à la fin de l'itération i, le nombre d'utilisateurs, le nombre d'utilisations
+#           ainsi quel le nombre d'années de prisons qu'ils ont accumulés
+#           attention, le nombre d'utilisateurs stockés est 
+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
+CouleursStrat=['b','r','black','g','purple']
+
+# 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)
+
+    Label(fenetre, text ="% stratégie4:").grid(row=13, column=0)
+    #per4 =IntVar()
+    Entry(fenetre, textvariable=per4, width=3).grid(row=13, column=1)
+
+    
+
+def fermeture_GUI():
+    """
+    """
+
+
+"""
+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():
+    """
+        NoneType -> GrilleJoueurs
+    """
+    fonction_gen = ListeGenGrille[TypeGrilleInitiale]
+    
+    return fonction_gen()
+
+##############################
+### Execution des tours / jeux
+
+def partie1v1(joueur, adversaire):
+    """
+        Joueur^2 -> int
+        
+        Effectue une partie à deux joueurs
+        Renvoie: paire (prison_joueur, prison_adversaire)
+    """
+    #print("joueur " + str(joueur))
+    print("len strategies = " +str(len(ListeStrategies)))
+    print('joueur[strategie]='+str(joueur['strategie']))
+    print('adversaire[strategie]='+str(adversaire['strategie']))
+    stratj = ListeStrategies[joueur['strategie']]
+    
+    strata = ListeStrategies[adversaire['strategie']]
+    
+    
+    etatj = stratj(joueur, adversaire)
+    etata = strata(adversaire, joueur)
+    #print('strat joueur ' + str(joueur['strategie']))
+    
+    # 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])
+    #print(Grille[0][0]['etat'])
+
+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
+            print('nouvelle stratégie='+str(new_strat))
+    # 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():
+    """
+        int -> array
+        
+        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():
+    """
+        int -> array
+        
+        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():
+    """
+        int -> array
+        
+        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():
+    """
+        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.
+        
+        Index: 3
+    """
+
+    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(0,5):
+        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():
+    """
+        list[float] -> array
+        
+        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.
+    """
+    #for i in range(len(ListePourcents)):
+        #print("pourcent i = " + str(ListePourcents[i]))
+
+
+    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(ListeStrategies)):
+        list_nb_joueurs_de_chaque.append((TailleGrilleX*TailleGrilleY)*ListePourcents[i])
+    
+    places_vides = TailleGrilleX*TailleGrilleY
+    for e in range(0,5):
+        count_joueurs = 0
+        #print('Stratégie choisie ='+str(e))
+        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] == -1:
+                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]}
+            #print('joueur en sortie'+str(matrice[i][j]))
+    return matrice
+
+#######################
+### Fonction stratégies
+
+def strat_toujours_nier(joueur, adversaire):
+    """
+        Joueur^2 -> int
+    
+        Index: 0
+        
+        Toujours nier (coopération)
+    """
+    return 0    # 0 : coop
+    
+def strat_toujours_avouer(joueur, adversaire):
+    """
+        Joueur^2 -> int
+    
+        Index: 1
+        
+        Toujours avouer (trahir)
+    """
+    return 1    #1 : traître
+
+def strat_altern(joueur, adversaire):
+    """
+        Joueur^2 -> int
+    
+        Index: 2
+        
+        Le joueur alterne entre nier et avouer
+    """
+
+    return 1 - joueur['etat']
+    
+def strat_precedent_adversaire(joueur, adversaire):
+    """
+        Joueur^2 -> int
+    
+        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]
+        
+def strat_principal_adversaire(joueur, adversaire):
+    """
+       Joueur^2 -> int
+       
+       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
+
+######################
+#INTERFACE GRAPHIQUE UTILISATEUR (GUI)
+######################
+# Fonctions pour command
+######################
+
+
+# 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()
+per0=DoubleVar()
+per1=DoubleVar()
+per2=DoubleVar()
+per3=DoubleVar()
+per4=DoubleVar()
+
+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 3 : Choisis l'état de son adversaire précédent.").grid(sticky=W)
+    Label(fenetre_infos, text="Stratégie 4 : 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 : Même stratégie pour tout le monde, les états 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 : La répartition des stratégies est équitable, les états de départs 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, 4), 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, command=affichage_combobox).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=3).grid(row=8, sticky=W)
+    Radiobutton(fenetre, text="Type 4", variable=Var_choix, value=4, command=saisir_les_pourcentages).grid(row=9, 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)
+
+    Button(fenetre, text="Infos", command=affichage_fenetre_infos).grid(row=7, column=1, sticky=W)
+
+    Label(fenetre, text="Saisir la vitesse de défilement des images:").grid(row=17)
+    Entry(fenetre, textvariable=Vit, width=3).grid(row=18)
+    
+    Button(fenetre, text="Continuer", command=fermeture).grid(row=19, column=0)
+    
+    fenetre.mainloop()
+
+
+def fermeture():
+    """
+    """
+    global ListePourcents
+    
+    ListePourcents=[per0.get(), per1.get(), per2.get(), per3.get(), per4.get()]
+    fenetre.quit()
+
+###############################################################################
+
+##############
+### 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_meme_strat)          # 0
+    ListeGenGrille.append(matrice_init_nie_sauf_un)         # 1
+    ListeGenGrille.append(matrice_init_avoue_sauf_un)       # 2
+    ListeGenGrille.append(matrice_init_equitable)           # 3
+    ListeGenGrille.append(matrice_init_pourcents_choisis)   # 4    
+    
+    ListeStrategies.append(strat_toujours_nier)         # 0
+    ListeStrategies.append(strat_toujours_avouer)       # 1
+    ListeStrategies.append(strat_altern)                # 2
+    ListeStrategies.append(strat_precedent_adversaire)  # 3
+    ListeStrategies.append(strat_principal_adversaire)  # 4
+
+    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 matrice avec seulement le paramètre stratégie pour chaque joueur , à litération i voulue"""
+    matR = np.random.randint(0,1,(TailleGrilleX,TailleGrilleY))
+    
+    
+    matrice = HistoriqueGrilles[i]
+   
+
+    for ligne in range (0,TailleGrilleX):  #int ligne
+        for colonne in range (0, TailleGrilleY): #int colonne
+            matR[ligne][colonne]=matrice[ligne][colonne][param]
+   
+    return matR
+
+
+def afficher_strat_dynamique():
+    fig=plt.figure()
+    fig.suptitle('Animation des stratégies')
+
+    cmap = mpl.colors.ListedColormap(["b","r" ,"black" ,"g" ,"purple"])
+
+    bounds=[0,1,2,3,4,5]
+    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, 5, 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():
+    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=Vitesse, repeat = False)
+
+    plt.show(block = True)
+
+
+def affichage_strats_resultats_totaux():
+    """array->graph
+    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
+    #list gain
+    gain=[]
+    #list strat
+    stratUtili=[]
+    
+    #nb_utilisations
+    utilisateurs=list()
+    
+    #uti[strat][iter] = nb
+    
+    #iteration
+    iteration=[]
+    
+    for i in range(5):
+        gain.append(0)
+        stratUtili.append(0)
+
+    for i in range(0,len(ListeStrategies)):
+        stratUtili[i]=StratsResultats[i][0]
+        if StratsResultats[i][0]==0:
+            gain[i]
+        else:
+            gain[i]=StratsResultats[i][1]/StratsResultats[i][0]
+        utilisateurs.append([])
+        
+    for i in range(0,MaxIterations+1):
+        for j in range(0,len(ListeStrategies)):
+            utilisateurs[j].append(StratsResultats[j][2][i][0])
+           
+        iteration.append(i)
+   
+    Strat=('0','1', '2','3' ,'4')
+    
+    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
+#######################
+
+Interface()
+init_complete()
+simulation()
+afficher_etat_dynamique()
+afficher_strat_dynamique()
+affichage_strats_resultats_totaux()
+
+
+
+"""
+def _ext(M):
+    K = np.ndarray((TailleGrilleX, TailleGrilleY))
+        
+    for x in range(len(M)):
+        for y in range(len(M[0])):
+            K[x][y] = M[x][y]['strategie']
+    
+    return K
+print(_ext(simulation()))
+"""
+