jeu de Dominos et POO - version classique

Le jeu de Dominos est un jeu très simple, ou, pour gagner, il faut être le premier joueur à avoir posé tous ses dominos. Une fois le premier domino placé sur la table, le joueur suivant doit à son tour poser un domino ayant le même nombre de points sur au moins un côté du domino précédemment posé.

Un domino est constitué de côtés, droite/gauche ou haut/bas selon comment la pièce sera disposée.

La disposition importe peu: il faut que la chaine reste ouverte.

On utilise la définition de classes suivantes:

class Domino:
    def __init__(self,val1,val2):
        self.val1 = val1
        self.val2 = val2
        self.suiv = None

    
class Partie:
    def __init__(self,first):
        self.first = first
        
    def last(self):
        """parcours de la liste chainee jusqu'a la fin
        return: str, valeurs du dernier domino sous la forme
        val1:val2
        """
        M = self.first
        while not M.suiv is None:
            M = M.suiv
        return '{}:{}'.format(M.val1,M.val2)
        
    def atteindre_domi(self,val2):
    	"""docstring a ajouter
    	"""
        D = self.first
        while not D.suiv is None and D.val2 != val2:
            D = D.suiv
        if D.val2 == val2:
            # domino trouve
            return D
        else:
            # domino non trouve, retourne False
            return False   
            
    def inserer(self,D_a_inserer):
    		"""insere le domino D_a_inserer a la premiere place possible
            dans le jeu
            param:
            D_a_inserer est une instance de la classe Domino. Il s'agit d'un domino double: D_a_inserer.val1 == D_a_inserer.val2

            exemple d'utilisation:
            etat de la partir avant insertion
            4:3=>3:2=>2:1
            on insere le domino D4 de valeur 3:3 en trouvant sa place
            dans la partie
            >>> partie.inserer(D4)
            etat de la partie apres insertion
            4:3=>3:3=>3:2=>2:1
            """
            #à completer

    def __repr__(self):
        M = self.first
        s = '{}:{} '.format(M.val1,M.val2)
			# à completer
        return s

Qu a. On cherche à modéliser la partie de l’image de gauche (voir plus haut). Les dominos seront instanciés à l’aide des noms D1, D2, D3, … Ecrire les instructions qui instancient tous les dominos de la partie, avec, pour chacun, leurs valeurs et le domino suivant.

Qu b. Ecrire l’instruction qui doit créer l’objet partie1 à partir de ce plateau de jeu. (classe Partie)

Qu c. Compléter la méthode de classe __repr__ qui surcharge la fonction print

Qu d. Commenter la méthode de classe atteindre_domi. A quoi sert-elle? Quelle est sa complexité asymtotique?

Qu e. Imaginons que l’état de la partie soit celui-ci:

print(partie1)
4:4 => 4:6 => 6:1 => 1:5 => 5:4 => 4:2 => 2:1 => 1:3 

Compléter la méthode de classe inserer qui permet d’insérer un domino (double) dans la chaine de dominos à partir des instructions suivantes:

D = partie1.atteindre_domi(2)
D10 = Domino(2,2)
partie1.inserer(D10)

Le nouvel état de la partie devrait alors être :

print(partie1)
4:4 => 4:6 => 6:1 => 1:5 => 5:4 => 4:2 => 2:2 => 2:1 => 1:3 

Qu f. Insérer le domino 1:1 à sa place, dans la partie.

Qu g. Ajouter une méthode de classe poser qui pose un domino à la suite du dernier domino posé dans la partie, à condition que celui-ci soit bien en correspondance. La fonction va alors retourner l’état de la partie (si le nouveau domino peut être posé), ou bien un message signifiant que la pose est interdite. Tester votre methode de classe poser en choisissant un domino correct, puis un domino non correct.

Corrections

à venir