Update ARE-DYNAMIC.py

ARE-DYNAMIC.py

@@ -19,17 +19,18 @@ import random
 import numpy as np
 import matplotlib as mpl
 from matplotlib import pyplot
+import copy
 
 ######################
 ### Variables Globales
 
-# Grille
-Grille = numpy.ndarray()
-
 # 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()
@@ -48,10 +49,17 @@ ListeStrategies = list()
 ListeGenGrille = list()
 
 # génératrice de grille à utiliser
-TypeGrilleInitiale = 0
+TypeGrilleInitiale = 3
 
 # nombre max d'itérations
-MaxIterations = 5
+MaxIterations = 2
+
+# stratégie par défaut
+StratParDefaut = 0
+
+# affichage dynamique
+AffichageDynamique = True
+
 
 """
 Types:
@@ -130,8 +138,7 @@ def partie_globale():
         Effectue une partie de huit par joueur
     """
 
-    global HistoriqueGrilles
+    global Grille
-    HistoriqueGrilles += [Grille]
 
     for i in range(len(Grille)):
         for j in range(len(Grille[0])):
@@ -140,35 +147,38 @@ def partie_globale():
     # 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 = numpy.copy(Grille)
+
+    copie_grille = np.copy(Grille)
     for x in range(len(copie_grille)): 
-        for y in range(len(copie_grille)[0]):
+        for y in range(len(copie_grille[0])):
             #(x,y) : joueur dont on va modifier la stratégie, si besoin
-            min_prison = joueur["annees_de_prison"]
+            min_prison = copie_grille[x][y]["annees_de_prison"]
-            new_strat = joueur["strategie"]
+            new_strat = copie_grille[x][y]["strategie"]
             for i in range (-1,2):
-                for j in range (-1,2):  #(i,j) : adversaires autour de (x,y)
+                for j in range (-1,2):  #(x+i,y+j) : adversaires autour de (x,y)
-                    (i,j) = 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 min_prison > adversaire["annees_de_prison"]:
+                        if min_prison > copie_grille[x+i][y+j]["annees_de_prison"]:
-                        new_strat = adversaire["strategie"]
+                            new_strat = copie_grille[x+i][y+j]["strategie"]
-            global Grille
             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 j in range(len(Grille)[0]):
+    for j in range(len(Grille[0])):
             Grille[i][j]['annees_de_prison'] = 0
     
     return Grille
 
 
-##############
-### Simulation
 
-def simulation():
-    pass
 
-####################################
+
-### Affichage et interface graphique
+
+
+
+
+
+
+
+
 
 #####################################
 ### Fonction génératrices de matrices
@@ -180,7 +190,7 @@ def matrice_init_vide():
 
     return [[dict() for x in range(TailleGrilleX)] for y in range(TailleGrilleY)]
 
-def matrice_init_meme_strat(strat):
+def matrice_init_meme_strat():
     """
         int -> array
         
@@ -188,19 +198,19 @@ def matrice_init_meme_strat(strat):
         mais commence avec des statuts différents, générés aléatoirement
     """
 
-    histo_strat = [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' : strat, 'annees_de_prison' : 0,\
+            matrice[i][j] = {'etat' : etat, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
             'historique_strategies' : histo_strat, 'historique_etats' : [etat]}
 
     return matrice
 
-def matrice_init_nie_sauf_un(strat):
+def matrice_init_nie_sauf_un():
     """
         int -> array
 
@@ -209,12 +219,12 @@ def matrice_init_nie_sauf_un(strat):
         stratégie
     """
     
-    histo_strat = [strat]
+    histo_strat = [StratParDefaut]
     matrice = matrice_init_vide()
 
     for i in range(TailleGrilleY):
         for j in range(TailleGrilleX):
