Update ARE-DYNAMIC.py

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