depot de 19/04/25

projet_rush_hour/README.md

 
+
+
+mi13
+gantchou koffi
+
 SEMAINE1
 pour commencer
 j'ai ecris quelques lignes de code notamment en deffinissant 2 classes; la classe Cell() qui va 
@@ -15,4 +20,9 @@ Dans le module jeu je vois l'etat du jeu en affichant le plateau contenant des v
 SEMAINE5
 j'ai continué dans la classe Plateau qui a pour but de montrer l'evolution du plateau de jeu 
 tout en definissant une fonction qui verifie si une position est valide  
+j'ai defini une fonction qui permet de depacer un vehicule dans le module jeu ou ily'a aussi la resolution du case tête grace a une file
+j'ai defini un module niveaux ou il y'a une configuration des niveaux qu'il faut resoudre 
+et dans le module configurations on a pour chaque niveau les mouvements qu'il faut pour les resoudre 
+j'ai egalement commencé a definir une interface graphique dans le module graphicalboard
+
 

projet_rush_hour/apqueue.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+"""
+:mod:`apqueue` module
+
+:author: `FIL - Faculté des Sciences et Technologies -
+          Univ. Lille <http://portail.fil.univ-lille1.fr>`_
+
+:date: 2015, september
+:last revision: 2024, March
+
+A module for queue data structure.
+
+:Provides:
+
+* class ApQueue
+
+and methods
+
+* `enqueue`
+* `dequeue`
+* `is_empty`
+"""
+from typing import TypeVar
+T = TypeVar('T')
+
+class ApQueueEmptyError(Exception):
+    """
+    Exception for empty stacks
+    """
+    def __init__(self, msg):
+        self.message = msg
+
+
+class ApQueue():
+    """
+    $$$ ap_queue = ApQueue()
+    $$$ ap_queue.is_empty()
+    True
+    $$$ ap_queue.enqueue(1)
+    $$$ ap_queue.is_empty()
+    False
+    $$$ ap_queue.enqueue(2)
+    $$$ str(ap_queue)
+    '→2|1→'
+    $$$ ap_queue.dequeue()
+    1
+    $$$ ap_queue.dequeue()
+    2
+    $$$ ap_queue.is_empty()
+    True
+    $$e ap_queue.dequeue()
+    ApQueueEmptyError
+    """
+    ARROW = chr(0x2192)
+
+    def __init__(self):
+        """
+
+        build  a new empty queue
+        precondition: none
+        """
+        self.__content = []
+
+    def contains(self, elt : T) -> bool:
+        """ à_remplacer_par_ce_que_fait_la_fonction
+
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        return elt in self.__content
+    
+    def enqueue(self, elt: T):
+        """
+        insert an element at the begining of the queue
+        precondition: none
+        """
+        self.__content.insert(0, elt)
+
+    def dequeue(self) -> T:
+        """
+        return the element on top of self
+        Side effect: self contains an element less
+        precondition: self must be non empty
+        """
+        if len(self.__content) > 0:
+            res = self.__content.pop()
+        else:
+            raise ApQueueEmptyError('empty queue, nothing to dequeue')
+        return res
+
+    def is_empty(self) -> bool:
+        """
+        return:
+          * ``True`` if s is empty
+          * ``False`` otherwise
+        precondition: none
+        """
+        return self.__content == []
+
+    def __str__(self) -> str:
+        """
+        return the string representation of this queue.
+        """
+        return ApQueue.ARROW + \
+            "|".join(str(el) for el in self.__content) + \
+            ApQueue.ARROW
+
+    def __len__(self) -> int:
+        """
+        return the length of this queue
+        """
+        return len(self.__content)
+
+if __name__ == '__main__':
+    import apl1test
+    apl1test.testmod('apqueue.py')
+    
+# import unittest    
+# class TestMathFunctions(unittest.TestCase):
+#     """ à_remplacer_par_ce_que_fait_la_classe
+# 
+#     Exemple(s) :
+#     $$$ 
+#     """
+#     def test___str__(self):
+#         """ à_remplacer_par_ce_que_fait_la_fonction
+# 
+#         Précondition :
+#         Exemple(s) :
+#         $$$
+#         """
+#         self.assertEqual(__str__(self),)
+#     
+

projet_rush_hour/cellule.py

@@ -18,10 +18,16 @@ class Cell():
         self.x = x
         self.y = y
         self.couleur = couleur # permettra de savoir si une cellule est vide ou pas
-        self.vehicule = None
         
     
+    def __eq__(self,other)->bool:
+        """ à_remplacer_par_ce_que_fait_la_fonction
 
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        return self.x == other.x and self.y == other.y and self.couleur == other.couleur
       
      
         

projet_rush_hour/config.py

+
+from vehicule import Vehicule
+# cette classe est tres importante quand on va generer la resolution du casse tête
+class Config():
+    """ la classe Config sert a presnter un vehicule et le mouvement qu'il fera
+
+    Exemple(s) :
+    $$$ co = Config(Vehicule(0,2,2,'vertical','A'),'haut')
+    $$$ co.vehicule
+    Vehicule(0,2,2,'vertical','A')
+    $$$ co.direction
+    'haut'
+    $$$ co
+    Config(Vehicule(0,2,2,'vertical','A'),'haut')
+    $$$ confi = Config('A','bas')
+    $$$ confi == co
+    False
+    $$$ co2 = Config(Vehicule(0,2,2,'vertical','A'),'haut')
+    $$$ co == co2
+    True
+    """
+    def __init__(self,vehicule,direction):
+        """ à_remplacer_par_ce_que_fait_la_fonction
+
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        self.vehicule = vehicule
+        self.direction = direction
+        
+        
+    def __eq__(self,other)->bool:
+        """ à_remplacer_par_ce_que_fait_la_fonction
+
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        if not isinstance(other,Config):
+            return False
+        return (self.vehicule == other.vehicule and self.direction == other.direction)
+    
+    
+    def __repr__(self)->str:
+        """ à_remplacer_par_ce_que_fait_la_fonction
+
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        return f'Config({self.vehicule},{self.direction})'
+        
\ No newline at end of file