-            matrice[i][j] = {'etat' : 1, 'strategie' : strat, 'annees_de_prison' : 0,\
+            matrice[i][j] = {'etat' : 1, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
             'historique_strategies' : histo_strat, 'historique_etats' : [1]}
 
     index_aleatoirex = random.randint(0,TailleGrilleX-1)
@@ -223,7 +233,7 @@ def matrice_init_nie_sauf_un(strat):
 
     return matrice
 
-def matrice_init_avoue_sauf_un(strat):
+def matrice_init_avoue_sauf_un():
     """
         int -> array
 
@@ -231,12 +241,12 @@ def matrice_init_avoue_sauf_un(strat):
         sauf un qui nie. Tous les joueurs ont la même strategie
     """
 
-    hito = [strat]
+    histo_strat = [StratParDefaut]
     matrice = matrice_init_vide()
 
     for i in range(TailleGrilleY):
         for j in range(TailleGrilleX):
-            matrice[i][j] = {'etat' : 0, 'strategie' : strat, 'annees_de_prison' : 0,\
+            matrice[i][j] = {'etat' : 0, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\
             'historique_strategies' : histo_strat, 'historique_etats' : [0]}
 
     index_aleatoirex = random.randint(0,TailleGrilleX-1)
@@ -254,8 +264,8 @@ def matrice_init_equitable():
 
     matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int)
     nb_de_joueurs_de_chaque = int((TailleGrilleX*TailleGrilleY)/len(ListeStrategies))
-    print(nb_de_joueurs_de_chaque)
     
+    places_vides = TailleGrilleX*TailleGrilleY
     for e in range(len(ListeStrategies)):
         count_joueurs = 0
         
@@ -263,9 +273,12 @@ def matrice_init_equitable():
             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
@@ -282,7 +295,9 @@ def matrice_init_equitable():
 
     return matrice
 
-def matrice_init_pourcents_choisis(list_pourcent):
+list_pourcent = []
+
+def matrice_init_pourcents_choisis():
     """
         list[float] -> array
 
@@ -291,7 +306,8 @@ def matrice_init_pourcents_choisis(list_pourcent):
         chaque stratégie est choisi. Les états initiaux sont
         choisis aléatoirement.
     """
-    assert(len(list_pourcent) == len(ListeStrategies))
+    if (len(list_pourcent) != len(ListeStrategies)):
+        print("Erreur: matrice_init_pourcents_choisis: liste_pourcent est de taille incorrecte!")
     
     matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int)
 
@@ -329,21 +345,9 @@ def matrice_init_pourcents_choisis(list_pourcent):
 
     return matrice
 
-def init_liste_gen_grilles():
-    """
-        NoneType -> NoneType
-        
-        Rajoute à ListeGenGrille toutes les fonctions de génération de grille
-    """
-    ListeGenGrille[0] = matrice_init_meme_strat
-    ListeGenGrille[1] = matrice_init_nie_sauf_un
-    ListeGenGrille[2] = matrice_init_avoue_sauf_un
-    ListeGenGrille[3] = matrice_init_equitable
-    ListeGenGrille[4] = matrice_init_pourcents_choisis
-    
-
 #######################
 ### Fonction stratégies
+
 def strat_toujours_nier(joueur, adversaire):
     """
         Joueur^2 -> int
@@ -386,40 +390,87 @@ 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)
        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_etat']:
+    for i in adversaire['historique_etats']:
         s += i
     
-    if len(adversaire['historique_etat']) == 0:
+    if len(adversaire['historique_etats']) == 0:
         return 0
 
-    elif (s/len(adversaire['historique_etat'])) > 0.5: 
+    elif (s/len(adversaire['historique_etats'])) > 0.5: 
         return 1
 
     else:
         return 0
 
-def init_liste_strategies():
-    """
-        NoneType -> NoneType
-        
-        Rajoute à ListeStrategies toutes les fonctions stratégies
-    """
-    
-    ListeStrategies[0] = strat_toujours_nier
-    ListeStrategies[1] = strat_toujours_avouer
-    ListeStrategies[2] = strat_altern
-    ListeStrategies[3] = strat_precedent_adversaire
-    ListeStrategies[4] = strat_principal_adversaire
-
 ###############################################################################
+
+##############
+### 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
+
+    for i in range(len(ListeStrategies)):
+        StratsResultats.append([0, 0, list()])
+
+    Grille = gen_matrice_initiale()
+
+
+def simulation():
+    iterations = 0
+
+    global HistoriqueGrilles
+    
+    while iterations <= MaxIterations:
+        HistoriqueGrilles.append(copy.deepcopy(Grille))
+        partie_globale()
+        iterations += 1
+    
+    return Grille
+
+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
+
+
+init_complete()
+
+print(simulation())
+
+#for M in HistoriqueGrilles:
+#    print(_ext(M))
+#    input()