diff --git a/ARE-DYNAMIC.py b/ARE-DYNAMIC.py
index 1247e9f..1ebb905 100644
--- a/ARE-DYNAMIC.py
+++ b/ARE-DYNAMIC.py
@@ -15,7 +15,10 @@
 ######################
 ### Importations
 
-import numpy
+import random
+import numpy as np
+import matplotlib as mpl
+from matplotlib import pyplot
 
 ######################
 ### Variables Globales
@@ -47,6 +50,9 @@ ListeGenGrille = list()
 # génératrice de grille à utiliser
 TypeGrilleInitiale = 0
 
+# nombre max d'itérations
+MaxIterations = 5
+
 """
 Types:
     Coord = tuple(x, y)
@@ -108,17 +114,52 @@ def partie1v1(joueur, adversaire):
     
     return ans_prison
 
-def partie8tours(coord_joueur):
+def partie8tours(x,y):
+    """ 
+        Coord -> NoneType 
+        
+        Effectue huit parties 1v1 entre le joueur et chacun de ses voisins l'un après l'autre    
     """
-        Coord ->
-    """
-    pass
+    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:
+                partie1v1(Grille[x][y], Grille[x+i][y+j])
 
-def partie_globale(mat):
+def partie_globale():
     """
-        GrilleJoueurs -> GrilleJoueurs
+        Effectue une partie de huit par joueur
     """
-    pass
+    
+    global HistoriqueGrilles
+    HistoriqueGrilles += [Grille]
+
+    for i in range(len(Grille)):
+        for j in range(len(Grille[0])):
+            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 = numpy.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 = joueur["annees_de_prison"]
+            new_strat = joueur["strategie"]
+            for i in range (-1,2):
+                for j in range (-1,2):  #(i,j) : adversaires autour de (x,y)
+                    (i,j) = adversaire
+                    if min_prison > adversaire["annees_de_prison"]:
+                        new_strat = adversaire["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]):
+            Grille[i][j]['annees_de_prison'] = 0
+    
+    return Grille
+
 
 ##############
 ### Simulation
@@ -134,16 +175,17 @@ def simulation():
 
 def matrice_init_vide():
     """
-    Crée une matrice contenant des dicts vides {}
+        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(strat):
     """
-    int -> array
-    Crée la matrice des joueurs où chacun a la même stratégie
-    mais commence avec des statuts différents, générés aléatoirement
+        int -> array
+        
+        Crée la matrice des joueurs où chacun a la même stratégie
+        mais commence avec des statuts différents, générés aléatoirement
     """
 
     histo_strat = [strat]
@@ -160,10 +202,11 @@ def matrice_init_meme_strat(strat):
 
 def matrice_init_nie_sauf_un(strat):
     """
-    int -> array
-    Crée la matrice des joueurs tel que chaque joueurs
-    nie, sauf un qui avoue. Chaque joueur à la même
-    stratégie
+        int -> array
+
+        Crée la matrice des joueurs tel que chaque joueurs
+        nie, sauf un qui avoue. Chaque joueur à la même
+        stratégie
     """
     
     histo_strat = [strat]
@@ -182,9 +225,10 @@ def matrice_init_nie_sauf_un(strat):
 
 def matrice_init_avoue_sauf_un(strat):
     """
-    int -> array
-    Créer la matrice des joueurs tel que chaque joueur avoue,
-    sauf un qui nie. Tous les joueurs ont la même strategie
+        int -> array
+
+        Créer la matrice des joueurs tel que chaque joueur avoue,
+        sauf un qui nie. Tous les joueurs ont la même strategie
     """
 
     hito = [strat]
@@ -203,10 +247,9 @@ def matrice_init_avoue_sauf_un(strat):
 
 def matrice_init_equitable():
     """
-    int*int*list[functions] -> array
-    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.
+        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.
     """
 
     matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int)
@@ -241,11 +284,12 @@ def matrice_init_equitable():
 
 def matrice_init_pourcents_choisis(list_pourcent):
     """
-    int*int*list[functions]*list[float] -> array
-    list_pourcent 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.
+        list[float] -> array
+
+        list_pourcent 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.
     """
     assert(len(list_pourcent) == len(ListeStrategies))
     
@@ -379,4 +423,3 @@ def init_liste_strategies():
     ListeStrategies[4] = strat_principal_adversaire
 
 ###############################################################################
-