Aller au contenu principal
Physique, Chimie et Informatique > Terminales Spé. NSI > Programmation objet

Jeu de dominos

Les dominos

Qu’est-ce que le jeu de dominos ?

Programmation

  1. Écrire le code de la classe Domino telle que le constructeur initialise les variables gauche et droite.

Penser à définir et utiliser une fonction verifie_valeur dont la spécification est

def verifie_valeur(self, val: int, cote: str) -> int:
    """
    Vérifie que la valeur attribuée au Domino est correcte.
    Dans le cas contraire, lève une exception.
    """
  1. Écrire le code de la fonction est_double dont la spécification est
def est_double(self: Domino) -> bool:
    """
    Teste si le domino est double.
    """
  1. Écrire le code de la fonction est_blanc dont la spécification est
def est_blanc(self: Domino) -> bool:
    """
    Teste si le domino est blanc, c'est à dire si ces valeurs gauche et
    droite sont nulles.
    """
  1. Écrire le code de la fonction nbre_points dont la spécification est
def nbre_points(self: Domino) -> int:
    """
    Compte le nombre de points.
    """
  1. Écrire le code de la fonction __str__ suivant
def __str__(self: Domino) -> str:
    """
    Affichage du domino.
    """
    if not self.est_double():
        return """
        ⎡⎺⎺⎺⎺⎺ ⎺⎺⎺⎺⎺⎤
        ⎢  {}  ⎢  {}  ⎥ 
        ⎣⎽⎽⎽⎽⎽ ⎽⎽⎽⎽⎽⎦
        """.format(self.gauche, self.droite)
    else:
        return """
        ⎡⎺⎺⎺⎺⎺⎤
        ⎢  {}  ⎢
        ⎢⎻⎻⎻⎻⎻⎢
        ⎢  {}  ⎢
        ⎣⎽⎽⎽⎽⎽⎦
        """.format(self.gauche, self.droite)
  1. Écrire le code de la classe JeuDominos dont le constructeur initialise la variable nbre_pieces à 28 et crée la variable jeu de type liste de dominos.
    Définir la fonction creation_jeu dont l’objet est la création du jeu.

  2. Écrire le code de la fonction melanger dont la spécification est

def melanger(self: JeuDominos) -> None:
    """
    Mélange aléatoirement le jeu de dominos.
    """
  1. Écrire le code de la fonction distribuer dont la spécification est
def distribuer(self: JeuDominos, nbre_joueurs: int) -> List[Domino]:
    """
    Extractions des dominos attribués à un joueur de la liste des dominos et retour des dominos attribués à ce joueur.
    """
  1. Écrire le code de la fonction affiche_jeu dont la spécification est
def affiche_jeu(self: JeuDominos) -> None:
    """
    Affiche le jeu ou la pioche en fonction de l'avancée du jeu.
    """
  1. Initialiser le jeu, et le mélanger.

  2. Pour le joueur 1, utiliser le code suivant

print("Joueur 1")
print("========")
jeu_j1 = jeu.distribuer(2)
points_joueur_1 = 0
nbre_dominos_blancs_j1 = 0
nbre_dominos_doubles_j1 = 0
for domino in jeu_j1:
    print(domino)
    points_joueur_1 += domino.nbre_points()
    if domino.est_blanc():
        nbre_dominos_blancs_j1 += 1
    if domino.est_double():
        nbre_dominos_doubles_j1 += 1

print(
    f"{points_joueur_1} points possibles, dont {nbre_dominos_blancs_j1} dominos blancs et {nbre_dominos_doubles_j1} dominos doubles."
)
  1. Adapter le code précédent pour le joueur 2.

  2. Afficher la pioche.