projet_rush_hour/configurations.py

+from plateau import Plateau
+from config import Config
+def niveau1()->list[Config]:
+    """ resolution du casse tete de niveau1
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    liste1 = [Config(Vehicule(5,2,3,horizontal,R),gauche),
+              Config(Vehicule(4,4,2,horizontal,C),gauche),
+              Config(Vehicule(4,3,2,horizontal,C),gauche),
+              Config(Vehicule(4,2,2,horizontal,C),gauche),
+              Config(Vehicule(1,3,3,vertical,Q),bas),
+              Config(Vehicule(1,5,3,vertical,O),bas),
+              Config(Vehicule(2,5,3,vertical,O),bas),
+              Config(Vehicule(0,0,2,horizontal,A),droite),
+              Config(Vehicule(1,0,3,vertical,P),haut),
+              Config(Vehicule(4,0,2,vertical,B),haut),
+              Config(Vehicule(5,1,3,horizontal,R),gauche)]
+    return liste1
+        
+def niveau2()->list[Config]:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    liste2 = [Config(Vehicule(4,4,2,horizontal,E),gauche),
+              Config(Vehicule(2,0,2,horizontal,Z),droite),
+              Config(Vehicule(0,3,3,horizontal,O),gauche),
+              Config(Vehicule(0,2,3,horizontal,O),gauche),
+              Config(Vehicule(1,5,3,vertical,P),bas),
+              Config(Vehicule(2,5,3,vertical,P),bas),
+              Config(Vehicule(2,4,2,vertical,C),haut),
+              Config(Vehicule(1,4,2,vertical,C),haut),
+              Config(Vehicule(0,0,2,vertical,A),bas),
+              Config(Vehicule(0,1,3,horizontal,O),gauche)
+              ]
+    return liste2
+        
+def niveau38()->list:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    liste38 = [Config(Vehicule(0,3,3,horizontal,O),gauche),
+               Config(Vehicule(2,5,3,vertical,R),haut),
+               Config(Vehicule(1,5,3,vertical,R),haut),
+               Config(Vehicule(3,3,2,horizontal,E),droite),
+               Config(Vehicule(4,3,2,horizontal,G),droite),
+               Config(Vehicule(1,3,2,vertical,C),bas),
+               Config(Vehicule(2,3,2,vertical,C),bas),
+               Config(Vehicule(1,1,2,horizontal,B),droite),
+               Config(Vehicule(1,2,2,horizontal,B),droite),
+               Config(Vehicule(2,2,2,vertical,D),haut),
+               Config(Vehicule(4,2,2,vertical,F),haut),
+               Config(Vehicule(5,3,3,horizontal,Q),gauche),
+               Config(Vehicule(5,2,3,horizontal,Q),gauche),
+               Config(Vehicule(5,1,3,horizontal,Q),gauche),
+               Config(Vehicule(3,3,2,vertical,C),bas),
+               Config(Vehicule(3,4,2,horizontal,E),gauche),
+               Config(Vehicule(0,5,3,vertical,R),bas),
+               Config(Vehicule(0,2,3,horizontal,O),droite),
+               Config(Vehicule(1,2,2,vertical,D),haut),
+               Config(Vehicule(2,0,2,horizontal,Z),droite),
+               Config(Vehicule(0,0,2,vertical,A),bas),
+               Config(Vehicule(1,0,2,vertical,A),bas),
+               Config(Vehicule(2,0,2,vertical,A),bas),
+               Config(Vehicule(2,1,2,horizontal,Z),gauche),
+               Config(Vehicule(0,2,2,vertical,D),bas),
+               Config(Vehicule(0,3,3,horizontal,O),gauche),
+               Config(Vehicule(1,5,3,vertical,R),haut),
+               Config(Vehicule(3,3,2,horizontal,E),droite),
+               Config(Vehicule(4,3,2,vertical,C),haut),
+               Config(Vehicule(3,3,2,vertical,C),haut),
+               Config(Vehicule(5,0,3,horizontal,Q),droite),
+               Config(Vehicule(5,1,3,horizontal,Q),droite),
+               Config(Vehicule(5,2,3,horizontal,Q),droite),
+               Config(Vehicule(3,0,2,vertical,A),bas),
+               Config(Vehicule(3,2,2,vertical,F),bas),
+               Config(Vehicule(1,2,2,vertical,D),bas),
+               Config(Vehicule(1,3,2,horizontal,B),gauche),
+               Config(Vehicule(1,2,2,horizontal,B),gauche),
+               Config(Vehicule(1,1,2,horizontal,B),gauche),
+               Config(Vehicule(2,2,2,vertical,D),haut),
+               Config(Vehicule(2,3,2,vertical,C),haut),
+               Config(Vehicule(3,4,2,horizontal,E),gauche),
+               Config(Vehicule(3,3,2,horizontal,E),gauche),
+               Config(Vehicule(3,2,2,horizontal,E),gauche),
+               Config(Vehicule(3,1,2,horizontal,E),gauche),
+               Config(Vehicule(1,3,2,vertical,C),bas),
+               Config(Vehicule(1,2,2,vertical,D),bas),
+               Config(Vehicule(1,0,2,horizontal,B),droite),
+               Config(Vehicule(1,1,2,horizontal,B),droite),
+               Config(Vehicule(1,2,2,horizontal,B),droite),
+               Config(Vehicule(2,2,2,vertical,D),haut),
+               Config(Vehicule(3,0,2,horizontal,E),droite),
+               Config(Vehicule(4,0,2,vertical,A),haut),
+               Config(Vehicule(0,5,3,vertical,R),bas),
+               Config(Vehicule(0,2,3,horizontal,O),droite),
+               Config(Vehicule(1,2,2,vertical,D),haut),
+               Config(Vehicule(2,0,2,horizontal,Z),droite),
+               Config(Vehicule(3,0,2,vertical,A),haut),
+               Config(Vehicule(2,0,2,vertical,A),haut),
+               Config(Vehicule(1,0,2,vertical,A),haut),
+               Config(Vehicule(2,1,2,horizontal,Z),gauche),
+               Config(Vehicule(3,1,2,horizontal,E),gauche),
+               Config(Vehicule(4,2,2,vertical,F),haut),
+               Config(Vehicule(3,2,2,vertical,F),haut),
+               Config(Vehicule(5,3,3,horizontal,Q),gauche),
+               Config(Vehicule(4,4,2,horizontal,G),gauche),
+               Config(Vehicule(4,3,2,horizontal,G),gauche),
+               Config(Vehicule(4,2,2,horizontal,G),gauche),
+               Config(Vehicule(4,1,2,horizontal,G),gauche),
+               Config(Vehicule(2,2,2,vertical,F),bas),
+               Config(Vehicule(1,5,3,vertical,R),bas),
+               Config(Vehicule(2,5,3,vertical,R),bas)]
+    return liste38
+
+
+
+def niveau39()->list:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    liste39 = [Config(Vehicule(4,2,2,horizontal,H),droite),
+               Config(Vehicule(5,2,2,horizontal,I),droite),
+               Config(Vehicule(5,3,2,horizontal,I),droite),
+               Config(Vehicule(2,5,3,vertical,R),haut),
+               Config(Vehicule(4,3,2,horizontal,H),droite),
+               Config(Vehicule(2,2,2,vertical,C),bas),
+               Config(Vehicule(3,2,2,vertical,C),bas),
+               Config(Vehicule(3,0,2,horizontal,D),droite),
+               Config(Vehicule(4,0,2,vertical,F),haut),
+               Config(Vehicule(0,2,2,vertical,A),bas),
+               Config(Vehicule(0,3,3,horizontal,O),gauche),
+               Config(Vehicule(1,5,3,vertical,R),haut),
+               Config(Vehicule(3,3,2,horizontal,E),droite),
+               Config(Vehicule(1,3,2,vertical,B),bas),
+               Config(Vehicule(2,3,2,vertical,B),bas),
+               Config(Vehicule(3,3,2,vertical,B),bas),
+               Config(Vehicule(3,4,2,horizontal,E),gauche),
+               Config(Vehicule(0,5,3,vertical,R),bas),
+               Config(Vehicule(0,2,3,horizontal,O),droite),
+               Config(Vehicule(1,2,2,vertical,A),haut),
+               Config(Vehicule(2,0,2,horizontal,Z),droite),
+               Config(Vehicule(2,1,2,horizontal,Z),droite),
+               Config(Vehicule(2,2,2,horizontal,Z),droite),
+               Config(Vehicule(0,2,2,vertical,A),bas),
+               Config(Vehicule(0,3,3,horizontal,O),gauche),
+               Config(Vehicule(1,5,3,vertical,R),haut),
+               Config(Vehicule(3,3,2,horizontal,E),droite),
+               Config(Vehicule(3,0,2,vertical,F),haut),
+               Config(Vehicule(2,0,2,vertical,F),haut),
+               Config(Vehicule(1,0,2,vertical,F),haut),
+               Config(Vehicule(3,1,2,horizontal,D),droite),
+               Config(Vehicule(4,1,2,vertical,G),haut),
+               Config(Vehicule(3,1,2,vertical,G),haut),
+               Config(Vehicule(2,1,2,vertical,G),haut),
+               Config(Vehicule(1,1,2,vertical,G),haut),
+               Config(Vehicule(3,2,2,horizontal,D),gauche),
+               Config(Vehicule(3,1,2,horizontal,D),gauche),
+               Config(Vehicule(3,4,2,horizontal,E),gauche),
+               Config(Vehicule(0,5,3,vertical,R),bas),
+               Config(Vehicule(0,2,3,horizontal,O),droite),
+               Config(Vehicule(1,2,2,vertical,A),haut),
+               Config(Vehicule(2,3,2,horizontal,Z),gauche),
+               Config(Vehicule(2,2,2,horizontal,Z),gauche),
+               Config(Vehicule(2,1,2,horizontal,Z),gauche),
+               Config(Vehicule(0,2,2,vertical,A),bas),
+               Config(Vehicule(0,3,3,horizontal,O),gauche),
+               Config(Vehicule(1,5,3,vertical,R),haut),
+               Config(Vehicule(3,3,2,horizontal,E),droite),
+               Config(Vehicule(4,3,2,vertical,B),haut),
+               Config(Vehicule(3,3,2,vertical,B),haut),
+               Config(Vehicule(2,3,2,vertical,B),haut),
+               Config(Vehicule(3,4,2,horizontal,E),gauche),
+               Config(Vehicule(0,5,3,vertical,R),bas),
+               Config(Vehicule(0,2,3,horizontal,O),droite),
+               Config(Vehicule(1,2,2,vertical,A),haut),
+               Config(Vehicule(4,2,2,vertical,C),haut),
+               Config(Vehicule(3,2,2,vertical,C),haut),
+               Config(Vehicule(4,4,2,horizontal,H),gauche),
+               Config(Vehicule(4,3,2,horizontal,H),gauche),
+               Config(Vehicule(4,2,2,horizontal,H),gauche),
+               Config(Vehicule(4,1,2,horizontal,H),gauche),
+               Config(Vehicule(2,2,2,vertical,C),bas),
+               Config(Vehicule(0,2,2,vertical,A),bas),
+               Config(Vehicule(0,3,3,horizontal,O),gauche),
+               Config(Vehicule(1,5,3,vertical,R),haut),
+               Config(Vehicule(3,3,2,horizontal,E),droite),
+               Config(Vehicule(1,3,2,vertical,B),bas),
+               Config(Vehicule(2,3,2,vertical,B),bas),
+               Config(Vehicule(5,4,2,horizontal,I),gauche),
+               Config(Vehicule(5,3,2,horizontal,I),gauche),
+               Config(Vehicule(5,2,2,horizontal,I),gauche),
+               Config(Vehicule(3,3,2,vertical,B),bas),
+               Config(Vehicule(3,4,2,horizontal,E),gauche),
+               Config(Vehicule(0,5,3,vertical,R),bas),
+               Config(Vehicule(1,5,3,vertical,R),bas),
+               Config(Vehicule(2,5,3,vertical,R),bas),
+               Config(Vehicule(0,2,3,horizontal,O),droite)]
+    return liste39
+
+
+
+def niveau40()->list:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    liste40 = [Config(Vehicule(5,3,2,horizontal,I),droite),
+               Config(Vehicule(3,3,2,vertical,E),bas),
+               Config(Vehicule(3,0,3,horizontal,Q),droite),
+               Config(Vehicule(3,1,3,horizontal,Q),droite),
+               Config(Vehicule(1,5,3,vertical,P),haut),
+               Config(Vehicule(3,2,3,horizontal,Q),droite),
+               Config(Vehicule(4,2,2,vertical,F),haut),
+               Config(Vehicule(5,0,2,horizontal,H),droite),
+               Config(Vehicule(1,1,2,vertical,C),bas),
+               Config(Vehicule(2,1,2,vertical,C),bas),
+               Config(Vehicule(0,0,3,vertical,O),bas),
+               Config(Vehicule(1,0,3,vertical,O),bas),
+               Config(Vehicule(2,0,3,vertical,O),bas),
+               Config(Vehicule(0,1,2,horizontal,A),gauche),
+               Config(Vehicule(1,2,2,vertical,D),haut),
+               Config(Vehicule(2,3,2,horizontal,Z),gauche),
+               Config(Vehicule(2,2,2,horizontal,Z),gauche),
+               Config(Vehicule(2,1,2,horizontal,Z),gauche),
+               Config(Vehicule(0,2,2,vertical,D),bas),
+               Config(Vehicule(0,0,2,horizontal,A),droite),
+               Config(Vehicule(0,1,2,horizontal,A),droite),
+               Config(Vehicule(0,4,2,vertical,B),bas),
+               Config(Vehicule(0,2,2,horizontal,A),droite),
+               Config(Vehicule(1,2,2,vertical,D),haut),
+               Config(Vehicule(2,0,2,horizontal,Z),droite),
+               Config(Vehicule(2,1,2,horizontal,Z),droite),
+               Config(Vehicule(3,0,3,vertical,O),haut),
+               Config(Vehicule(2,0,3,vertical,O),haut),
+               Config(Vehicule(1,0,3,vertical,O),haut),
+               Config(Vehicule(3,1,2,vertical,C),haut),
+               Config(Vehicule(2,1,2,vertical,C),haut),
+               Config(Vehicule(1,1,2,vertical,C),haut),
+               Config(Vehicule(2,2,2,horizontal,Z),gauche),
+               Config(Vehicule(5,1,2,horizontal,H),gauche),
+               Config(Vehicule(3,2,2,vertical,F),bas),
+               Config(Vehicule(3,3,3,horizontal,Q),gauche),
+               Config(Vehicule(3,2,3,horizontal,Q),gauche),
+               Config(Vehicule(3,1,3,horizontal,Q),gauche),
+               Config(Vehicule(0,5,3,vertical,P),bas),
+               Config(Vehicule(0,3,2,horizontal,A),droite),
+               Config(Vehicule(4,3,2,vertical,E),haut),
+               Config(Vehicule(3,3,2,vertical,E),haut),
+               Config(Vehicule(2,3,2,vertical,E),haut),
+               Config(Vehicule(1,3,2,vertical,E),haut),
+               Config(Vehicule(3,0,3,horizontal,Q),droite),
+               Config(Vehicule(3,1,3,horizontal,Q),droite),
+               Config(Vehicule(2,1,2,horizontal,Z),droite),
+               Config(Vehicule(0,1,2,vertical,C),bas),
+               Config(Vehicule(1,1,2,vertical,C),bas),
+               Config(Vehicule(2,1,2,vertical,C),bas),
+               Config(Vehicule(2,2,2,horizontal,Z),gauche),
+               Config(Vehicule(0,3,2,vertical,E),bas),
+               Config(Vehicule(0,4,2,horizontal,A),gauche),
+               Config(Vehicule(1,5,3,vertical,P),haut),
+               Config(Vehicule(3,2,3,horizontal,Q),droite),
+               Config(Vehicule(4,2,2,vertical,F),haut),
+               Config(Vehicule(5,0,2,horizontal,H),droite),
+               Config(Vehicule(0,0,3,vertical,O),bas),
+               Config(Vehicule(1,0,3,vertical,O),bas),
+               Config(Vehicule(2,0,3,vertical,O),bas),
+               Config(Vehicule(2,1,2,horizontal,Z),gauche),
+               Config(Vehicule(0,2,2,vertical,D),bas),
+               Config(Vehicule(0,3,2,horizontal,A),gauche),
+               Config(Vehicule(0,2,2,horizontal,A),gauche),
+               Config(Vehicule(0,1,2,horizontal,A),gauche),
+               Config(Vehicule(1,2,2,vertical,D),haut),
+               Config(Vehicule(2,0,2,horizontal,Z),droite),
+               Config(Vehicule(3,0,3,vertical,O),haut),
+               Config(Vehicule(5,1,2,horizontal,H),gauche),
+               Config(Vehicule(3,2,2,vertical,F),bas),
+               Config(Vehicule(3,3,3,horizontal,Q),gauche),
+               Config(Vehicule(0,5,3,vertical,P),bas),
+               Config(Vehicule(1,3,2,vertical,E),haut),
+               Config(Vehicule(1,4,2,vertical,B),haut),
+               Config(Vehicule(5,4,2,horizontal,I),gauche),
+               Config(Vehicule(4,4,2,horizontal,G),gauche),
+               Config(Vehicule(1,5,3,vertical,P),bas)]
+    return liste40

projet_rush_hour/graphicalboard.py

+
+from vehicule import Vehicule
+from tkinter import *
+fenetre = Tk()
+fenetre.geometry('500x500')
+fenetre.title('rush hour plateau')
+fenetre['bg'] = 'white'
+fenetre.resizable(height= False,width = False)
+
+label = Label(fenetre, text = '')
+label.pack()
+
+
+
+
+
+
+
+
+
+fenetre.mainloop()
\ No newline at end of file

projet_rush_hour/grille.py

-
-from cellule import Cell
-class Grille():
-    """ à_remplacer_par_ce_que_fait_la_classe
-
-    Exemple(s) :
-    $$$ 
-    """
-    def init(self,grille):
-        """ à_remplacer_par_ce_que_fait_la_fonction
-
-        Précondition :
-        Exemple(s) :
-        $$$
-        """
-        self.grille = [[Cell() for _ in range(6)] for _ in range(6)]
\ No newline at end of file

projet_rush_hour/jeu.py

+
+#mi13
+# gantchou koffi
 from cellule import Cell
 from vehicule import Vehicule 
 from plateau import Plateau
-def main():
-    vehicules = []
-    A = Vehicule(0,0,2,'horizontal','A')
-    Z = Vehicule(2,1,2,'horizontal','Z')
-    C = Vehicule(4,3,2,'horizontal','C')
-    R = Vehicule(5,2,3,'horizontal','R')
-    B = Vehicule(2,3,2,'vertical','B')
+from config import Config
+import niveaux
+from apqueue import ApQueue       
+from copy import deepcopy
+  
+def deplacer(plateau,vehicule:Vehicule,mouvement)->Plateau:
+        """ deplacement de l'objet voiture
+
+        Précondition :
+        Exemple(s) :
+        $$$ v1 = Vehicule(2,0,2,'horizontal','Z')
+        $$$ v2 = Vehicule(4,3,2,'horizontal','A')
+        $$$ v3 = Vehicule(0,4,2,'vertical','I')
+        $$$ plateau = Plateau([v1,v2,v3])
+        $$$ v1_deplacer = Vehicule(2,1,2,'horizontal','Z')
+        $$$ deplacer(plateau,v1,'droite')
+        Plateau([v1_deplacer,v2,v3])
+        """
+        vehicule_a_deplacer =  deepcopy(vehicule)   
+        if vehicule_a_deplacer.orientation == 'horizontal':
+            if mouvement == 'gauche':
+                vehicule_a_deplacer.y_deb -= 1
+            elif mouvement == 'droite':
+                vehicule_a_deplacer.y_deb +=  1
+        elif vehicule_a_deplacer.orientation == 'vertical':
+            if mouvement == 'bas':
+                vehicule_a_deplacer.x_deb +=1
+            elif mouvement == 'haut':
+                vehicule_a_deplacer.x_deb -= 1
+        vehicules = deepcopy(plateau.vehicules)
+        vehicules.remove(vehicule)
+        vehicules.append(vehicule_a_deplacer)
+        
+        return Plateau(vehicules)         
         
-    vehicules = [A,Z,C,R,B]
     
+
+def main():
+    vehicules = niveaux.niveau40()# choix du niveau à resoudre qui constitue une liste de vehicules
     plateau = Plateau(vehicules)
-    plateau.affiche_grille()
-    
-    while not(plateau.est_fini()):
-        couleur = input('choisie vehicule a deplacer : ')
-        mouvement =  input ('choisie le mouvement : gauche, droite, haut , bas : ')
-        de_combien = int(input('vous voulez deplacer de combat : '))
-        vehicule = plateau.recherhe_voiture(couleur)
-        if plateau.est_valide(vehicule, mouvement,de_combien):
-            plateau.deplacer(vehicule,mouvement,de_combien)
-           
-        else:
-            print('deplacement invalide')
-        plateau.affiche_grille()
+    queue_plateau = ApQueue() # on initialise une file 
+    queue_plateau.enqueue((plateau,[])) # on ajoute premierement a cette queue le plateau de jeu et une liste de mouvement vide car au depart il n'y a eu aucun mouvement
+    # j'ai mis plateau dans queue parce que si queue plateau ne contenais rien on ne pourra jamais rentrer dans la 1ere boucle while
+    # et cette condition qui sera toujours vrai va causer une boucle while
+    plateau_deja_vus = [plateau] # on initialise plateau_deja_vus a une liste contenant d'abord  plateau car la configuration initiale cad plateau pourrait 
+    cpt = 0
+    while not(queue_plateau.is_empty()):
+        plateau_a_deplacer,mouvement_liste = queue_plateau.dequeue() # on cree le plateau a deplacer et la liste des mouvement
+        mouvements = plateau_a_deplacer.mouvements_possibles()
+        while len(mouvements) != 0:           
+            m = mouvements.pop()
+            
+            cpt+=1
+            print(cpt)
+            
+            plateau_nouveau = deplacer(plateau_a_deplacer,m.vehicule,m.direction)
+            #plateau_nouveau.affiche_grille()
+            if plateau_nouveau.est_fini():
+                print("vous avez gagné",mouvement_liste)
+                return 
+            if plateau_nouveau not in plateau_deja_vus:
+                plateau_deja_vus.append(plateau_nouveau)
+                queue_plateau.enqueue((plateau_nouveau, mouvement_liste + [m]))
                     
 
 if __name__ == "__main__":

projet_rush_hour/niveaux.py

+from vehicule import Vehicule
+
+def niveau1()->list[Vehicule]:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    A = Vehicule(0,0,2,'horizontal','A')
+    Z = Vehicule(2,1,2,'horizontal','Z')
+    C = Vehicule(4,4,2,'horizontal','C')
+    R = Vehicule(5,2,3,'horizontal','R')
+    B = Vehicule(4,0,2,'vertical','B')
+    P = Vehicule(1,0,3,'vertical','P')
+    O = Vehicule(1,5,3,'vertical','O')
+    Q = Vehicule(1,3,3,'vertical','Q')
+    vehicules = [A,Z,C,R,B,P,O,Q]
+    return vehicules
+
+
+def niveau2()->list[Vehicule]:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    A = Vehicule(0,0,2,'vertical','A')
+    C = Vehicule(2,4,2,'vertical','C')
+    B = Vehicule(1,3,2,'vertical','B')
+    P = Vehicule(1,5,3,'vertical','P')
+    D = Vehicule(4,2,2,'vertical','D')
+    Q = Vehicule(3,0,3,'horizontal','Q')
+    O = Vehicule(0,3,3,'horizontal','O')
+    Z = Vehicule(2,0,2,'horizontal','Z')
+    G = Vehicule(5,3,2,'horizontal','G')
+    E = Vehicule(4,4,2,'horizontal','E')
+    F = Vehicule(5,0,2,'horizontal','F')
+    return [A,C,B,P,D,Q,O,Z,G,E,F]
+
+
+def niveau38()->list[Vehicule]:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    A = Vehicule(0,0,2,'vertical','A')
+    C = Vehicule(1,3,2,'vertical','C')
+    F = Vehicule(4,2,2,'vertical','F')
+    D = Vehicule(2,2,2,'vertical','D')
+    R = Vehicule(2,5,3,'vertical','R')
+    Z = Vehicule(2,0,2,'horizontal','Z')
+    B = Vehicule(1,1,2,'horizontal','B')
+    O = Vehicule(0,3,3,'horizontal','O')
+    G = Vehicule(4,3,2,'horizontal','G')
+    E = Vehicule(3,3,2,'horizontal','E')
+    Q = Vehicule(5,3,3,'horizontal','Q')
+    return [A,C,F,D,R,Z,B,O,G,E,Q]
+    
+def niveau39()->list[Vehicule]:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    A = Vehicule(0,2,2,'vertical','A')
+    C = Vehicule(2,2,2,'vertical','C')
+    B = Vehicule(1,3,2,'vertical','B')
+    F = Vehicule(4,0,2,'vertical','F')
+    G = Vehicule(4,1,2,'vertical','G')
+    R = Vehicule(2,5,3,'vertical','R')
+    O = Vehicule(0,3,3,'horizontal','O')
+    Z = Vehicule(2,0,2,'horizontal','Z')
+    D = Vehicule(3,0,2,'horizontal','D')
+    I = Vehicule(5,2,2,'horizontal','I')
+    E = Vehicule(3,3,2,'horizontal','E')
+    H = Vehicule(4,2,2,'horizontal','H')
+    
+    return [A,B,C,F,G,R,O,Z,I,E,H,D]
+    
+    
+    
+def niveau40()->list[Vehicule]:
+    """ à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition :
+    Exemple(s) :
+    $$$
+    """
+    O = Vehicule(0,0,3,'vertical','O')
+    C = Vehicule(1,1,2,'vertical','C')
+    D = Vehicule(1,2,2,'vertical','D')
+    B = Vehicule(0,4,2,'vertical','B')
+    P = Vehicule(1,5,3,'vertical','P')
+    E = Vehicule(3,3,2,'vertical','E')
+    F = Vehicule(4,2,2,'vertical','F')
+    Q = Vehicule(3,0,3,'horizontal','Q')
+    I = Vehicule(5,3,2,'horizontal','I')
+    H = Vehicule(5,0,2,'horizontal','H')
+    Z = Vehicule(2,3,2,'horizontal','Z')
+    G = Vehicule(4,4,2,'horizontal','G')
+    A = Vehicule(0,1,2,'horizontal','A')
+    return [O,C,D,B,P,E,F,Q,I,H,Z,G,A]
+

projet_rush_hour/plateau.py

 from cellule import Cell
 from vehicule import Vehicule
+from config import Config
+from apqueue import ApQueue
+
+
 class Plateau():
-    """ à_remplacer_par_ce_que_fait_la_classe
+    """ la classe occupe du plateau sa mise a jour apres des mouvements qui a pour attribut la liste de vehicule
 
     Exemple(s) :
-    $$$ 
+    $$$ A = Vehicule(0,0,2,'horizontal','A')
+    $$$ Z = Vehicule(2,1,2,'horizontal','Z')
+    $$$ C = Vehicule(4,3,2,'horizontal','C')
+    $$$ R = Vehicule(5,2,3,'horizontal','R')
+    $$$ B = Vehicule(2,3,2,'vertical','B') 
+    $$$ p = Plateau([A,Z,C,R,B])
+    $$$ p.vehicules
+    [A,Z,C,R,B]
+    $$$ p2 = Plateau([B,Z,R,C,A])
+    $$$ p == p2
+    True
+    $$$ E = Vehicule(2,0,2,'vertical','E') 
+    $$$ p3 = Plateau([B,Z,R,C,A,E])
+    $$$ p == p3
+    False
+    $$$ p4 = Plateau([B,Z,R,C])
+    $$$ p4 == p
+    False
     """
     def __init__(self,vehicules:list[Vehicule]):
