Activité pratique

Consignes globales

Dans cette séance, vous allez implémenter en Python une version simplifiée du jeu de société Citadelles pour 2 joueurs. Cette activité vous permettra de mettre en pratique les concepts de programmation orientée objet vus en Algo 1 et d’appliquer les bonnes pratiques de développement logiciel acquises dans les séances précédentes (documentation, tests, programmation défensive).

Vous partirez de la conception POO déjà réalisée en Algo 1 (identification des classes, attributs, méthodes et relations) pour aboutir à un programme exécutable permettant de jouer une partie complète.

A la fin de la séance, vous devrez être capable de :

• Implémenter des classes Python à partir d’un modèle de conception
• Structurer un projet multi-fichiers
• Écrire et exécuter des tests unitaires pour valider votre code
• Créer une interface simple en ligne de commande pour interagir avec votre programme
• Jouer une partie à 2 rôles (en incarnant les deux joueurs)

Contenu de l’activité

Préparation de l’environnement

Avant de commencer, créez un projet uv dédié à cette séance. Dans un terminal, placez-vous dans le dossier de la séance (par exemple imt/s5/info/prog/session4), puis lancez la commande suivante :

uv init --no-package

uv init --no-package

uv init --no-package

uv init --no-package

Vous écrirez tous les fichiers de cette séance dans ce projet, en ajoutant les bibliothèques dont vous avez besoin avec uv add et en exécutant vos programmes dans l’environnement virtuel associé. Au besoin, revoyez la fiche Gestion moderne de projet Python avec uv.

Organisation de l’activité

Vous allez travailler individuellement ou en binôme pour implémenter le jeu. Le TP est découpé en 6 étapes progressives :

Rappel de la conception et mise en place (15 min)

Objectif : S’assurer que tout le monde part sur de bonnes bases en rappelant la conception POO déjà réalisée en Algo 1.

Rappel des classes incontournables

En Algo 1, vous avez identifié les classes principales pour modéliser Citadelles. Dans ce TP, nous avons fait un choix de conception, afin de simplifier l’exercice. Ce choix est discutable, vous pouvez d’ailleurs en discuter avec votre encadrant(e). Pour démarrer, voici un rappel des classes incontournables :

• Carte : classe de base pour tous les types de cartes
• Quartier et Personnage : sous-classes de Carte
• Joueur (ou Player) : représente un·e joueur·euse
• Partie : orchestre le déroulement du jeu

Question de rappel : Quelles autres classes ou regroupements de cartes aviez-vous identifiés ?

Schéma conceptuel de base

Voici deux schémas simplifiés des relations entre les principales classes (à compléter et affiner) :

Relations d’héritages entre les cartes :

classDiagram
    class Carte
    class Quartier
    class Personnage
    Carte <|-- Quartier
    Quartier <|-- Noble
    Quartier <|-- Religieux
    Quartier <|-- Commercial
    Quartier <|-- Militaire
    Quartier <|-- Prestige
    Carte <|-- Personnage
    Personnage <|-- Assassin
    Personnage <|-- Voleur
    Personnage <|-- Magicien
    Personnage <|-- Roi
    Personnage <|-- Eveque
    Personnage <|-- Marchand
    Personnage <|-- Architecte
    Personnage <|-- Condottiere

Carte (classe abstraite)
├── Quartier (classe abstraite)
│   ├── Noble (ex: Manoir, Palais)
│   ├── Religieux (ex: Temple, Eglise)
│   ├── Commercial (ex: Taverne, Echoppe)
│   ├── Militaire (ex: Tour de guet, Caserne)
│   └── Prestige (ex: Cour des miracles, Donjon)
└── Personnage (classe abstraite)
    ├── Assassin
    ├── Voleur
    ├── Magicien
    ├── Roi
    ├── Eveque
    ├── Marchand
    ├── Architecte
    └── Condottiere

classDiagram
    Partie -- "2" Joueur
    Joueur -- Jeu
    Joueur -- Cité
    Joueur -- "2" Personnage
    Partie -- Personnage
    Partie -- Pioche

Partie
├── Joueur (x2)
│   ├── Jeu (cartes Quartier)
│   ├── Cité (quartiers construits)
│   └── Personnages choisis
├── Pioche (cartes Quartier)
└── Personnages (gestion des personnages disponibles/écartés)

Vérification de la compréhension

Avant de commencer à coder, assurez-vous de pouvoir répondre à ces questions :

1. Quels attributs une carte Quartier doit-elle avoir ?
2. Quels attributs une carte Personnage doit-elle avoir ?
3. Comment modéliser la relation entre un Joueur et ses cartes (main, cité, personnages) ?
4. Où stocker les cartes Quartier qui n’ont pas encore été piochées ?

