Update ARE-DYNAMIC.py

ARE-DYNAMIC.py

@@ -59,7 +59,7 @@ TypeGrilleInitiale = 3
 Iteration = 0
 
 # nombre max d'itérations
-MaxIterations = 100
+MaxIterations = 4
 
 # stratégie par défaut
 StratParDefaut = 0
@@ -73,13 +73,11 @@ ListePourcents = list()
 #Couleurs des Stratégies
 CouleursStrat=['b','r','black','g','purple']
 
-#Vitesse de défilement des affichages dynamiques
-Vitesse = 500
 
 """
 Types:
     Coord = tuple(x, y)
-    Joueur = dict("etat", "historique_etats", "strategie", "annees_de_prison", "historique_strategies")
+    Joueur = dict("x", "y", "etat", "historique_etats", "strategie", "annees_de_prison", "historique_strategies")
     GrilleJoueurs = matrice2d(Joueur)
 """
 
@@ -98,7 +96,10 @@ def gen_matrice_initiale():
 
 def partie1v1(joueur, adversaire):
     """
+        Joueur^2 -> int
+        
         Effectue une partie à deux joueurs
+        Renvoie: paire (prison_joueur, prison_adversaire)
     """
 
     stratj = ListeStrategies[joueur["strategie"]]
@@ -140,8 +141,12 @@ def partie1v1(joueur, adversaire):
     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):
@@ -161,12 +166,13 @@ def partie_globale():
             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)
 
+    # 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
+            #(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):
@@ -178,7 +184,10 @@ def partie_globale():
             
     # Réinitialisation du nb d'années de prison
     for j in range(len(Grille[0])):
-        Grille[i][j]['annees_de_prison'] = 0
+            Grille[i][j]['annees_de_prison'] = 0
+    
+    return Grille
+
 
 
 #####################################
@@ -192,7 +201,9 @@ def matrice_init_vide():
     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
@@ -202,16 +213,19 @@ def matrice_init_meme_strat():
     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] = {'etat' : etat, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
+            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
@@ -224,7 +238,7 @@ def matrice_init_nie_sauf_un():
 
     for i in range(TailleGrilleY):
         for j in range(TailleGrilleX):
-            matrice[i][j] = {'etat' : 1, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
+            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)
@@ -234,7 +248,9 @@ def matrice_init_nie_sauf_un():
     return matrice
 
 def matrice_init_avoue_sauf_un():
-    """        
+    """
+        int -> array
+        
         Index: 2
 
         Créer la matrice des joueurs tel que chaque joueur avoue,
@@ -246,7 +262,7 @@ def matrice_init_avoue_sauf_un():
 
     for i in range(TailleGrilleY):
         for j in range(TailleGrilleX):
-            matrice[i][j] = {'etat' : 0, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
+            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)
@@ -282,7 +298,7 @@ def matrice_init_equitable():
             count_joueurs += 1
             places_vides -= 1
 
-    for i in range(TailleGrilleY):                #on vérifie qu'il ne reste pas d'index vides
+    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))
@@ -292,13 +308,15 @@ def matrice_init_equitable():
     for i in range(TailleGrilleY):
         for j in range(TailleGrilleX):
             etat = random.randint(0, 1)
-            matrice[i][j] = {'etat' : etat, 'strategie' : matrice_strat[i][j], 'annees_de_prison' : 0,\
+            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.
@@ -340,7 +358,7 @@ def matrice_init_pourcents_choisis():
     for i in range(TailleGrilleY):
         for j in range(TailleGrilleX):
             etat = random.randint(0, 1)
-            matrice[i][j] = {'etat' : etat, 'strategie' : matrice_strat[i][j], 'annees_de_prison' : 0,\
+            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
@@ -349,7 +367,9 @@ def matrice_init_pourcents_choisis():
 ### Fonction stratégies
 
 def strat_toujours_nier(joueur, adversaire):
-    """    
+    """
+        Joueur^2 -> int
+    
         Index: 0
         
         Toujours nier (coopération)
@@ -357,31 +377,30 @@ def strat_toujours_nier(joueur, adversaire):
     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_meilleur_gain(joueur, adversaire):
+def strat_altern(joueur, adversaire):
     """
+        Joueur^2 -> int
+    
         Index: 2
-
+        
-        Le joueur adopte l'état de l'adversaire ayant obtenu le meilleur gain (= le moins d'années de prison) 
+        Le joueur alterne entre nier et avouer
     """
-    max_gain = joueur['annees_de_prison']
+
-    nveau_etat = joueur['etat']
+    return 1 - joueur['etat']
-    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 < 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
     
 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)
@@ -389,7 +408,9 @@ def strat_precedent_adversaire(joueur, adversaire):
     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)
