From 8fd0e10a1991c8982155e73ddef2f342dedbe4c0 Mon Sep 17 00:00:00 2001 From: julianb0 Date: Wed, 8 Mar 2017 10:56:31 +0100 Subject: [PATCH] Update ARE-DYNAMIC.py --- ARE-DYNAMIC.py | 331 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 331 insertions(+) diff --git a/ARE-DYNAMIC.py b/ARE-DYNAMIC.py index 094adfc..968d97a 100644 --- a/ARE-DYNAMIC.py +++ b/ARE-DYNAMIC.py @@ -160,6 +160,336 @@ def init_liste_gen_grilles(): ListeGenGrille[4] = matrice_init_pourcents_choisis +####################### +### 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 + """ +# -*- 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 numpy + +###################### +### Variables Globales + +# Grille +Grille = numpy.ndarray() + +# taille de la grille +TailleGrilleX = 15 +TailleGrilleY = 15 + +# 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 = une liste de paires (iter, uti) représentant le nombre d'utilisateurs à l'itération "iter" +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 = 0 + +""" +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] + + joueur["annees_de_prison"] += ans_prison[0] + adversaire["annees_de_prison"] += ans_prison[1] + + return ans_prison + +def partie8tours(coord_joueur): + """ + Coord -> + """ + pass + +def partie_globale(mat): + """ + GrilleJoueurs -> GrilleJoueurs + """ + pass + +############## +### Simulation + +def simulation(): + pass + +#################################### +### Affichage et interface graphique + +##################################### +### 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(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 = [strat] + 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,\ + 'historique_strategies' : histo_strat, 'historique_etats' : [etat]} + + return matrice + +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 + """ + + histo_strat = [strat] + 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,\ + '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(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 + """ + + hito = [strat] + 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,\ + '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(): + """ + 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. + """ + + 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) + + 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: + continue + matrice_strat[index_aleatoirex][index_aleatoirey] = e + count_joueurs += 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 + +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. + """ + assert(len(list_pourcent) == len(ListeStrategies)) + + 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 + +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): @@ -241,3 +571,4 @@ def init_liste_strategies(): ListeStrategies[4] = strat_principal_adversaire ############################################################################### +