Mise en place de l’environnement

1. Organisation du projet : tous les fichiers de ce TP seront créés directement à la racine du projet uv de la séance, les uns à côté des autres :

   • un fichier par classe (ou famille de classes) : carte.py, quartier.py, etc.
   • un fichier de tests par fichier de code, nommé test_*.py : test_carte.py, test_quartier.py, etc.

   Le fichier main.py créé par uv init sera remplacé à l’étape 4 par celui qui vous est fourni.

2. Première version dans Git (optionnel) : le dépôt Git a déjà été créé par uv init, il ne reste donc qu’à enregistrer une première version. Depuis la racine du projet :

   ​

   Windows (Batch) Windows (PowerShell) Linux (Bash) MacOS (Zsh)

   git add .
   git commit -m "Initial commit - Debut implementation Citadelles"

   git add .
   git commit -m "Initial commit - Debut implementation Citadelles"

   git add .
   git commit -m "Initial commit - Début implémentation Citadelles"

   git add .
   git commit -m "Initial commit - Début implémentation Citadelles"

Implémentation des classes de base (45 min)

Objectif : Coder les classes les plus simples et indépendantes.

from enum import Enum

class Couleur(Enum):
    NOBLE = "Jaune"
    RELIGIEUX = "Bleu"
    COMMERCIAL = "Vert"
    MILITAIRE = "Rouge"
    PRESTIGE = "Violet"

from abc import ABC, abstractmethod

class Forme(ABC):
    @abstractmethod
    def aire(self) -> float:
        pass # 'pass' indique de ne rien faire tout en étant syntaxiquement correct

class Carre(Forme):
    def __init__(self, cote: float) -> None:
        self._cote = cote

    def aire(self) -> float:
        return self._cote ** 2

c = Carre(2)   # possible : Carre implémente aire()
f = Forme()    # TypeError : Forme a une méthode abstraite

Classe Carte (classe de base)

Créez la classe Carte dans carte.py :

• Carte (classe abstraite avec attribut : _nom)

Exigences :

• Chaque classe doit être documentée (docstring).
• Cette classe servira de base pour Quartier et Personnage.

from abc import ABC

class Carte(ABC):
    """Classe abstraite représentant une carte dans le jeu Citadelles."""
    
    def __init__(self, nom: str) -> None:
        """
        Initialise une carte avec son nom.
        
        Args:
            nom: Le nom de la carte
        """
        self._nom = nom
    
    def nom(self) -> str:
        """Retourne le nom de la carte."""
        return self._nom
    
    def __str__(self) -> str:
        """Retourne une représentation textuelle de la carte."""
        return f"{self.__class__.__name__}: {self._nom}"

import unittest
from carte import Carte

class TestCarte(unittest.TestCase):
    def test_creation_carte_valide(self):
        c = Carte("une carte")
        self.assertEqual(c.nom(), "une carte")
        self.assertEqual(str(c), "Carte: une carte")

python -m unittest -v

python -m unittest -v

python3 -m unittest -v

python3 -m unittest -v

Hiérarchie des Quartiers

Créez les classes suivantes dans quartier.py :

• Couleur (énumération pour les 5 couleurs : Noble, Religieux, Commercial, Militaire, Prestige)
• Quartier (classe héritant de Carte avec attributs : _nom, _couleur, _cout, _points)
• Sous-classes de Quartier pour chaque type (ex: Noble, Religieux, etc.)

Exigences :

• Quartier hérite de Carte (utilisez from carte import Carte)
• Chaque classe doit être documentée (docstring).
• Vérifiez que les arguments cout et points sont des entiers positifs (programmation défensive).
• Ajoutez à Quartier les méthodes get_points(self) -> int et get_cout(self) -> int, qui retournent respectivement les points et le coût du quartier (elles seront utilisées par Cite et Partie).
• Écrivez des tests unitaires dans test_quartier.py.

Conseils :

• Veillez à typer les paramètres des méthodes, pour une meilleure lisibilité et maintenabilité du code.
• Indiquez également le type retour des méthodes.
• Utilisez les exceptions de type ValueError pour la programmation défensive.
• Appuyez-vous sur les tests pour développer la classe, en particulier respectez l’ordre et les noms des paramètres.
• L’héritage impose, dans la méthode __init__(self, ...), d’appeler super().__init__(...) avec les arguments attendus par la classe mère.

import unittest
from quartier import Couleur, Noble, Religieux

