Projet AWALE

1.1. Contraintes

Langage de programmation : Python.

1.2. Groupes

Groupe 1: MOREAU Martin, RONNE Kylian
Groupe 2: PILON Paul-Alexandre, PRUDHOMME Max
Groupe 3: MEKUIE M'OBIANG Karl Joris, MOREAU Matteo
Groupe 4: MELLOUK Ilyasse, NAHIME Sofia

1.3. Sujet

Le jeu de l'awalé, ou awélé ou encore kalaha, est un jeu de société africain à deux joueurs. On peut trouver les règles de ce jeu sur Wikipédia mais on va les simplifier ici. Le but est de récolter le plus de billes possibles en en prenant à son adversaire.

Initialement, chaque joueur dispose de 6 cases de jeu qui contiennent 4 billes et d'un grenier qui permet de stocker les billes gagnées, comme sur la figure suivante :

Awalé

A chaque tour, un joueur choisit une de ses cases non vides et égraine les billes dans le sens inverse des aiguilles d'une montre en déposant une bille s'il passe par son grenier. Il ne peut pas déposer de bille dans le grenier de son adversaire.

S'il dépose la dernière bille dans l'une de ses cases et que celle-ci ne contient qu'une seule bille, il ramasse les billes de son adversaire dans la case en regard de la sienne mais laisse sa bille dans la case où il termine de jouer.

Si un joueur n'a plus de billes dans ses cases, la partie se termine et le joueur qui possède encore des billes les place dans son grenier.

1.3.1. Prise des billes de l'adversaire

Voici un exemple ou le joueur orange, joue les 3 billes dans la première de ses cases. Il termine en case 4 avec une seule bille, il peut donc prendre les 7 billes en regard de cette case chez son adversaire.

Awalé

1.4. Spécificités

Pour ce jeu, on va opposer un être humain à l'ordinateur et on réalisera un tournoi qui verra chaque équipe s'affronter. On établira un classement en fonction du nombre de victoires.

On vous demande :

de mettre en place des structures de données et fonctions communes à tous les groupes de manière à pouvoir réaliser une compétition entre groupes de projet
de développer une fonction de jeu pour l'ordinateur qui prendra les mêmes paramètres pour tous les groupes de projet et retournera la case à jouer à partir d'une situation de jeu
de tester que la fonction de jeu pour l'ordinateur fonctionne correctement

Il n’est pas nécessaire de développer une interface graphique.

1.5. Implantation

1.5.1. Modules

On va utiliser trois modules / fichiers comme suit :

awale.py qui contiendra les fonctions liées au fonctionnement du jeu
appli_awale.py qui sera le programme principal
ia<N>.py où $N$ est le numéro de votre groupe de projet, qui donne une intelligence artificielle pour jouer

1.5.2. Structures de données

On va utiliser une simple liste qui contient le nombre de billes / graines dans chaque trou. Le premier élément d'indice 0 ne sera pas utilisé :

les éléments d'indice 1 à 6 sont les trous / cases à jouer pour le joueur 1
l'élément d'indice 7 est le grenier du joueur 1
les éléments d'indice 8 à 13 sont les trous / cases à jouer pour le joueur 2
l'élément d'indice 14 est le grenier du joueur 2

1.5.3. Fonctions à implanter

Pour awale.py :

import numpy as np
 
# premier joueur
JOUEUR_1 = 1
# second joueur
JOUEUR_2 = 2
# nombre de trous / cases
MAX_TROUS = 14
 
#
# Initialisation du jeu sous forme de tableau numpy
# dont le premier indice ne sert à rien
# On peut également utiliser une simple liste
#
def jeu_initialiser():
    return np.array( [ 0, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 0 ] )
 
#
# Retourne l'adversaire du joueur passé en paramètre
# - joueur (int)
def adversaire( joueur ):
# à compléter
 
#
# Retourne le trou suivant accessible en fonction du trou
# d'où on commence et du joueur. On rappelle qu'un joueur
# ne peut pas jouer dans le grenier de son adversaire
# - trou (int) variant entre 1 et 14
# - joueur (int) soit JOUEUR_1, soit JOUEUR_2
def trou_suivant( trou,  joueur ):
# à compléter
 
#
# Afficher le plateau de jeu
# - jeu (liste ou numpy array)
def jeu_afficher( jeu ):
# à compléter
 
