# -*- coding:utf-8 -*- ############################ ### ARE-DYNAMIC.py ### ### Auteurs: ### Julian Barathieu (3670170) ### Lucie Hoffmann (3671067) ### Nicolas Boussenina (3670515) ### Constance Poulain (3671006) ### ### Projet: Théorie des Jeux, Dilemne du Prisonier ### ARE-DYNAMIC 2016-2017 UPMC MIPI ### ###################### ### Importations import random import numpy as np import matplotlib as mpl import matplotlib.pyplot as plt import copy ###################### ### Variables Globales # 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() # chaque StratsResultats[i] est un triplet [nb_utilisations, total_ans_prisons, utilisation_detail] avec: # i = index de la stratégie en question # nb_utilisations = nombre total d'utilisations de la stratégie # total_ans_prisons = total d'années de prisons subies par les utilisateurs de la stratégie # utilisation_detail[i] = une liste de trilets [utilisateurs, utilisations, prisons] # représentant, à la fin de l'itération i, le nombre d'utilisateurs, le nombre d'utilisations # ainsi quel le nombre d'années de prisons qu'ils ont accumulés # attention, le nombre d'utilisateurs stockés est StratsResultats = list() # liste des stratégies (fonctions Joueur^2 -> {0, 1} décidant si un joueur nie ou non en fonction de son adversaire) ListeStrategies = list() # liste des fonctions génératrices de grille ListeGenGrille = list() # génératrice de grille à utiliser TypeGrilleInitiale = 3 # itération actuelle Iteration = 0 # nombre max d'itérations MaxIterations = 2 # stratégie par défaut StratParDefaut = 0 # affichage dynamique AffichageDynamique = True """ Types: Coord = tuple(x, y) Joueur = dict("etat", "historique_etats", "strategie", "annees_de_prison", "historique_strategies") GrilleJoueurs = matrice2d(Joueur) """ ##################################### ### Génération de la matrice initiale def gen_matrice_initiale(): """ NoneType -> GrilleJoueurs """ fonction_gen = ListeGenGrille[TypeGrilleInitiale] return fonction_gen() ############################## ### Execution des tours / jeux def partie1v1(joueur, adversaire): """ Joueur^2 -> int Effectue une partie à deux joueurs Renvoie: paire (prison_joueur, prison_adversaire) """ stratj = ListeStrategies[joueur["strategie"]] strata = ListeStrategies[adversaire["strategie"]] etatj = stratj(joueur, adversaire) etata = strata(adversaire, joueur) # 1 = avouer # 0 = nier if etatj == 0: if etata == 0: # nie-nie ans_prison = (2, 2) else: # nie-avoue ans_prison = (10, 0) else: if etata == 0: # avoue-nie ans_prison = (0, 10) else: # avoue-avoue ans_prison = (5, 5) (StratsResultats[joueur["strategie"]])[0] += 1 (StratsResultats[joueur["strategie"]])[1] += ans_prison[0] (StratsResultats[adversaire["strategie"]])[0] += 1 (StratsResultats[adversaire["strategie"]])[1] += ans_prison[1] (StratsResultats[joueur["strategie"]])[2][Iteration][1] += 1 (StratsResultats[joueur["strategie"]])[2][Iteration][2] += ans_prisons[0] (StratsResultats[adversaire["strategie"]])[2][Iteration][1] += 1 (StratsResultats[adversaire["strategie"]])[2][Iteration][2] += ans_prisons[0] 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): 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(): """ Effectue une partie de huit par joueur """ global 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 = 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 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): #(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])): Grille[i][j]['annees_de_prison'] = 0 return Grille ##################################### ### Fonction génératrices de matrices def matrice_init_vide(): """ 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(): """ 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 = [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,\ 'historique_strategies' : histo_strat, 'historique_etats' : [etat]} return matrice def matrice_init_nie_sauf_un(): """ 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 = [StratParDefaut] matrice = matrice_init_vide() for i in range(TailleGrilleY): for j in range(TailleGrilleX): 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) index_aleatoirey = random.randint(0,TailleGrilleY-1) (matrice[index_aleatoirex][index_aleatoirey])['etat'] = 0 return matrice def matrice_init_avoue_sauf_un(): """ 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 """ histo_strat = [StratParDefaut] matrice = matrice_init_vide() for i in range(TailleGrilleY): for j in range(TailleGrilleX): 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) index_aleatoirey = random.randint(0,TailleGrilleY-1) (matrice[index_aleatoirex][index_aleatoirey])['etat'] = 1 return matrice def matrice_init_equitable(): """ 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) nb_de_joueurs_de_chaque = int((TailleGrilleX*TailleGrilleY)/len(ListeStrategies)) 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 if matrice_strat[i][j] == -1: matrice_strat[i][j] = random.randint(0, len(ListeStrategies)) 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' : matrice_strat[i][j], 'annees_de_prison' : 0,\ 'historique_strategies' : [matrice_strat[i][j]], 'historique_etats' : [etat]} return matrice list_pourcent = [] def matrice_init_pourcents_choisis(): """ 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. """ 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) list_nb_joueurs_de_chaque = list() for i in range(len(list_pourcent)): list_nb_joueurs_de_chaque.append((TailleGrilleX*TailleGrilleY)*list_pourcent[i]) places_vides = TailleGrilleX*TailleGrilleY for e in range(len(list_pourcent)): count_joueurs = 0 while count_joueurs <= list_nb_joueurs_de_chaque[e]: 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 if matrice_strat[i][j] == 0: matrice_strat[i][j] = random.randint(0, len(list_pourcent)) 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' : matrice_strat[i][j], 'annees_de_prison' : 0,\ 'historique_strategies' : [matrice_strat[i][j]], 'historique_etats' : [etat]} return matrice ####################### ### Fonction stratégies def strat_toujours_nier(joueur, adversaire): """ Joueur^2 -> int Index: 0 Toujours nier (coopération) """ 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_altern(joueur, adversaire): """ Joueur^2 -> int Index: 2 Le joueur alterne entre nier et avouer """ return 1 - joueur['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) """ 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_etats']: s += i if len(adversaire['historique_etats']) == 0: return 0 elif (s/len(adversaire['historique_etats'])) > 0.5: return 1 else: return 0 ############################################################################### ############## ### 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(): global Iteration global HistoriqueGrilles Iteration = 0 while Iteration <= MaxIterations: HistoriqueGrilles.append(copy.deepcopy(Grille)) Iteration += 1 for i in range(len(StratsResultats)): StratsResultats[i][2].append([0, 0, 0]) partie_globale() for i in range(len(StratsResultats)): for x in range(TailleGrilleX): for y in range(TailleGrilleY): if Grille[x][y]["strategie"] == i: StratsResultats[i][2][Iteration][0] += 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() simulation()