class TestQuartier(unittest.TestCase):
    def test_creation_quartier_valide(self):
        q = Religieux("Temple", 1, 1)
        self.assertEqual(q._nom, "Temple")
        self.assertEqual(q._couleur, Couleur.RELIGIEUX)
        self.assertEqual(q._cout, 1)
        self.assertEqual(q._points, 1)

    def test_heritage_noble(self):
        manoir = Noble("Manoir", 3, 2)
        self.assertEqual(manoir._nom, "Manoir")
        self.assertEqual(manoir._couleur, Couleur.NOBLE)
        self.assertEqual(manoir._cout, 3)

    def test_couleur_enum(self):
        # Vérifie que toutes les couleurs sont définies
        self.assertEqual(len(Couleur), 5)
        self.assertIn(Couleur.NOBLE, Couleur)
        self.assertIn(Couleur.PRESTIGE, Couleur)

def creer_quartiers() -> list[Quartier]:
    """
    Crée et retourne la liste complète des quartiers pour Citadelles à 2 joueurs.
    
    Returns:
        Liste de tous les quartiers du jeu
    """
    return [
        # Noble (jaune) - 9 cartes
        Noble("Manoir", 3, 2),
        Noble("Manoir", 3, 2),
        Noble("Manoir", 3, 2),
        Noble("Manoir", 3, 2),
        Noble("Palais", 5, 4),
        Noble("Palais", 5, 4),
        Noble("Château", 4, 3),
        Noble("Château", 4, 3),
        Noble("Château", 4, 3),
        
        # Religieux (bleu) - 10 cartes
        Religieux("Temple", 1, 1),
        Religieux("Temple", 1, 1),
        Religieux("Temple", 1, 1),
        Religieux("Eglise", 2, 2),
        Religieux("Eglise", 2, 2),
        Religieux("Eglise", 2, 2),
        Religieux("Monastère", 3, 3),
        Religieux("Monastère", 3, 3),
        Religieux("Monastère", 3, 3),
        Religieux("Cathedrale", 5, 5),
        
        # Commercial (vert) - 18 cartes
        Commercial("Taverne", 1, 1),
        Commercial("Taverne", 1, 1),
        Commercial("Taverne", 1, 1),
        Commercial("Taverne", 1, 1),
        Commercial("Taverne", 1, 1),
        Commercial("Echoppe", 2, 2),
        Commercial("Echoppe", 2, 2),
        Commercial("Echoppe", 2, 2),
        Commercial("Echoppe", 2, 2),
        Commercial("Marche", 2, 2),
        Commercial("Marche", 2, 2),
        Commercial("Marche", 2, 2),
        Commercial("Comptoir", 3, 3),
        Commercial("Comptoir", 3, 3),
        Commercial("Comptoir", 3, 3),
        Commercial("Port", 4, 4),
        Commercial("Port", 4, 4),
        Commercial("Hotel de ville", 5, 5),
        
        # Militaire (rouge) - 10 cartes
        Militaire("Tour de guet", 1, 1),
        Militaire("Tour de guet", 1, 1),
        Militaire("Tour de guet", 1, 1),
        Militaire("Prison", 2, 2),
        Militaire("Prison", 2, 2),
        Militaire("Prison", 2, 2),
        Militaire("Caserne", 3, 3),
        Militaire("Caserne", 3, 3),
        Militaire("Caserne", 3, 3),
        Militaire("Forteresse", 5, 5),
        
        # Prestige (violet) - 3 cartes
        Prestige("Cour des miracles", 2, 3),
        Prestige("Donjon", 3, 3),
        Prestige("Tresor imperial", 4, 4),
    ]

from pioche import Pioche
from quartier import creer_quartiers

pioche = Pioche(creer_quartiers())

Hiérarchie des Personnages

Créez les classes suivantes dans personnage.py :

• Personnage (classe héritant de Carte avec attributs : _nom, _description, _ordre)
• Sous-classes pour chaque rôle : Assassin, Voleur, Magicien, Roi, Eveque, Marchand, Architecte, Condottiere

Exigences :

• Personnage hérite de Carte (utilisez from carte import Carte)
• L’attribut _ordre détermine l’ordre de jeu (Assassin=1, Voleur=2, …, Condottiere=8).
• Implémentez la méthode __eq__ dans la classe Personnage pour permettre la comparaison d’instances (ex: if p1 == p2). Deux personnages sont égaux s’ils ont le même ordre.
• Documentez chaque classe.
• Écrivez des tests dans test_personnage.py.

Conseils :

• Les conseils précédents s’appliquent ici également.
• N’hésitez pas à copier/coller depuis d’autres fichiers (en adaptant les parties dupliquées) et depuis les Règles simplifiées pour 2 joueurs.