#
# Indique si le jeu est terminé (True), c'est à dire si l'un des
# joueurs ne peut pas jouer
# - jeu (liste ou numpy array)
#
def jeu_est_termine( jeu ):
# à compléter
 
#
# Si on termine le jeu on ramasse les billes restantes
# et on les place dans le grenier du joueur concerné
# - jeu (liste ou numpy array)
# 
def jeu_ramasser_billes( jeu ):
 
# à compléter
 
#
# Indique si un joueur peut jouer, c'est à dire qu'il possède
# des billes dans au moins une de ses cases
# - jeu (liste ou numpy array)
# - joueur (int) soit JOUEUR_1, soit JOUEUR_2
#
def joueur_peut_jouer( jeu, joueur ):
# à compléter
 
 
#
# Indique si le joueur peut jouer la case/trou indiqué
# - jeu (liste ou numpy array)
# - joueur (int) soit JOUEUR_1, soit JOUEUR_2
# - trou (int) valeur entre 1 et 6
def joueur_peut_jouer_trou( jeu, joueur, trou ):
# à compléter
   
   
#
# Joue pour le joueur donné, le coup donné
# - jeu (liste ou numpy array)
# - joueur (int) soit JOUEUR_1, soit JOUEUR_2
# - trou (int) valeur entre 1 et 6
#
def joue( jeu, joueur, trou ):
# à compléter
   
 
#
# Retourne le nombre de billes dans le grenier du joueur donné
# - jeu (liste ou numpy array)
# - joueur (int) soit JOUEUR_1, soit JOUEUR_2
#
def jeu_grenier( jeu, joueur ):
# à compléter
 

Pour appli_awale.py :

import numpy as np
import awale as aw
 
 
le_joueur_courant = aw.JOUEUR_1
le_jeu = aw.jeu_initialiser()
 
def demande( jeu, joueur ):
    n = 0
    while True:
        print( "quel trou jouer joueur ", joueur, " ? ", end='')
        n = int(input())
        if aw.joueur_peut_jouer_trou( jeu, joueur, n):
            break
    return n
 
tour = 1
 
 
#
# Boucle principale
#
while not aw.jeu_est_termine( le_jeu ):
 
    aw.jeu_afficher( le_jeu )
 
    if aw.joueur_peut_jouer( le_jeu, le_joueur_courant ):
 
        if le_joueur_courant == aw.JOUEUR_1:
            trou = demande( le_jeu, le_joueur_courant )
            print("joue")
            aw.joue( le_jeu, le_joueur_courant, trou )
 
        if le_joueur_courant == aw.JOUEUR_2:
            trou = demande( le_jeu, le_joueur_courant )
            print("joue")
            aw.joue( le_jeu, le_joueur_courant, trou )
            
 
    else:
        print("Le joueur ", le_joueur_courant," ne peut pas jouer")
 
    le_joueur_courant = aw.adversaire( le_joueur_courant )
    
    print( le_jeu )
 
#
# Fin de partie, au moins un des joueurs ne peut pas jouer
#
aw.jeu_ramasser_billes( le_jeu )
aw.jeu_afficher( le_jeu )
grenier_1 = jeu_grenier( le_jeu, aw.JOUEUR_1 )
grenier_2 = jeu_grenier( le_jeu, aw.JOUEUR_2 )
if grenier_1 > grenier_2:
    print("Joueur 1 a gagné !")
elif grenier_2 > grenier_1:
    print("Joueur 2 a gagné !")
else:
    print("Match nul")
 

Pour ia0.py :

import awale as aw
 
#
# Trouve le meilleur coup à jouer en fonction du
# jeu et du joueur
# Retourne une valeur entre 1 et 6 quelque soit le joueur
#
def ia( jeu, joueur ):
# à compléter
 

1.6. Tests

Vérifier que les sous-programmes que vous avez écrits sont capable de donner le résultat final à partir de le jeu suivant. Pour rappel le premier élément est 0.

0  0  0  3  3  0  1  14  0  0  0  0  2  10  15

C'est le joueur 1 qui commence. On a donc :

Séquence de jeu
Tour	Joueur	Trou à jouer
36	1	4
37	2	5
38	1	3
39	2	6
40	1	2
41	2	1
42	1	3
43	2	2
44	1	4
45	2	3
46	1	1
47	2	4
48	1	2
49	2	5
50	1	3
51	2	6


