ajout des fichier finaux

bataille/Carte.py

@@ -0,0 +1,19 @@
+class Carte:
+    """Classe"""
+    def __init__(self, valeur, couleur):
+        '''Constructeur de la classe Carte'''
+        self.valeur = valeur
+        self.couleur = couleur
+
+    def compare(self, other):
+        '''Comparaison de deux cartes'''
+        if self.valeur > other.valeur:
+            return 1
+        if self.valeur < other.valeur:
+            return -1
+        else:
+            return 0
+
+    def __str__(self):
+        '''Renvoie une chaine de caractères représentant la carte'''
+        return str(self.valeur) + " de " + self.couleur

bataille/Jeux.py

@@ -0,0 +1,23 @@
+from bataille.Carte import Carte
+from random import shuffle
+
+class Jeux:
+    def __init__(self):
+        """Constructeur de la classe Jeux"""
+        couleurs = ["carreau", "coeur", "pique", "trefle"]
+        valeurs = list(range(2, 15))  # génère une liste de 2 à 14
+        self.paquet = [Carte(valeur, couleur) for valeur in valeurs for couleur in couleurs]
+
+    def distribue(self, File):
+        """Distribution des cartes"""
+        f1 = File()
+        f2 = File()
+        shuffle(self.paquet)
+        for i, carte in enumerate(self.paquet):
+            if i % 2 == 0:
+                f1.enfiler(carte)
+            else:
+                f2.enfiler(carte)
+        return f1, f2
+
+

gui/gui.py