import unittest
from personnage import *

class TestPersonnage(unittest.TestCase):
    def test_creation_assassin(self):
        assassin = Assassin()
        self.assertEqual(assassin._nom, "Assassin")
        self.assertEqual(assassin._ordre, 1)

    def test_creation_roi(self):
        roi = Roi()
        self.assertEqual(roi._nom, "Roi")
        self.assertEqual(roi._ordre, 4)  # Roi est le 4ème

    def test_creation_condottiere(self):
        condottiere = Condottiere()
        self.assertEqual(condottiere._ordre, 8)  # Condottiere est le dernier

    def test_ordres_uniques(self):
        # Vérifie que tous les personnages ont des ordres différents
        personnages = [Assassin(), Voleur(), Magicien(), Roi(), 
                      Eveque(), Marchand(), Architecte(), Condottiere()]
        ordres = [p._ordre for p in personnages]
        self.assertEqual(len(set(ordres)), len(ordres))  # Tous uniques

def creer_personnages() -> list[Personnage]:
    """
    Crée et retourne la liste complète des personnages pour Citadelles à 2 joueurs.
    
    Returns:
        Liste de tous les personnages du jeu
    """
    return [
        Assassin(),
        Voleur(),
        Magicien(),
        Roi(),
        Eveque(),
        Marchand(),
        Architecte(),
        Condottiere()
    ]

from personnage import creer_personnages

personnages = creer_personnages()

Collections de cartes (45 min)

Objectif : Implémenter les classes qui gèrent les groupes de cartes.

Pioche

Créez la classe Pioche dans pioche.py avec les méthodes :

• melanger(self) -> None : mélange les cartes de la pioche
• piocher(self) -> Carte | None : pioche la première carte (retourne None si vide)
• ajouter_carte(self, carte:Carte) -> None : ajoute une carte à la pioche
• est_vide(self) -> bool : retourne True si la pioche est vide

De plus, le constructeur prendra en paramètre une liste de cartes qui sera stocké dans l’attribut _cartes.

Remarque : Dans une pioche, nous ne souhaitons manipuler que des objets de type de Carte. C’est pourquoi dans le constructeur, le paramètre cartes devra être typé avec cartes : list[Carte]. Cela implique d’importer correctement la classe Carte dans Pioche.

Conseil : Le module random dispose d’une fonction nommée shuffle permettant de mélanger (en place) les éléments d’une liste passée en paramètre (Documentation).

Tests : test_pioche.py

import unittest
from pioche import Pioche
from quartier import Quartier, Couleur

class TestPioche(unittest.TestCase):
    def setUp(self):
        # Crée une pioche avec 3 quartiers pour les tests
        cartes = [
            Quartier("Temple", Couleur.RELIGIEUX, 1, 1),
            Quartier("Eglise", Couleur.RELIGIEUX, 2, 2),
            Quartier("Manoir", Couleur.NOBLE, 3, 2)
        ]
        self.pioche = Pioche(cartes)

    def test_pioche_initiale(self):
        self.assertEqual(len(self.pioche._cartes), 3)

    def test_piocher(self):
        carte = self.pioche.piocher()
        self.assertIsNotNone(carte)
        self.assertEqual(carte._nom, "Temple")
        self.assertEqual(len(self.pioche._cartes), 2)

    def test_piocher_vide(self):
        # Vide la pioche
        self.pioche.piocher()
        self.pioche.piocher()
        self.pioche.piocher()
        self.assertTrue(self.pioche.est_vide())
        self.assertIsNone(self.pioche.piocher())

    def test_ajouter_carte(self):
        nouveau_quartier = Quartier("Taverne", Couleur.COMMERCIAL, 1, 1)
        self.pioche.ajouter_carte(nouveau_quartier)
        self.assertEqual(len(self.pioche._cartes), 4)

    def test_melanger(self):
        # Crée une pioche avec des cartes dans un ordre connu
        cartes = [
            Quartier("A", Couleur.NOBLE, 1, 1),
            Quartier("B", Couleur.NOBLE, 1, 1),
            Quartier("C", Couleur.NOBLE, 1, 1)
        ]
        pioche = Pioche(cartes)
        pioche.melanger()
        # On ne peut pas tester l'ordre aléatoire, mais on peut vérifier
        # que la pioche a toujours 3 cartes
        self.assertEqual(len(pioche._cartes), 3)

Jeu

Créez la classe Jeu dans jeu.py avec les méthodes :