Situation initiale
          Joueur 2             
    10  2  0  0  0  0 
15                    14
     0  0  3  3  0  1 
          Joueur 1             
Joueur  1 joue trou 4
tour= 36


-------------------------------
         Joueur 2             
    10  2  0  0  0  0 
15                    15
     0  0  3  0  1  2 
          Joueur 1             
Joueur  2 joue trou 5
tour= 37
-------------------------------
          Joueur 2             
    11  0  0  0  0  0 
16                    15
     0  0  3  0  1  2 
          Joueur 1             
Joueur  1 joue trou 3
tour= 38
-------------------------------
          Joueur 2             
    11  0  0  0  0  0 
16                    15
     0  0  0  1  2  3 
          Joueur 1             
Joueur  2 joue trou 6
tour= 39
-------------------------------
          Joueur 2             
     0  0  1  1  1  1 
18                    15
     1  1  0  2  3  4 
          Joueur 1             
Joueur  1 joue trou 2
tour= 40
-------------------------------
          Joueur 2             
     0  0  0  1  1  1 
18                    16
     1  0  1  2  3  4 
          Joueur 1             
Joueur  2 joue trou 1
tour= 41
-------------------------------
          Joueur 2             
     0  0  0  1  2  0 
18                    16
     1  0  1  2  3  4 
          Joueur 1             
Joueur  1 joue trou 3
tour= 42
-------------------------------
          Joueur 2             
     0  0  0  1  2  0 
18                    16
     1  0  0  3  3  4 
          Joueur 1             
Joueur  2 joue trou 2
tour= 43
-------------------------------
          Joueur 2             
     0  0  1  2  0  0 
18                    16
     1  0  0  3  3  4 
          Joueur 1             
Joueur  1 joue trou 4
tour= 44
-------------------------------
          Joueur 2             
     0  0  1  2  0  0 
18                    17
     1  0  0  0  4  5 
          Joueur 1             
Joueur  2 joue trou 3
tour= 45
-------------------------------
          Joueur 2             
     0  1  2  0  0  0 
18                    17
     1  0  0  0  4  5 
          Joueur 1             
Joueur  1 joue trou 1
tour= 46
-------------------------------
          Joueur 2             
     0  0  2  0  0  0 
18                    18
     0  1  0  0  4  5 
          Joueur 1             
Joueur  2 joue trou 4
tour= 47
-------------------------------
          Joueur 2             
     1  1  0  0  0  0 
18                    18
     0  1  0  0  4  5 
          Joueur 1             
Joueur  1 joue trou 2
tour= 48
-------------------------------
          Joueur 2             
     1  1  0  0  0  0 
18                    18
     0  0  1  0  4  5 
          Joueur 1             
Joueur  2 joue trou 5
tour= 49
-------------------------------
          Joueur 2             
     2  0  0  0  0  0 
18                    18
     0  0  1  0  4  5 
          Joueur 1             
Joueur  1 joue trou 3
tour= 50
-------------------------------
          Joueur 2             
     2  0  0  0  0  0 
18                    18
     0  0  0  1  4  5 
          Joueur 1             
Joueur  2 joue trou 6

Situation finale
-------------------------------
          Joueur 2             
     0  0  0  0  0  0 
19                    29
     0  0  0  0  0  0 
          Joueur 1             
Joueur 1 a gagné !

Au final c'est le joueur 1 qui gagne avec 29 billes contre 19.

1.7. Tournoi

1.7.1. Règles

Chaque groupe doit proposer un fichier Python qui comporte une fonction qui retourne le prochain coup à jouer.

Chaque groupe affronte un adversaire 10 fois et on comptabilise le nombre de victoires, défaites ou matchs nuls.

Si le code fourni par un groupe :

gènère une erreur qui fait se terminer le programme
ne donne pas de solution dans un temps raisonnable (2 minutes maximum)
donne un coup non jouable

alors la partie est considérée perdue par ce groupe.

1.7.2. Résultats

Résultats du tournoi
Groupe	Victoires	Défaites	Matchs nuls
1	-	-	-
2	-	-	-
3	-	-	-
4	-	-	-
5	-	-	-

Page de Jean-Michel Richer