@@ -0,0 +1,143 @@
+import tkinter as tk
+from tkinter import messagebox
+from PIL import Image, ImageTk
+from bataille.Jeux import Jeux
+from structure.File import File_lst
+
+class BatailleGUI:
+    """Interface graphique pour le jeu de bataille"""
+
+
+    def __init__(self, root):
+        """Constructeur de la classe BatailleGUI"""
+        self.root = root
+        self.root.title("Jeu de Bataille")
+
+        # Set background image
+        self.bg_image = Image.open("gui/ressources/tapis.png")
+        self.bg_image = self.bg_image.resize((1000, 700))
+        self.bg_photo = ImageTk.PhotoImage(self.bg_image)
+        self.bg_label = tk.Label(root, image=self.bg_photo)
+        self.bg_label.place(relwidth=1, relheight=1)
+
+        self.jeux = Jeux()
+        self.f1, self.f2 = self.jeux.distribue(File_lst)
+
+        self.total_cartes_label = tk.Label(root, text=f"Total cartes: {len(self.jeux.paquet)}", bg="green", fg="white")
+        self.total_cartes_label.grid(row=0, column=0, columnspan=3)
+
+        self.canvas_joueur1 = tk.Canvas(root, width=200, height=300, bg="green")
+        self.canvas_joueur1.grid(row=2, column=0, padx=20, pady=20)
+
+        self.canvas_joueur2 = tk.Canvas(root, width=200, height=300, bg="green")
+        self.canvas_joueur2.grid(row=2, column=2, padx=20, pady=20)
+
+        self.label_joueur1 = tk.Label(root, text="Joueur 1", bg="green", fg="white")
+        self.label_joueur1.grid(row=3, column=0)
+
+        self.label_joueur2 = tk.Label(root, text="Joueur 2", bg="green", fg="white")
+        self.label_joueur2.grid(row=3, column=2)
+
+        self.bouton_tour = tk.Button(root, text="Jouer un tour", command=self.jouer_tour)
+        self.bouton_tour.grid(row=4, column=1)
+
+        self.bouton_restart = tk.Button(root, text="Redémarrer", command=self.restart_game)
+        self.bouton_restart.grid(row=5, column=1)
+
+        self.bouton_auto = tk.Button(root, text="Défilement auto", command=self.auto_play)
+        self.bouton_auto.grid(row=6, column=0)
+
+        self.bouton_quit_auto = tk.Button(root, text="Quitter auto play", command=self.quit_auto_play)
+        self.bouton_quit_auto.grid(row=6, column=2)
+
+        self.bouton_quit = tk.Button(root, text="Quitter", command=root.quit)
+        self.bouton_quit.grid(row=7, column=1)
+
+        self.auto_playing = False
+
+        self.update_cartes()
+
+    def update_cartes(self):
+        """Met à jour les cartes des joueurs"""
+        self.label_joueur1.config(text=f"Joueur 1: {self.f1.taille()} cartes")
+        self.label_joueur2.config(text=f"Joueur 2: {self.f2.taille()} cartes")
+
+        if not self.f1.est_vide():
+            carte1 = self.f1.tete()
+            img1 = f"gui/ressources/{carte1.valeur}-{carte1.couleur}.png"
+            image1 = Image.open(img1)
+            image1 = image1.resize((200, 300))
+            self.photo1 = ImageTk.PhotoImage(image1)
+            self.canvas_joueur1.create_image(0, 0, anchor=tk.NW, image=self.photo1)
+
+        if not self.f2.est_vide():
+            carte2 = self.f2.tete()
+            img2 = f"gui/ressources/{carte2.valeur}-{carte2.couleur}.png"
+            image2 = Image.open(img2)
+            image2 = image2.resize((200, 300))
+            self.photo2 = ImageTk.PhotoImage(image2)
+            self.canvas_joueur2.create_image(0, 0, anchor=tk.NW, image=self.photo2)
+
+    def jouer_tour(self):
+        """Joue un tour de jeu"""
+        if self.f1.est_vide() or self.f2.est_vide():
+            if self.f1.taille() > self.f2.taille():
+                messagebox.showinfo("Fin de la partie", "Le joueur 1 a gagné!")
+            else:
+                messagebox.showinfo("Fin de la partie", "Le joueur 2 a gagné!")
+            self.restart_game()
+            self.auto_playing = False
+            return
+
+
+        cartes_jouees = []
+
+        while True:
+            if self.f1.est_vide() or self.f2.est_vide():
+                if self.f1.taille() > self.f2.taille():
+                    messagebox.showinfo("Fin de la partie", "Le joueur 1 a gagné!")
+                else:
+                    messagebox.showinfo("Fin de la partie", "Le joueur 2 a gagné!")
+                self.restart_game()
+                self.auto_playing = False
+                return
+
+            carte1 = self.f1.defiler()
+            carte2 = self.f2.defiler()
+            cartes_jouees.extend([carte1, carte2])
+
+            if carte1.valeur > carte2.valeur:
+                # Ajoutez chaque carte une par une
+                for carte in cartes_jouees:
+                    self.f1.enfiler(carte)
+                break
+            elif carte2.valeur > carte1.valeur:
+                # Ajoutez chaque carte une par une
+                for carte in cartes_jouees:
+                    self.f2.enfiler(carte)
+                break
+            else:
+                if self.f1.taille() < 1 or self.f2.taille() < 1:
+                    messagebox.showinfo("Fin de la partie", "Un joueur n'a pas assez de cartes pour continuer!")
+                    return
+                cartes_jouees.extend([self.f1.defiler(), self.f2.defiler()])
+
+        self.update_cartes()
+
+    def restart_game(self):
+        """Redémarre le jeu"""
+        self.jeux = Jeux()
+        self.f1, self.f2 = self.jeux.distribue(File_lst)
+        self.update_cartes()
+
+    def auto_play(self):
+        """Défilement automatique"""
+        self.auto_playing = True
+        while not self.f1.est_vide() and not self.f2.est_vide() and self.auto_playing:
+            self.jouer_tour()
+            self.root.update()
+            self.root.after(300)
+
+    def quit_auto_play(self):
+        """Quitter le défilement automatique"""
+        self.auto_playing = False

main.py

@@ -0,0 +1,7 @@
+import tkinter as tk
+from gui.gui import BatailleGUI
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    app = BatailleGUI(root)
+    root.mainloop()