• ajouter_carte(self, carte: Carte) -> None : ajoute une carte Quartier au jeu (quand le joueur pioche)
• retirer_carte(self, carte: Carte) -> Carte : retire une carte du jeu (retourne la carte retirée)
• get_cartes(self) -> list[Carte] : retourne la liste des cartes du jeu

Le constructeur déclare un paramètre optionnel nommé cartes qui, s’il est présent, initialisera l’attribut (protégé) de la classe _cartes à celle déclarée ou, s’il est absent, devra initialiser cet attribut à une liste (de cartes) vide.

Tests : test_jeu.py

import unittest
from jeu import Jeu
from quartier import Quartier, Couleur

class TestJeu(unittest.TestCase):
    def setUp(self):
        self.jeu = Jeu()
        self.quartier1 = Quartier("Temple", Couleur.RELIGIEUX, 1, 1)
        self.quartier2 = Quartier("Manoir", Couleur.NOBLE, 3, 2)

    def test_ajouter_carte(self):
        self.jeu.ajouter_carte(self.quartier1)
        self.assertEqual(len(self.jeu.get_cartes()), 1)
        self.assertIn(self.quartier1, self.jeu.get_cartes())

    def test_ajouter_plusieurs_cartes(self):
        self.jeu.ajouter_carte(self.quartier1)
        self.jeu.ajouter_carte(self.quartier2)
        self.assertEqual(len(self.jeu.get_cartes()), 2)

    def test_retirer_carte(self):
        self.jeu.ajouter_carte(self.quartier1)
        self.jeu.ajouter_carte(self.quartier2)
        
        carte_retiree = self.jeu.retirer_carte(self.quartier1)
        self.assertEqual(carte_retiree, self.quartier1)
        self.assertEqual(len(self.jeu.get_cartes()), 1)
        self.assertNotIn(self.quartier1, self.jeu.get_cartes())

    def test_retirer_autre_carte(self):
        self.jeu.ajouter_carte(self.quartier1)
        self.jeu.ajouter_carte(self.quartier2)
        
        self.jeu.retirer_carte(self.quartier2)
        self.assertEqual(len(self.jeu.get_cartes()), 1)
        self.assertNotIn(self.quartier2, self.jeu.get_cartes())

Cité

Créez la classe Cite dans cite.py avec les méthodes :

• construire(self, quartier: Quartier) -> None : construit un quartier dans la cité.
• get_quartiers(self) -> list[Quartier] : retourne la liste des quartiers construits.
• get_points(self) -> int : retourne le total des points.

Par programmation défensive, la méthode construire(self, quartier: Quartier) -> None doit refuser une carte qui est déjà dans la cité, en levant une ValueError. Il s’agit bien de la même carte (le même objet, ce que teste quartier in ...) : deux cartes différentes portant le même nom, comme deux Manoir, peuvent toutes les deux être construites.

Conseil : N’oubliez pas d’initialiser les attributs.

Tests : test_cite.py

import unittest
from cite import Cite
from quartier import Quartier, Couleur

class TestCite(unittest.TestCase):
    def setUp(self):
        self._cite = Cite()
        self.quartier1 = Quartier("Temple", Couleur.RELIGIEUX, 1, 1)
        self.quartier2 = Quartier("Manoir", Couleur.NOBLE, 3, 2)
        self.quartier3 = Quartier("Cathedrale", Couleur.RELIGIEUX, 5, 5)

    def test_construire_quartier(self):
        self._cite.construire(self.quartier1)
        self.assertEqual(len(self._cite.get_quartiers()), 1)
        self.assertIn(self.quartier1, self._cite.get_quartiers())

    def test_get_points(self):
        self._cite.construire(self.quartier1)  # 1 point
        self._cite.construire(self.quartier2)  # 2 points
        self.assertEqual(self._cite.get_points(), 3)

    def test_construire_plusieurs_quartiers(self):
        self._cite.construire(self.quartier1)
        self._cite.construire(self.quartier2)
        self._cite.construire(self.quartier3)
        self.assertEqual(len(self._cite.get_quartiers()), 3)
        self.assertEqual(self._cite.get_points(), 8)  # 1 + 2 + 5

    def test_cite_vide(self):
        self.assertEqual(len(self._cite.get_quartiers()), 0)
        self.assertEqual(self._cite.get_points(), 0)

Classe Joueur (45 min)

Objectif : Implémenter la classe centrale Joueur.

La classe Joueur dépend de Jeu et Cite (implémentées en Étape 2). Dans la version de Citadelles à deux joueurs, chaque joueur gère deux personnages.

Créez la classe Joueur dans joueur.py avec :