-        """ à_remplacer_par_ce_que_fait_la_fonction
+        """ construction de la grille de jeu 
 
         Précondition :
         Exemple(s) :
@@ -17,8 +38,19 @@ class Plateau():
         self.grille = [[Cell(x,y,'*') for x in range(6)] for y in range(6)]
         for vehicule in vehicules:
             for cell in vehicule.get_vehicule_cells():
+                if self.grille[cell.x][cell.y].couleur != '*':
+                    raise Exception('configuration invalide')
                 self.grille[cell.x][cell.y] = cell
         
+    def __repr__(self)->str:
+        """ à_remplacer_par_ce_que_fait_la_fonction
+
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        return f'Plateau({self.vehicules})'
+            
     def affiche_grille(self):
         """ à_remplacer_par_ce_que_fait_la_fonction
 
@@ -32,7 +64,30 @@ class Plateau():
                 print(cell.couleur,end = ' ' )
             print('\n')
             
-    def est_valide(self,vehicule:Vehicule,mouvement,de_combien)->bool:
+    def mouvements_possibles(self)-> list[Config]:
+        """ genere les mouvements possible sur le plateau
+            
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        liste = []
+        for  vehicule in  self.vehicules:
+            if vehicule.orientation == 'horizontal':
+                if self.est_valide(vehicule, 'gauche'):
+                    liste.append(Config(vehicule,'gauche'))
+                if self.est_valide(vehicule, 'droite'):
+                    liste.append(Config(vehicule,'droite')) 
+            if vehicule.orientation == 'vertical':
+                if self.est_valide(vehicule, 'bas'):
+                    liste.append(Config(vehicule,'bas'))
+                if self.est_valide(vehicule,'haut'):
+                    liste.append(Config(vehicule,'haut'))
+        return liste
+                                    
+        
+        
+    def est_valide(self,vehicule:Vehicule,mouvement)->bool:
         """ verifier si une position est valide
 
         Précondition :
