From 6d80ffecae1336709db63573eb15434d5dec117d Mon Sep 17 00:00:00 2001 From: julianb0 Date: Wed, 15 Mar 2017 10:25:35 +0100 Subject: [PATCH] Update ARE-DYNAMIC.py --- ARE-DYNAMIC.py | 189 +++++++++++++++++++++++++++++++------------------ 1 file changed, 120 insertions(+), 69 deletions(-) diff --git a/ARE-DYNAMIC.py b/ARE-DYNAMIC.py index 1ebb905..6b95b05 100644 --- a/ARE-DYNAMIC.py +++ b/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: @@ -129,9 +137,8 @@ def partie_globale(): """ Effectue une partie de huit par joueur """ - - global HistoriqueGrilles - HistoriqueGrilles += [Grille] + + global 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"] - new_strat = joueur["strategie"] + 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): #(i,j) : adversaires autour de (x,y) - (i,j) = adversaire - if min_prison > adversaire["annees_de_prison"]: - new_strat = adversaire["strategie"] - global Grille + for j in range (-1,2): #(x+i,y+j) : adversaires autour de (x,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 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 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,18 +264,21 @@ 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 - + 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 @@ -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()