• Attributs : _nom, _jeu (instance de Jeu), _cite (instance de Cite), _pieces (entier), _personnages (liste de Personnage ou vide). Seul le nom du joueur est passé en paramètre du constructeur, les autres attributs sont initialisés dans le constructeur.
• Méthodes :
  • recevoir_or(self, montant : int) -> None : ajoute de l’or (vérifier que le montant est strictement positif ou lever une ValueError)
  • payer(self, montant : int) -> bool : retire de l’or (retourne True si succès). Vérifier que les conditions sont réunies avant de procéder au retrait du montant.
  • construire_quartier(self, quartier: Quartier) -> bool : construit un quartier du jeu, indique par retour si la construction a eu lieu.
  • get_points(self) -> int : retourne les points totaux

Exigences :

• Vérifiez que le joueur a assez d’or avant de construire.
• Vérifiez que le quartier est dans le jeu du joueur.
• Écrivez des tests complets dans test_joueur.py.
• Vérifier bien les imports.

Remarques: Le mot or est réservé en Python (opérateur booléen), nous ne pouvons donc pas l’utiliser comme nom d’attribut ou de paramètre. C’est pourquoi nous utilisons le terme pieces.

import unittest
from joueur import Joueur
from jeu import Jeu
from cite import Cite
from personnage import Assassin
from quartier import Quartier, Couleur

class TestJoueur(unittest.TestCase):
    def setUp(self):
        self.joueur = Joueur("Alice")
        self.quartier1 = Quartier("Temple", Couleur.RELIGIEUX, 1, 1)
        self.quartier2 = Quartier("Manoir", Couleur.NOBLE, 3, 2)

    def test_creation_joueur(self):
        self.assertEqual(self.joueur._nom, "Alice")
        self.assertEqual(self.joueur._pieces, 0)
        self.assertEqual(self.joueur._personnages, [])
        self.assertIsInstance(self.joueur._jeu, Jeu)
        self.assertIsInstance(self.joueur._cite, Cite)

    def test_recevoir_or(self):
        self.joueur.recevoir_or(5)
        self.assertEqual(self.joueur._pieces, 5)
        
        self.joueur.recevoir_or(3)
        self.assertEqual(self.joueur._pieces, 8)

    def test_payer_suffisant(self):
        self.joueur.recevoir_or(10)
        result = self.joueur.payer(5)
        self.assertTrue(result)
        self.assertEqual(self.joueur._pieces, 5)

    def test_payer_insuffisant(self):
        self.joueur.recevoir_or(3)
        result = self.joueur.payer(5)
        self.assertFalse(result)
        self.assertEqual(self.joueur._pieces, 3)  # L'or ne change pas

    def test_construire_quartier_avec_assez_or(self):
        self.joueur.recevoir_or(10)
        self.joueur._jeu.ajouter_carte(self.quartier1)
        
        result = self.joueur.construire_quartier(self.quartier1)
        self.assertTrue(result)
        self.assertEqual(self.joueur._pieces, 9)  # 10 - 1
        self.assertEqual(len(self.joueur._jeu.get_cartes()), 0)
        self.assertEqual(len(self.joueur._cite.get_quartiers()), 1)

    def test_construire_quartier_sans_assez_or(self):
        self.joueur.recevoir_or(1)
        self.joueur._jeu.ajouter_carte(self.quartier2)  # cout = 3
        
        result = self.joueur.construire_quartier(self.quartier2)
        self.assertFalse(result)
        self.assertEqual(self.joueur._pieces, 1)  # L'or ne change pas
        self.assertEqual(len(self.joueur._cite.get_quartiers()), 0)

    def test_construire_quartier_pas_dans_main(self):
        self.joueur.recevoir_or(10)
        # Le quartier n'est pas dans le jeu
        result = self.joueur.construire_quartier(self.quartier1)
        self.assertFalse(result)

    def test_get_points(self):
        self.joueur.recevoir_or(10)
        self.joueur._jeu.ajouter_carte(self.quartier1)  # 1 point
        self.joueur._jeu.ajouter_carte(self.quartier2)  # 2 points
        
        self.joueur.construire_quartier(self.quartier1)
        self.joueur.construire_quartier(self.quartier2)
        
        self.assertEqual(self.joueur.get_points(), 3)

    def test_personnage(self):
        self.joueur._personnages = [Assassin()]
        self.assertIsNotNone(self.joueur._personnages)
        self.assertEqual(len(self.joueur._personnages), 1)
        self.assertEqual(self.joueur._personnages[0]._nom, "Assassin")

Classe Partie et intégration (45 min)

Objectif : Orchestrer le déroulement du jeu en utilisant les fichiers fournis.

