# -*- 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_meme_strat(strat):
    pass

def matrice_init_nie_sauf_un(strat):
    pass

def matrice_init_avoue_sauf_un(strat):
    pass

def matrice_init_equitable():
    pass

def matrice_init_pourcents_choisis(list_pourcent):
    pass

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

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