structure/File.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+class File_lst:
+    """Implémentation d'une file par une liste."""
+    def __init__(self):
+        """Crée une file vide."""
+        self.__file = []
+
+    def est_vide(self):
+        """Indique si la file est vide."""
+        return self.__file == []
+
+    def enfiler(self, valeur):
+        """Enfile l'élément valeur."""
+        self.__file.append(valeur)
+
+    def defiler(self):
+        """Défile la tête de la file et la renvoie."""
+        return self.__file.pop(0)
+
+    def taille(self):
+        """Renvoie la taille de la file."""
+        return len(self.__file)
+
+    def tete(self):
+        """Renvoie la tête de la file (sans la défiler)."""
+        return self.__file[0]
+
+    def __str__(self):
+        s = "tete->"
+        for val in self.__file:
+            s += str(val) + "->"
+        return s + "queue"
+
+
+class Maillon:
+    """Un maillon d'une liste doublement chaînée."""
+    def __init__(self, precedent, valeur, suivant):
+        self.valeur = valeur
+        self.precedent = precedent
+        self.suivant = suivant
+
+    def __str__(self):
+        return str(self.valeur)
+
+
+class File_chaine:
+    """Implémentation d'une file par une liste doublement chaînée."""
+    def __init__(self):
+        """Crée une file vide."""
+        self.__debut = self.__fin = None
+        self.__taille = 0
+
+    def est_vide(self):
+        """Indique si la file est vide."""
+        return self.__taille == 0
+
+    def enfiler(self, valeur):
+        """Enfile l'élément valeur."""
+        maillon = Maillon(self.__fin, valeur, None)
+        if self.est_vide():
+            self.__debut = self.__fin = maillon
+        else:
+            self.__fin.suivant = maillon
+            self.__fin = maillon
+        self.__taille += 1
+
+    def defiler(self):
+        """Défile la tête de la file et la renvoie."""
+        if self.est_vide():
+            raise IndexError("Impossible de défiler une file vide.")
+        valeur = self.__debut.valeur
+        self.__taille -= 1
+        if self.est_vide():
+            self.__debut = self.__fin = None
+        else:
+            self.__debut = self.__debut.suivant
+            self.__debut.precedent = None
+        return valeur
+
+    def taille(self):
+        """Renvoie la taille de la file."""
+        return self.__taille
+
+    def tete(self):
+        """Renvoie la tête de la file (sans la défiler)."""
+        if self.est_vide():
+            raise IndexError("Une file vide n'a pas de tête.")
+        return self.__debut.valeur
+
+    def __str__(self):
+        s = "tete->"
+        maillon = self.__debut
+        while maillon is not None:
+            s += str(maillon) + "->"
+            maillon = maillon.suivant
+        return s + "queue"
+
+
+if __name__ == "__main__":
+    f = File_lst()
+    print(f.est_vide())
+    f.enfiler('A')
+    f.enfiler('B')
+    f.enfiler('C')
+    print(f.est_vide())
+    print(f.tete())
+    print(f)
+    print(f.taille())
+    print(f.defiler())
+    print(f.defiler())
+    print(f.defiler())
+    print(f.est_vide())

structure/Pile.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from listeChaine import ListeChaine
+
+class Pile_lst:
+    """Implémentation d'une pile par une liste."""
+    def __init__(self):
+        """Crée une pile vide."""
+        self.__pile = []
+
+    def est_vide(self):
+        """Indique si la pile est vide."""
+        return self.__pile == []
+
+    def empiler(self, valeur):
+        """Empile la valeur."""
+        self.__pile.append(valeur)
+
+    def depiler(self):
+        """Dépile le sommet de la pile et le renvoie."""
+        return self.__pile.pop()
+
+    def taille(self):
+        """Renvoie la taille de la pile."""
+        return len(self.__pile)
+
+    def sommet(self):
+        """Renvoie le sommet de la pile (sans le dépiler)."""
+        return self.__pile[-1]
+
+    def __str__(self):
+        s = "|"
+        for val in self.__pile:
+            s = str(val) + "->" + s
+        return s
+
+
+class Pile_chaine:
+    """Implémentation d'une pile par une liste chaînée."""
+    def __init__(self):
+        """Crée une pile vide."""
+        self.__pile = ListeChaine()
+        self.__taille = 0
+
+    def est_vide(self):
+        """Indique si la pile est vide."""
+        return self.__taille == 0
+
+    def empiler(self, valeur):
+        """Empile la valeur."""
+        self.__pile.ajoute(valeur)
+        self.__taille += 1
+
+    def depiler(self):
+        """Dépile le sommet de la pile et le renvoie."""
+        if self.est_vide():
+            raise IndexError("Impossible de dépiler une pile vide.")
+        valeur = self.__pile.tete()
+        self.__pile = self.__pile.queue()
+        self.__taille -= 1
+        return valeur
+
+    def taille(self):
+        """Renvoie la taille de la pile."""
+        return self.__taille
+
+    def sommet(self):
+        """Renvoie le sommet de la pile (sans le dépiler)."""
+        if self.est_vide():
+            raise IndexError("Une pile vide n'a pas de sommet.")
+        return self.__pile.tete()
+
+    def __str__(self):
+        return str(self.__pile) + "->|"
+
+
+if __name__ == "__main__":
+    p = Pile_lst()
+    print(p.est_vide())
+    p.empiler('A')
+    p.empiler('B')
+    p.empiler('C')
+    print(p.est_vide())
+    print(p.sommet())
+    print(p)
+    print(p.taille())
+    print(p.depiler())
+    print(p.depiler())
+    print(p.depiler())
+    print(p.est_vide())