@@ -43,24 +98,22 @@ class Plateau():
         $$$ R = Vehicule(5,2,3,'horizontal','R')
         $$$ B = Vehicule(2,3,2,'vertical','B') 
         $$$ p = Plateau([A,Z,C,R,B])
-        $$$ p.est_valide(B,'haut',2)
+        $$$ p.est_valide(B,'haut')
         True
-        $$$ p.est_valide(B,'gauche',2)
+        $$$ p.est_valide(B,'gauche')
         False
         """
         
-        # la variable de_combien est saisie par l'utilisateur dans le module jeu et elle est utilisée dans ce cas pour voir si le pas vers lequel l'utilisateur veut aller est possible
-        
         cellules_vehicule = vehicule.get_vehicule_cells()
         if vehicule.orientation == 'horizontal':
             if mouvement == 'gauche':
-                y = cellules_vehicule[0].y - de_combien
+                y = cellules_vehicule[0].y - 1
                 x = cellules_vehicule[0].x
                 if y >= 0 and self.grille[x][y].couleur == '*' :
                     return True
                 return False
             elif mouvement == 'droite':
-                y = cellules_vehicule[-1].y + de_combien
+                y = cellules_vehicule[-1].y + 1
                 x = cellules_vehicule[-1].x
                 if y<=5 and self.grille[x][y].couleur == '*':
                     return True
@@ -68,21 +121,36 @@ class Plateau():
             
         elif vehicule.orientation == 'vertical':
             if mouvement == 'haut':
-                x = cellules_vehicule[0].x - de_combien
+                x = cellules_vehicule[0].x - 1
                 y = cellules_vehicule[0].y
                 if x>=0 and self.grille[x][y].couleur == '*' :
                     return True
                 return False
             elif mouvement == 'bas':
-                x = cellules_vehicule[-1].x + de_combien
+                x = cellules_vehicule[-1].x + 1
                 y = cellules_vehicule[-1].y
-                if x>=0 and self.grille[x][y].couleur == '*' :
+                if x<=5 and self.grille[x][y].couleur == '*' :
                     return True
                 return False
         return False  
     
+    def __eq__(self,other)->bool:
+        """ à_remplacer_par_ce_que_fait_la_fonction
+
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        for i in range(6):
+            for j in range(6):
+                if self.grille[i][j] != other.grille[i][j]:
+                    return False
+        return True
+        
+        
+        
                 
