ARE_Dynamic_2017/ARE-DYNAMIC.py

# -*- 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
from matplotlib import pyplot

######################
### 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

# nombre max d'itérations
MaxIterations = 5

"""
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(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 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

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():
    """
        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):
    """
        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

###############################################################################