structure/listeChaine.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Sep 22 20:44:35 2020
+
+@author: manu
+"""
+
+
+class Maillon:
+    """Un maillon d'une liste chaînée."""
+    def __init__(self, valeur, suivant):
+        self.valeur = valeur
+        self.suivant = suivant
+
+    def __str__(self):
+        """Renvoie une chane de caractères représentant le maillon."""
+        return str(self.valeur)
+
+
+class ListeChaine:
+    """Une liste chaînée."""
+    def __init__(self, tete=None):
+        """Crée une liste vide, ou une liste dont la tete (un maillon)
+        est donnée."""
+        self.__tete = tete
+
+    def est_vide(self):
+        """Indique si la liste est vide."""
+        return self.__tete is None
+
+    def tete(self):
+        """Renvoie la valeur du premier élément de la liste."""
+        if self.est_vide():
+            raise IndexError("La liste vide n'a pas de tête")
+        return self.__tete.valeur
+
+    def queue(self):
+        """Renvoie la queue de la liste."""
+        if self.est_vide():
+            raise IndexError("La liste vide n'a pas de queue")
+        return ListeChaine(self.__tete.suivant)
+
+    def ajoute(self, valeur):
+        """ajoute `valeur` en tête de la liste."""
+        self.__tete = Maillon(valeur, self.__tete)
+
+    def __str__(self):
+        """Renvoie une chaîne de caractères représentant la liste."""
+        maillon = self.__tete
+        s = ''
+        while maillon is not None:
+            s = s + str(maillon.valeur)
+            maillon = maillon.suivant
+            if maillon is not None:
+                s += '->'
+        return s
+
+    def __len__(self):
+        """Renvoie la longueur de la liste."""
+        maillon = self.__tete
+        long = 0
+        while maillon is not None:
+            long = long + 1
+            maillon = maillon.suivant
+        return long
+
+    def __getitem__(self, n):
+        """Renvoie l'élément d'indice n de la liste."""
+        maillon = self.__tete
+        i = 0
+        while i < n and maillon is not None:
+            i = i + 1
+            maillon = maillon.suivant
+        if maillon is None or n < 0:
+            raise IndexError("Indice non valide")
+        return maillon.valeur
+
+    def __add__(self, other):
+        """Renvoie la liste correspondant à la concaténation des 2 listes."""
+        if self.est_vide():
+            return other
+        v = self.tete()
+        q = self.queue()
+        return ListeChaine(Maillon(v, (q + other).__tete))
+
+    def reverse(self):
+        """Renvoie une liste correspondant à la liste renversée."""
+        res = ListeChaine()
+        maillon = self.__tete
+        while maillon is not None:
+            res.ajoute(maillon.valeur)
+            maillon = maillon.suivant
+        return res
+
+
+if __name__ == "__main__":
+    lst = ListeChaine()
+    print(lst.est_vide())
+    lst.ajoute(306)
+    lst.ajoute(42)
+    lst.ajoute(205)
+    print(lst)
+    print(lst.est_vide())
+    print(lst[0])
+    print(lst[1])
+    print(len(lst))
+    lst2 = ListeChaine()
+    lst2.ajoute(18)
+    lst2.ajoute(45)
+    print(lst + lst2)