-    def recherhe_voiture(self,couleur)->Vehicule:
+    def recherche_voiture(self,couleur)->Vehicule:
         """ recherche la voiture dans la liste de voitures sur le plateau
 
         Précondition :
@@ -93,9 +161,8 @@ class Plateau():
         $$$ R = Vehicule(5,2,3,'horizontal','R')
         $$$ B = Vehicule(2,3,2,'vertical','B') 
         $$$ p = Plateau([A,Z,C,R,B])
-        $$$ p.recherhe_voiture('A').couleur
-        'A'
-        $$$ p
+        $$$ p.recherche_voiture('A')
+        Vehicule(0,0,2,'horizontal','A')
         
         """
         for  vehicule in self.vehicules:
@@ -104,31 +171,6 @@ class Plateau():
         return None
 
     
-    def deplacer(self,vehicule:Vehicule,mouvement,de_combien):
-        """ deplacement de l'objet voiture
-
-        Précondition :
-        Exemple(s) :
-        $$$ 
-        
-        """
-        # la variable de_combien permet de deplacer le vehicule dans la mesure du possible d'un nombre de pas
-        for cell in vehicule.get_vehicule_cells():
-            self.grille[cell.x][cell.y].couleur = '*' 
-        
-        if vehicule.orientation == 'horizontal':
-            if mouvement == 'gauche':
-                vehicule.y_deb -= de_combien
-            elif mouvement == 'droite':
-                vehicule.y_deb +=  de_combien
-        elif vehicule.orientation == 'vertical':
-            if mouvement == 'bas':
-                vehicule.x_deb +=de_combien
-            elif mouvement == 'haut':
-                vehicule.x_deb -= de_combien 
-        for cell in vehicule.get_vehicule_cells():
-            self.grille[cell.x][cell.y] = cell
-        
     
     def est_fini(self)->bool:
         """ montre quand le jeu se termine
@@ -147,7 +189,7 @@ class Plateau():
         $$$ s.est_fini()
         True
         """
