Update ARE-DYNAMIC.py

ARE-DYNAMIC.py

@@ -59,7 +59,7 @@ TypeGrilleInitiale = 3
 Iteration = 0
 
 # nombre max d'itérations
-MaxIterations = 4
+MaxIterations = 100
 
 # stratégie par défaut
 StratParDefaut = 0
@@ -96,10 +96,7 @@ 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"]]
@@ -141,12 +138,8 @@ 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):
@@ -166,10 +159,9 @@ 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)
+
     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
@@ -186,9 +178,6 @@ def partie_globale():
     for j in range(len(Grille[0])):
         Grille[i][j]['annees_de_prison'] = 0
 
-    return Grille
-
-
 
 #####################################
 ### Fonction génératrices de matrices
@@ -202,8 +191,6 @@ def matrice_init_vide():
 
 def matrice_init_meme_strat():
     """        
-        int -> array
-        
         Index: 0
         
         Crée la matrice des joueurs où chacun a la même stratégie
@@ -213,7 +200,6 @@ 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)
@@ -224,8 +210,6 @@ def matrice_init_meme_strat():
 
 def matrice_init_nie_sauf_un():
     """        
-        int -> array
-        
         Index: 1
 
         Crée la matrice des joueurs tel que chaque joueurs
@@ -249,8 +233,6 @@ def matrice_init_nie_sauf_un():
 
 def matrice_init_avoue_sauf_un():
     """        
-        int -> array
-        
         Index: 2
 
         Créer la matrice des joueurs tel que chaque joueur avoue,
@@ -298,7 +280,7 @@ def matrice_init_equitable():
             count_joueurs += 1
             places_vides -= 1
 
-    for i in range(TailleGrilleY):                #on vérifie qu'il n'y a pas d'index vides
+    for i in range(TailleGrilleY):                #on vérifie qu'il ne reste 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))
@@ -315,8 +297,6 @@ def matrice_init_equitable():
 
 def matrice_init_pourcents_choisis():
     """        
-        list[float] -> array
-        
         Index: 4
 
         ListePourcents contient des float de 0.0 à 1.0.
@@ -368,8 +348,6 @@ def matrice_init_pourcents_choisis():
 
 def strat_toujours_nier(joueur, adversaire):
     """    
-        Joueur^2 -> int
-    
         Index: 0
         
         Toujours nier (coopération)
@@ -378,8 +356,6 @@ def strat_toujours_nier(joueur, adversaire):
     
 def strat_toujours_avouer(joueur, adversaire):
     """    
-        Joueur^2 -> int
-    
         Index: 1
         
         Toujours avouer (trahir)
@@ -388,8 +364,6 @@ def strat_toujours_avouer(joueur, adversaire):
 
 def strat_altern(joueur, adversaire):
     """    
-        Joueur^2 -> int
-    
         Index: 2
         
         Le joueur alterne entre nier et avouer
@@ -399,8 +373,6 @@ def strat_altern(joueur, adversaire):
     
 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)
@@ -409,8 +381,6 @@ def strat_precedent_adversaire(joueur, adversaire):
         
 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)
@@ -440,6 +410,7 @@ 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
@@ -472,6 +443,7 @@ def simulation():
     global Iteration
     global HistoriqueGrilles
 
+    
     Iteration = 0
 
     while Iteration <= MaxIterations:
@@ -498,14 +470,15 @@ def simulation():
 
 
 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"""
+        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]
@@ -514,6 +487,7 @@ def matRecup(i, param):
 
 
 def afficher_strat_dynamique():
+
     fig=plt.figure()
     fig.suptitle('Animation des stratégies')
 
@@ -537,6 +511,7 @@ def afficher_strat_dynamique():
     
 
 def afficher_etat_dynamique():
+
     fig=plt.figure()
     fig.suptitle('Animation des états')
 
@@ -560,34 +535,24 @@ def afficher_etat_dynamique():
 
 
 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
+    #iterations
     iteration=[]
     
-    for i in range(5):
+    for i in range(len(ListeStrategies)):
-        gain.append(0)
+        stratUtili.append(StratsResultats[i][0])
-        stratUtili.append(0)
-
-    for i in range(0,len(ListeStrategies)):
-        stratUtili[i]=StratsResultats[i][0]
         if StratsResultats[i][0]==0:
-            gain[i]
+            gain.append(0)
         else:
-            gain[i]=StratsResultats[i][1]/StratsResultats[i][0]
+            gain.append(StratsResultats[i][1]/StratsResultats[i][0])
         utilisateurs.append([])
         
     for i in range(0,MaxIterations+1):
@@ -628,23 +593,22 @@ def affichage_strats_resultats_totaux():
     plt.legend()   
 
 
-if __name__ == "__main__":
-    init_complete()
-    simulation()
-    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]["strategie"]
+            K[x][y] = M[x][y]["etat"]
     
     return K
-print(_ext(simulation()))
 """
 
+if __name__ == "__main__":
+    init_complete()
+    simulation()
+    afficher_strat_dynamique()
+