@@ -410,6 +431,28 @@ def strat_principal_adversaire(joueur, adversaire):
     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']
+    x = joueur['x']
+    y = joueur['y']
+    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 < 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
+
+
+
 ###############################################################################
 
 ##############
@@ -419,7 +462,6 @@ def init_complete():
     """
         Rajoute à ListeStrategies toutes les fonctions stratégies
         Rajoute à ListeGenGrille toutes les fonctions de génération de grille
-        Initialise la grille et StratsResultats
     """
 
     ListeGenGrille.append(matrice_init_meme_strat)          # 0
@@ -430,7 +472,7 @@ def init_complete():
     
     ListeStrategies.append(strat_toujours_nier)         # 0
     ListeStrategies.append(strat_toujours_avouer)       # 1
-    ListeStrategies.append(strat_meilleur_gain)         # 2
+    ListeStrategies.append(strat_altern)                # 2
     ListeStrategies.append(strat_precedent_adversaire)  # 3
     ListeStrategies.append(strat_principal_adversaire)  # 4
 
@@ -451,7 +493,6 @@ def init_complete():
 def simulation():
     global Iteration
     global HistoriqueGrilles
-
     
     Iteration = 0
 
@@ -470,7 +511,7 @@ def simulation():
                 for y in range(TailleGrilleY):
                     if Grille[x][y]["strategie"] == i:
                         StratsResultats[i][2][Iteration][0] += 1
-
+    
     return Grille
 
 
@@ -479,15 +520,14 @@ def simulation():
 
 
 def matRecup(i, param):
-    """
+    """array*str-> array
-        array * str -> array
+    Récupère la matrice avec seulement le paramètre stratégie pour chaque joueur , à litération i voulue"""
-        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]
@@ -496,7 +536,6 @@ def matRecup(i, param):
 
 
 def afficher_strat_dynamique():
-
     fig=plt.figure()
     fig.suptitle('Animation des stratégies')
 
@@ -506,7 +545,7 @@ def afficher_strat_dynamique():
     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)
+    cb=plt.colorbar(img , cmap=cmap , norm=norm , boundaries = bounds , ticks=bounds)
     labels = np.arange(0, 5, 1)
     cb.set_ticklabels(labels)
     
@@ -514,13 +553,12 @@ def afficher_strat_dynamique():
         img.set_array(matRecup(next_iteration , 'strategie'))
         return [img]
 
-    anim = animation.FuncAnimation(fig, update, frames=range(MaxIterations), interval= Vitesse, repeat = False)
+    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')
 
@@ -530,7 +568,7 @@ def afficher_etat_dynamique():
     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)
+    cb=plt.colorbar(img , cmap=cmap , norm=norm , boundaries = bounds , ticks=bounds)
     labels = np.arange(0, 2, 1)
     cb.set_ticklabels(labels)
     
@@ -538,30 +576,40 @@ def afficher_etat_dynamique():
         img.set_array(matRecup(next_iteration , 'etat'))
         return [img]
 
-    anim = animation.FuncAnimation(fig, update, frames=range(MaxIterations), interval= Vitesse, repeat = False)
+    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
     
-    #iterations
+    #iteration
     iteration=[]
     
-    for i in range(len(ListeStrategies)):
+    for i in range(5):
-        stratUtili.append(StratsResultats[i][0])
+        gain.append(0)
+        stratUtili.append(0)
+
+    for i in range(0,len(ListeStrategies)):
+        stratUtili[i]=StratsResultats[i][0]
         if StratsResultats[i][0]==0:
-            gain.append(0)
+            gain[i]
         else:
-            gain.append(StratsResultats[i][1]/StratsResultats[i][0])
+            gain[i]=StratsResultats[i][1]/StratsResultats[i][0]
         utilisateurs.append([])
         
     for i in range(0,MaxIterations+1):
@@ -602,21 +650,22 @@ def affichage_strats_resultats_totaux():
     plt.legend()   
 
 
+init_complete()
+simulation()
+afficher_etat_dynamique()
+affichage_strats_resultats_totaux()
+
+
 
-# fonction de debug, ne pas utiliser
 """
 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]["etat"]
+            K[x][y] = M[x][y]["strategie"]
     
     return K
+print(_ext(simulation()))
 """
 
-if __name__ == "__main__":
-    init_complete()
-    simulation()
-    afficher_strat_dynamique()
-