Fichiers à utiliser : Ci-après, vous trouverez 4 fichiers Python à utiliser à partir de cette étape :

session4/
├── main.py              # Déjà fourni (remplace celui de uv)
├── ui.py                # Déjà fourni
├── partie.py            # À compléter
├── test_partie.py       # Déjà fourni (à utiliser pour valider)
└── ... (vos autres fichiers)

Classe Partie (partie.py) :

La classe Partie fournie gère le déroulement complet d’une partie. Plusieurs méthodes sont déjà implémentées :

• __init__(self, joueur1: str, joueur2: str) -> None : Initialise la partie avec 2 joueurs, la couronne, les personnages et la pioche
• _distribuer_quartiers_initiaux(self) -> None : Distribue 4 quartiers à chaque joueur (ordre dépend de la couronne)
• _distribuer_personnages(self) -> None : Gère le choix des personnages par les joueurs
• _lancer_tour(self) -> None : Orchestre un tour complet (appelle _jouer_tour pour chaque personnage)
• _choisir_personnage(self, joueur: Joueur, personnages: Jeu) -> bool : Permet à un joueur de choisir un personnage
• _jouer_tour(self, joueur: Joueur, personnage: Personnage, pioche: Pioche) -> None : Gère le tour d’un joueur avec un personnage
• _choisir_revenu(self, joueur: Joueur, pioche: Pioche) -> None : Permet de choisir entre or ou quartiers
• _construire_quartier(self, joueur: Joueur) -> None : Gère la construction d’un quartier
• _appliquer_pouvoir(self, personnage: Personnage) -> None : Affiche seulement la description du pouvoir du personnage ; à compléter si vous implémentez les pouvoirs (étape 5)

Méthodes à compléter dans partie.py :

Vous devez implémenter les 3 méthodes marquées TODO :

1. lancer_partie(self) -> None : Méthode principale qui orchestrerait :

   • Distribution initiale des quartiers (4 par joueur)
   • Distribution initiale de l’or (2 pièces par joueur)
   • Boucle des tours jusqu’à ce qu’un joueur ait 8 quartiers
   • Comptage des points en fin de partie

2. _conditions_arret(self) -> bool : Retourne True si un joueur a construit 8 quartiers dans sa cité

3. _comptage_points(self) -> None : Calcule et affiche les points de chaque joueur en fin de partie

Conseils pour compléter :

• Utilisez les méthodes déjà implémentées (_distribuer_quartiers_initiaux, _distribuer_personnages, _lancer_tour)
• Inspirez-vous des tests dans test_partie.py pour comprendre le comportement attendu
• La condition d’arrêt : len(joueur._cite.get_quartiers()) >= 8
• Pour le comptage des points : utilisez joueur.get_points()

Règles appliquées dans le code fourni :

• Chaque joueur choisit 2 personnages par tour (méthode _distribuer_personnages())
• Ordre de jeu : selon l’ordre des personnages (Assassin=1 joue en premier)
• Tour de jeu pour chaque personnage :
  1. Choix du revenu (2 pièces ou piocher 2 quartiers et en garder 1)
  2. Construction d’un quartier (optionnelle)
  3. Application du pouvoir spécial (à implémenter si temps)
• La couronne est attribuée aléatoirement au début et change si le Roi est choisi

Fichier main.py fourni :

from partie import Partie
from ui import UI

if __name__ == "__main__":
    UI.clear()
    UI.title("🏰 CITADELLES 🏰")
    UI.info("Jeu à 2 joueurs - créé par Bruno Faidutti")
    UI.separator()
    
    nom1 = input("Nom du Joueur 1 [Alice] : ") or "Alice"
    nom2 = input("Nom du Joueur 2 [Bob] : ") or "Bob"
    UI.info(f"Début de la partie entre {nom1} et {nom2}")
    UI.separator()
    
    partie = Partie(nom1, nom2)
    partie.lancer_partie()

Fichier ui.py fourni : Classe utilitaire pour un affichage console agréable avec méthodes statiques pour les titres, menus, messages de succès/erreur, etc.

Tests fournis : Le fichier test_partie.py contient des tests pour valider votre implémentation. Exécutez-le avec python -m unittest test_partie.py.

Intégration et test complet (30 min)

Objectif : Valider que tout fonctionne ensemble.

