On considère un jeu dans lequel des cartes sont manipulées. On s'intéresse à l'objet carte à jouer.

1. Justifier que l'on peut définir une classe nommée JeuDeCartesEnMain en précisant deux attributs de cette classe.

2. Proposer des méthodes qui peuvent s'appliquer à cette classe. (Seuls des verbes d'action sur des cartes à jouer sont attendus ici).

3. Proposer deux instances de cette classe.

1. Créer deux personnages nommés :

   • Berenice une femme d'expérience 1254.

   • Bob de genre 'autre' et d'expérience 0.

2. Vérifier la valeur des attributs de Berenice.

1. Modifiez le code suivant pour rendre l'attribut experience privé :

class Personnage:                             
    """
    Un personnage du jeu vidéo              
    """

    def __init__(self, genre, experience=0):  
        self.genre = genre                    
        self.experience = experience          

        

2. Créez un nouveau personnage au choix.

3. Essayez d'accéder directement à son expérience avec la syntaxe : valeur = nom_objet.nom_attribut. Que remarquez-vous ?

1. Écrivez le code précédent (dans un éditeur ou dans un Jupyter).

2. Créez un nouveau personnage Freeda ; vous pouvez lui donner le niveau d'expérience que vous voulez.

3. Obtenez son niveau d'expérience en utilisant le code suivant : Freeda.get_experience(). Retrouvez-vous la valeur que vous aviez saisie ?

1. Écrivez le code précédent (dans un éditeur ou dans un Jupyter).

2. Créez un nouveau personnage Garou ; vous pouvez lui donner le niveau d'expérience que vous voulez.

3. Vérifier son niveau d'expérience en utilisant l'accesseur get_experience().

4. Modifier son niveau d'experience en le mettant à 10, par exemple, en utilisant la syntaxe suivante : Garou.set_experience(10).

5. Vérifier son niveau d'expérience en utilisant la méthode adéquate.

1. Par quel mot-clé débute toute classe ?

2. Voici le début d'un script pour cette classe. De nombreuses méthodes sont incomplètes.

class Carte:                             
    """
    Un jeu de 52 cartes            
    """
            
     def __init__(self, valeur, couleur):       # toujours self pour désigner l'objet auquel s'appliquera cette méthode
    """constructeur de la classe""" 
    # À compléter                               # penser qu'il y a deux attributs
      
    # ensembles des accesseurs
    def get_valeur(self):                       
        # À compléter                           # penser à utiliser un return afin de récupérer la valeur souhaitée
    
    def get_couleur(self):                       
        # À compléter                           # penser à utiliser un return afin de récupérer la valeur souhaitée
 

Complétez le constructeur de la classe en écrivant une ligne pour chaque attribut.

3. Compléter les deux méthodes correspondant aux accesseurs liés à chaque attribut.

4. Testez votre code en construisant une première carte, nommée carte_en_main, qui est une instance de la classe Carte et qui devra être ici le 7 de carreau.

5. Rajouter au code précédent deux mutateurs nommé set_couleur et set_valeur ; ces méthodes ont deux paramètres : self et nouvelle

.

6. On suppose que désormais la carte en main n'est plus le 7 de carreau mais le 10 de cœur. Utiliser les deux mutateurs créés afin de changer les attributs de l'instance carte_en_main.

7. On veut construire une méthode trier_hasard dans la classe Carte ayant pour seul paramètre self qui permet de modifier la couleur et la valeur d'une carte pour simuler le tirage aléatoire d'une carte du jeu.
   Pour cela :

   1. Rajouter en première ligne de code : from random import *.

   2. Voici ci-dessous le début de la méthode trier_hasard à insérer dans la classe Carte :

                   
       def tirer_hasard(self):
           """
           choix au hasard de la couleur et de la valeur
           """
           # pour la couleur
           coul = choice(['carreau', 'coeur', 'pique', 'trefle'])   # choix au hasard d'un élément de la liste
           # ligne à rajouter pour modifier la couleur de la carte (utilisez le mutateur set_couleur())
       

   En utilisant le mutateur set_couleur(), compléter la dernière ligne de la méthode trier_hasard.

   3. On modélise le tirage aléatoire de la valeur par le tirage aléatoire d'un nombre entier entre 1 et 13 où :

      • le 1 correspond à l''As',

      • le 11 correspond au 'Valet',

      • le 12 correspond à la 'Dame',

      • le 13 correspond au 'Roi'.

      On simule le tirage aléatoire grâce à randint(1, 13).
      Voici la suite de cette méthode trier_hasard (à ajouter en dessous des lignes précédentes) :

   
           # pour la valeur
           n = randint(1, 13)   # tirage aléatoire de la valeur
           if n == 1:
               # ligne à rajouter pour modifier la valeur de la carte en 'As' (utilisez le mutateur set_valeur())
           elif n == 11:
               # poursuivre en traitant chaque cas
           

   Compléter la fin de la méthode trier_hasard.

8. Utiliser cette méthode trier_hasard pour modifier carte_en_main. Après chaque nouveau lancer, découvrez la nouvelle valeur et la nouvelle couleur en utilisant les accesseurs,

9. Modifier le code de la méthode trier_hasard afin de remplacer le traitement des différents par des if, elif et else par l'utilisation d'un dictionnaire.

10. Libre à vous de développer davantage ce projet en rajoutant votre propres idées.

Pour lier les deux classes déjà construites, nous allons successivement :

1. Construire la classe Outil à l'intérieur d'un fichier spécifique,

2. Importer cette classe Outil dans un nouveau programme qui correspondra à la classe Personnage précédente modifiée.
   Ce programme correspondra à un nouveau fichier,

