JEU DE BATAILLE

Présentation

• La bataille est un jeu de cartes qui se joue habituellement à deux et qui est d'une grande simplicité pour les débutants, puisqu'on peut y jouer sous la conduite exclusive du hasard.

• Règles :
  • On distribue l'ensemble d'un jeu de cartes (54 ou 32) aux joueurs, qui n'en prennent pas connaissance.
  • À chaque tour, chaque joueur retourne la carte du haut de sa main (ou son tas). Celui qui a la carte de la plus haute valeur (du 2 ou du 7 jusqu'à l'As) récupère les cartes, qu'il place sous son tas.
  • En cas d'égalité de valeurs — cas appelé bataille — les joueurs disent « bataille ! », et commencent par placer une première carte face cachée puis une seconde carte face visible pour décider qui récupèrera les cartes. En cas de nouvelle égalité, la procédure est répétée.
  • À la fin, le joueur gagnant remporte toutes les cartes, qu'il place sous son tas. La bataille est parfois l'occasion d'acquérir une grosse carte et c'est l'unique manière de gagner un as. Sans bataille et à moins qu'un joueur ne possède tous les As, il serait impossible de terminer une partie de bataille.
  • Lorsqu'un joueur a en sa possession toutes les cartes du jeu, il gagne la partie.

Représentation

• On utilisera les classes définissant une pile et une file vues précédemment en cours.

Les cartes

CARTES=[(i,j) for i in range(8) for j in range(4)]

Pour un jeu de 32 cartes, on représente la valeur et la couleur d'une carte par un tuple d'entiers $(i,j)$ tels que:

• $i$ est la valeur de 0 à 7 : 0 correspond au "7" et 7 correspond à l'As
• $j$ est la couleur de 0 à 3 : 0 pour "Pique, 1 pour "Coeur", 2 pour "Carreau", 3 pour "Trèfle"
• Ainsi $(5,2)$ représente la Dame de Carreau

La distribution

• Le jeu à distribuer est une pile.
• Distribuer ce jeu pour deux joueurs , c'est dépiler les cartes du jeu pour constituer deux piles.

Les tas des joueurs

• Lors du jeu, les tas de cartes des joueurs sont des files dont la tête est la carte du dessus.
• Jouer une carte, c'est la défiler.
• Les cartes gagnées au cours du jeu par un joueur sont placées sous son tas de cartes, c'est à dire en queue de file.

Représentation graphique

• La classe Card fournie ci-après permet d'afficher deux cartes côte à côte avec différents affichages possibles.

• Exemples :

carte1=Card(5,2)
carte2=Card(7,0)
carte1.affiche_bataille(carte2)
carte1.affiche_bataille(carte2,visible=0)
carte1.affiche_bataille(carte2,visible=1)

┌───────┐       ┌───────┐
| Q     |       | A     |
|       |       |       |
|   ♦   |       |   ♠   |
|       |       |       |
|     Q |       |     A |
└───────┘       └───────┘
 ┌───────┐        ┌───────┐
┌|///////|       ┌|///////|
||///////|       ||///////|
||///////|       ||///////|
||///////|       ||///////|
||///////|       ||///////|
|└───────┘       |└───────┘
└───────┘        └───────┘
 ┌───────┐        ┌───────┐
┌| Q     |       ┌| A     |
||       |       ||       |
||   ♦   |       ||   ♠   |
||       |       ||       |
||     Q |       ||     A |
|└───────┘       |└───────┘
└───────┘        └───────┘

class Card:
    def __init__(self,i,j):
        self.i=i
        self.j=j
        self.value =['7','8','9','10','J','Q','K','A'][i]
        self.suit = ["♠","♥","♦","♣"][j]

    def affiche_bataille(self,card,visible=-1):
        if visible==-1:
            print('┌───────┐','     ','┌───────┐')
            print(f'| {self.value:<2}    |','     ',f'| {card.value:<2}    |')
            print('|       |','     ','|       |')
            print(f'|   {self.suit}   |','     ',f'|   {card.suit}   |')
            print('|       |','     ','|       |')
            print(f'|    {self.value:>2} |','     ',f'|    {card.value:>2} |')
            print('└───────┘','     ','└───────┘') 
        
        elif visible==0 :
            print(' ┌───────┐','     ',' ┌───────┐')
            print('┌|///////|','     ','┌|///////|')
            print('||///////|','     ','||///////|')
            print('||///////|','     ','||///////|')
            print('||///////|','     ','||///////|')
            print('||///////|','     ','||///////|')
            print('|└───────┘','     ','|└───────┘') 
            print('└───────┘ ','     ','└───────┘') 
        
        else:
            print(' ┌───────┐','     ',' ┌───────┐')
            print(f'┌| {self.value:<2}    |','     ',f'┌| {card.value:<2}    |')
            print('||       |','     ','||       |')
            print(f'||   {self.suit}   |','     ',f'||   {card.suit}   |')
            print('||       |','     ','||       |')
            print(f'||    {self.value:>2} |','     ',f'||    {card.value:>2} |')
            print('|└───────┘','     ','|└───────┘') 
            print('└───────┘ ','     ','└───────┘') 

Travail :

A faire

• Par groupe de deux ou trois, vous devez écrire un progamme python qui simule le jeu de bataille entre deux joueurs.Ce pregramme sera constitué d'au moins deux fichiers :
  • Un fichier qui contiendra les classes et les fonctions nécéssaires.
  • Un fichier principal qui contiendra la programme à éxécuter.

A rendre

En plus du programme, un fichier individuel au format .pdf de 5 pages maximum contenant un rapport avec :

• La répartition des tâches dans le groupe.
• Les difficultés rencontrées et les solutions proposées.
• L'explication d'une partie de code que vous aurez plus spécifiquement travaillé.