383 lines
11 KiB
Python
383 lines
11 KiB
Python
# -*- 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):
|
||
"""
|
||
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_etat']:
|
||
s += i
|
||
|
||
if len(adversaire['historique_etat']) == 0:
|
||
return 0
|
||
|
||
elif (s/len(adversaire['historique_etat'])) > 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
|
||
|
||
###############################################################################
|
||
|