-        vehicule_Z = self.recherhe_voiture('Z')
+        vehicule_Z = self.recherche_voiture('Z')
         for i in range(vehicule_Z.y_deb + vehicule_Z.taille,6):
             if self.grille[2][i].couleur != '*':
                 return False
@@ -157,3 +199,23 @@ class Plateau():
     
                     
 
+                    
+                    
+                    
+                    
+                    
+                        
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+        
\ No newline at end of file

projet_rush_hour/vehicule.py

@@ -3,7 +3,7 @@ from cellule import Cell
 class Vehicule():
 
 
-    """ construit un vehicule qui est une liste de cellule
+    """ construit un vehicule qui est une liste de cellule caracterisé par sa taille orientation x_deb,y_deb,et sa couleur 
     
 
     Exemple(s) :
@@ -18,6 +18,11 @@ class Vehicule():
     'horizontal'
     $$$ v1.couleur
     'Z'
+    $$$ v2 = Vehicule(2,1,2,'horizontal','A')
+    $$$ v1 == v2
+    False
+    $$$ v3 = Vehicule(2,1,2,'horizontal','A')
+    $$$ v3 == v2
     """
     def __init__(self,x_deb,y_deb,taille,orientation,couleur):
         """ à_remplacer_par_ce_que_fait_la_fonction
@@ -59,5 +64,20 @@ class Vehicule():
         Exemple(s) :
         $$$
         """
+        if not isinstance(other,Vehicule):
+            return False
+        if (self.x_deb == other.x_deb and self.y_deb == other.y_deb and self.taille == other.taille and self.orientation == other.orientation and self.couleur == other.couleur):
             return True
+        return False
+    
+    
+    def __repr__(self)->str:
+        """ à_remplacer_par_ce_que_fait_la_fonction
+
+        Précondition :
+        Exemple(s) :
+        $$$
+        """
+        return f'Vehicule({self.x_deb},{self.y_deb},{self.taille},{self.orientation},{self.couleur})'
+