3. Créer un programme principal qui importera la seule classe Personnage.
   Ce programme correspondra grosso modo au programme accessible à l'utilisateur.

Voici le détail de ce qui est à faire :

1. Créez un fichier nommée outil.py qui contient le code de la classe Outil. Il vous suffit d'y mettre comme contenu le code obtenu à la fin de l'exercice 8 (cf. lien direct).

2. 1. Créez un nouveau fichier nommé personnage_avec_outil.py.

   2. Y mettre le contenu de la classe Personnage obtenu à la fin de l'exercice 9 (cf. lien direct).

   3. Comme quelques modifications sont nécessaires pour lier les deux classes, afin d'éviter les confusions, renommer la classe comme PersonnageAvecOutil.

   4. Rajouter en deuxième ligne le code suivant :

      
      from outil import *
                              

      Ce code permet d'importer les fonctions présentes dans le fichier outil.py, c'est-à-dire d'utiliser les méthodes de la classe Outil. Désormais, les deux classes sont liées.

3. 1. Créez un fichier main.py. Ce fichier sera le programme que l'utilisateur exécutera directement.

   2. Dans ce fichier main.py, coller le code suivant :

      
      # importation des fonctions présentes dans le fichier personnage_avec_outil.py, c'est-à-dire des méthodes de la classe PersonnageAvecOutil                         
      from personnage_avec_outil import * 
      
      # gestion de l'affichage de la saisie du genre par l'utilisateur
      genre = input("""
                  Saisir la lettre correspondant au genre désiré pour votre personnage :
                      M : si vous voulez une héros de genre masculin,
                      F : si vous voulez une héroïne de genre féminin,
                      A : si vous désirez un personnage sans genre déterminé
                  """)
      
      genre = genre.upper()  # pour s'assurer que la lettre saisie est en majuscule
      
      # Création du nouveau personnage, appelé ici par défaut hero
      if genre == 'F':
          hero = PersonnageAvecOutil('feminin')
      elif genre == 'M':
          hero = PersonnageAvecOutil('masculin')
      elif genre == 'A':
          hero = PersonnageAvecOutil('autre')
      else :
          print("erreur de saisie dans le choix du genre")
      
      # Affichage d'une caractéristique du personnage créé :
      print("Votre personnage a comme niveau d'expérience {}.".format(hero.get_experience()))
                              

      Remarquez que la méthode get_experience() de la classe PersonnageAvecOutil est directement utilisable.
      L'utilisateur peut ainsi utiliser les méthodes sans savoir comment elles ont été écrites.

   3. En exécutant le programme de ce fichier, vous devez voir apparaître dans la console :

      >>> 
      Votre personnage a comme niveau d'expérience 0.                                                    

Maintenant que les deux classes sont liées, il est possible de modifier ou de créer des méthodes.

On veut désormais que tout personnage possède un objet, unique pour simplifier pour l'instant.
Pour cela, on considère que le personnage possède un nouvel attribut, nommé objet, qui correspond à l'outil en main.
On veut désormais que tout personnage nouvellement créé commence avec un seul outil : un simple bâton de marche, de masse 0.5 kg et que l'on peut tenir à une seule main.

1. Pour cela, modifiez comme ci-dessous le script de la méthode __init__ de la classe PersonneAvecOutil du fichier personnage_avec_outil.py :

       def __init__(self, genre, experience=0):
           self.genre = genre
           self.__experience = experience
           self.objet = Outil(0, 0.5)    # ligne à rajouter            

   Cette ligne rajoutée fait appel au constructeur de la classe Outil, constructeur importé grâce au code de la première ligne from outil import *.

2. On désire maintenant obtenir un accesseur pour ce nouvel attribut objet. On veut qu'il nous renvoie la masse et le nombre de mains nécessaires à son utilisation.
   Pour le créer dans la classe PersonneAvecOutil (donc dans le fichier fichier personnage_avec_outil.py), il suffit d'utiliser les méthodes déjà existantes dans la classe Outil.

   Le script suivant, qui permet d'obtenir un tel accesseur, est à copier en fin de fichier personnage_avec_outil.py :

   
       # méthode faisant appel à la classe Outil :
       def get_objet(self):
           """accesseur des caractéristiques masse et nombre de mains de l'objet"""
           masse = self.objet.get_masse()
           main = self.objet.get_main()
           return masse, main   
                       

   Notez bien que :

   • les méthodes get_masse() et get_main() sont celles de la classe Outil importée.

   • elles s'appliquent sur l'instance self.objet qui correspond à l'attribut objet du personnage courant (appelé avec le mot-clef self).

3. On désire que lors de la création d'un nouveau personnage, s'affiche le nom de l'objet avec la valeur de ces attributs de masse et de nombre de mains nécessaires.

   Pour cela, il suffit de rajouter les deux lignes suivantes en fin du programme principal (du fichier main.py) :

   
   # Découverte des caractéristiques de l'objet en main du héros ou de l'héroïne :
   print("Vous commencez avec un bâton de marche de masse {} que vous pouvez tenir à {} main.".format(hero.get_objet()[0],hero.get_objet()[1]))
                   

   Notez bien que :

   • bien que la classe Outil ne soit pas directement importée dans la fichier main.py, on peut accéder aux attributs de l'outil.

   • cet accès se fait grâce à l'accesseur nouvellement créé, qui lui est importé de la classe PersonnageAvecOutil grâce à la ligne déjà présente : from personnage_avec_outil import *.

4. Si vous exécutez ce programme main.py, vous verrez s'afficher dans la console :

   >>> 
   Votre personnage a comme niveau d'expérience 0. 
   Vous commencez avec un bâton de marche de masse 0.5 que vous pouvez tenir à 1 main.