1. Exécutez le programme : python main.py
2. Jouez une partie complète à 2 rôles (vous incarnez les deux joueurs).
3. Corrigez les bugs en utilisant les messages d’erreur.
4. Ajoutez des améliorations (si temps) :
   • Implémentez les pouvoirs des personnages (Assassin, Voleur, etc.)
   • Déplacez la logique du joueur depuis la classe Partie vers la classe Joueur
   • Améliorez l’interface (couleurs, tableaux)
   • Vérifiez que la logique du jeu est respectée (et testée), comme la validité des actions par exemple.

Après le TP

Compléter l’activité

Avant la prochaine séance, vous devez :

• Terminer les parties obligatoires : Les étapes 4 à 6 (incluses) doivent être fonctionnelles.
• Enregistrer votre code dans votre dépôt Git :
  ​

  Windows (Batch) Windows (PowerShell) Linux (Bash) MacOS (Zsh)

  git add .
  git commit -m "Fin du TP Citadelles"

  git add .
  git commit -m "Fin du TP Citadelles"

  git add .
  git commit -m "Fin du TP Citadelles"

  git add .
  git commit -m "Fin du TP Citadelles"

• Réviser les concepts POO et les bonnes pratiques (documentation, tests).

Structure finale du projet

session4/
├── pyproject.toml       # Configuration du projet uv
├── main.py              # Point d'entrée
├── ui.py                # Classe UI (affichage console)
├── carte.py             # Classe Carte (classe de base)
├── quartier.py          # Classes Quartier et sous-classes
├── personnage.py        # Classes Personnage et sous-classes
├── jeu.py               # Classe Jeu (jeu de cartes)
├── pioche.py            # Classe Pioche
├── cite.py              # Classe Cite
├── joueur.py            # Classe Joueur
├── partie.py            # Classe Partie
├── test_carte.py
├── test_quartier.py
├── test_personnage.py
├── test_jeu.py
├── test_pioche.py
├── test_cite.py
├── test_joueur.py
└── test_partie.py

Pour aller plus loin

Réorganiser le projet en packages

Dans ce TP, tous les fichiers sont placés à plat, à la racine du projet. C’est simple, mais le code de l’application et ses tests se retrouvent mélangés, et cela devient vite difficile à lire quand le projet grandit. L’usage est alors de regrouper le code dans un package et de mettre les tests à part, comme dans le projet Mastermind de la séance précédente.

Un module est un fichier Python (carte.py est le module carte). Un package est un dossier qui regroupe des modules. Pour indiquer à Python qu’un dossier est un package, on y place un fichier nommé __init__.py, qui peut rester vide : il est exécuté la première fois que le package est importé.

Structure visée :

session4/
├── pyproject.toml
├── main.py              # Point d'entrée, reste à la racine
├── citadelles/          # Package contenant le code du jeu
│   ├── __init__.py      # Fichier vide, déclare le package
│   ├── ui.py
│   ├── carte.py
│   ├── quartier.py
│   ├── personnage.py
│   ├── jeu.py
│   ├── pioche.py
│   ├── cite.py
│   ├── joueur.py
│   └── partie.py
└── tests/               # Tests, séparés du code
    ├── test_carte.py
    ├── test_quartier.py
    ├── test_personnage.py
    ├── test_jeu.py
    ├── test_pioche.py
    ├── test_cite.py
    ├── test_joueur.py
    └── test_partie.py

Étapes :

1. Déplacez les fichiers : créez les dossiers citadelles/ et tests/, déplacez-y respectivement les fichiers de code (sauf main.py) et les fichiers test_*.py.

2. Déclarez le package : créez un fichier vide citadelles/__init__.py.

3. Adaptez les imports : les modules ne sont plus à la racine, il faut donc préciser le package dans lequel ils se trouvent. Dans tous les fichiers (code, tests et main.py), y compris pour les imports écrits à l’intérieur de certaines méthodes de test_partie.py, remplacez par exemple :

   from carte import Carte
   from quartier import Quartier, Couleur

   par :

   from citadelles.carte import Carte
   from citadelles.quartier import Quartier, Couleur

4. Relancez le programme et les tests, toujours depuis la racine du projet. Le programme se lance comme avant (python main.py). Pour les tests, il faut maintenant indiquer le dossier dans lequel les chercher :

   ​

   Windows (Batch) Windows (PowerShell) Linux (Bash) MacOS (Zsh)

   python -m unittest discover -s tests -v

   python -m unittest discover -s tests -v

   python3 -m unittest discover -s tests -v

   python3 -m unittest discover -s tests -v

   Dans VS Code, relancez Configure Python Tests en sélectionnant cette fois le dossier tests.

Pour aller encore plus loin

Si vous souhaitez prolonger le projet, vous pouvez :

• Ajouter un système de sauvegarde/chargement de partie.
• Créer une interface graphique avec tkinter ou pygame.