# -*- 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) 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(): """ 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) """ 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(): """ 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(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(): """ 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. """ 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): """ 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] == 0 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 def strat_meilleur_gain (joueur, adversaire): """ Joueur^2 -> int 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) ###################### # 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() 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, 5), 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) 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:").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_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 ListeStrategies.append(strat_meilleur_gain) # 5 global Grille global StratsResultats global Vitesse Vitesse = Vit.get() global TailleGrilleX global TailleGrilleY TailleGrilleX=X.get() TailleGrilleY=Y.get() print(TailleGrilleX) 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", "yellow"]) 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=500, 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(6): 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())) """