Skip to content

Morpion

Énoncé

Dans ce mini projet nous allons programmer un jeu du morpion, appelé tic-tac-toe en anglais. Comme l'illustre l'image ci-dessous, ce jeu se joue à deux joueurs sur un plateau de 9 cases. Chaque joueur se voit affecté soit les croix soit les ronds. On joue à tour de rôle en plaçant un pion dans une case libre et c'est toujours le joueur qui a les croix qui commence. L'objectif du jeu est d'aligner trois de ses poins sur une ligne, une colonne ou une diagonale.

Ce mini projet comporte trois objectifs pédagogiques principaux :

  • aller un peu plus loin dans la découverte des caractères unicode ;
  • s'entraîner à rentrer dans le code de quelqu'un d'autre ;
  • la réalisation d'une intelligence artificielle, plus ou moins intelligente.

morpion

ATTENTION

Bien qu'une implémentation "sérieuse" utiliserait des boucles, comme nous n'avons pas encore (re-)étudié les boucles for et while, on se propose de réaliser de ce projet en s'interdisant leur utilisation. Néanmoins, comme on le voit dans le code, on s'autorise à utiliser des list python qui elles aussi n'ont pas encore étaient (re-)étudiées. Ce choix nous permet d'avoir du code plus simple et donc de nous concentrer sur les objectifs pédagogiques du mini projet.

Le travail à réaliser consiste à :

  • compléter le fichier morpion.py disponible ici et affiché ci-dessous ;
  • à implémenter le module joueur_humain ;
  • à implémenter une première version module joueur_ordi bête comme ses pieds ;
  • à implémenter une seconde version, la plus intelligente possible, du module joueur_ordi capable de battre joueur_ordi_malin.

Nous prendrons le temps de bien lire la documentation de chacune des fonctions du fichier morpion.py pour bien comprendre comment leur utilisation s'articule ainsi que pour comprendre quel doit être le contenu des modules joueur_humain et joueur_ordi.

Pour avoir un rendu sympa, bien que notre jeu reste un jeu purement textuel dans le sens où celui-ci n'ouvre aucune fenêtre et s'exécute donc exclusivement dans le terminal, nous aurons certainement besoin de faire des recherches concernant :

  • les caractères unicode ;
  • leur utilisation en python ;
  • l'affichage de texte en couleur dans un terminal.

Comme mentionné dans le code ci-dessous, le module joueur_ordi_malin est fourni. Une fois le module joueur_humain réalisé, nous pourrons jouer contre cette (très grande) "intelligence artificielle". Le format utilisé est volontairement le format interne de l'interpréteur python, pour que nous puissions développer notre propre joueur automatique sans "tricher", c'est à dire sans voir le code du joueur malin. Le module joueur_ordi_malin, en fonction de notre version de Python est disponible :

Comme pour un module classique, on placera ce fichier à côté du fichier morpion.py pour l'utiliser en prenant soin de supprimer le numéro de version dans le nom du fichier pour que celui-ci soit exactement joueur_ordi_malin.pyc.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#!/usr/bin/env python3

"""Un jeu de morpion"""


# Les différents types de joueurs sont représentés par des modules.
# Les modules joueur_humain et joueur_ordi doivent être réaliser.
# Le module joueur_ordi_malin est fourni.
# Le module joueur_humain demande simplement à l'utilisateur de jouer.
# Le module joueur_ordi joue automatiquement. Sa stratégie n'est pas spécifiée.
import joueur_humain
import joueur_ordi
import joueur_ordi_malin


def recupere_chaine_a_afficher(symbole):
    """Renvoie la chaîne de caractère à afficher pour le symbole donné.

    Pour le symbole "x", le caractère unicode "MULTIPLICATION X", affiché
    en rouge doit être utilisé.
    Pour le symbole "x", le caractère unicode "WHITE CIRCLE", affiché
    en bleu doit être utilisé.

    précondition : symbole est soit "x" soit "o"
    """
    # TODO
    ...

def affiche_plateau(cases):
    """Affiche le plateau représenté par le tuples cases à 9 éléments.

    L'affichage se fait sur la sortie standard uniquement en utilisant
    des appels à la fonction print.

    précondition : chacune des cases contient soit
      - la chaîne de caractères "x" (case occupée par le joueur 1)
      - la chaîne de caractères "o" (case occupée par le joueur 2)
      - la chaîne de caractères "i" avec i entier correspondant au
        numéro de la case (case libre)
    précondition : cases est un tuple de 9 éléments
    """
    # TODO
    ...

def joue_coup(joueur, joueur_num, cases, symbole):
    """Joue un coup.

    Cette fonction effectue les opérations suivantes tout en affichant
    ce qu'il se passe sur la sortie standard :
      - affiche le plateau représenté par cases
      - utilise le module joueur pour savoir quel coup doit être joué
      - met à jour le plateau de jeu avec ce coup
      - affiche le plateau et le numéro du joueur gagnant si c'est gagné
        puis quitte le programme
      - renvoie le nouveau plateau

    précondition : joueur est un module avec une fonction
                   joue_coup(cases, symbole) qui renvoie le
                   numéro d'une case précédemment inoccupée.
    précondition : joueur_num est soit l'entier 1 soit l'entier 2
    précondition : cases est un tuple de 9 éléments
    précondition : symbole est soit "x" soit "o"

    """



def joue_partie():
    """Joue une partie complète de morpion"""

    # Initialisation des deux joueurs en demandant à l'utilisateur
    # Parenthèses nécessaires pour "spliter un string literal"
    message_choix_joueur = ("Veuillez choisir le type du joueur {} en tapant\n"
                            "  0 pour humain\n"
                            "  1 pour un ordinateur\n"
                            "  2 pour un ordinateur très malin\n"
                            "  entrez votre choix : ")

    print(message_choix_joueur.format(1), end="")
    type1 = int(input())
    print(message_choix_joueur.format(2), end="")
    type2 = int(input())
    joueur1 = joueur_humain if type1 == 0 else (joueur_ordi
                                                if type1 == 1
                                                else joueur_ordi_malin)
    joueur2 = joueur_humain if type2 == 0 else (joueur_ordi
                                                if type2 == 1
                                                else joueur_ordi_malin)
    print()

    # Initialisation et affichage du plateau vide
    # Une case vide est représentée par son numéro,
    # utilisé par le joueur humain pour indiquer
    # quelle case il joue.
    cases = ["0", "1", "2",
             "3", "4", "5",
             "6", "7", "8"]

    # Joue 9 coups au maximum
    joue_coup(joueur1, 1, cases, "x")
    joue_coup(joueur2, 2, cases, "o")
    joue_coup(joueur1, 1, cases, "x")
    joue_coup(joueur2, 2, cases, "o")
    joue_coup(joueur1, 1, cases, "x")
    joue_coup(joueur2, 2, cases, "o")
    joue_coup(joueur1, 1, cases, "x")
    joue_coup(joueur2, 2, cases, "o")
    joue_coup(joueur1, 1, cases, "x")

    # Si on arrive là, il y a égalité
    print("Match nul !")

if __name__ == "__main__":
    joue_partie()

Pour terminer, essayons de comprendre ce que représente la jolie image ci-dessous ?

morpion optim o

Difficulté

star star star star star

Exercices associés