adding bfs state search

ekran.py

@@ -32,20 +32,22 @@ def narysuj_regaly():
     regal.Regal(15, 1, 11, 8)
     regal.Regal(16, 1, 11, 9)
 
-def drawGrid():
+
+def narysuj_siatke():
     blockSize = 70  # Set the size of the grid block
     WHITE = (200, 200, 200)
     for x in range(0, EKRAN_SZEROKOSC, blockSize):
         for y in range(0, EKRAN_WYSOKOSC, blockSize):
             rect = pygame.Rect(x, y, blockSize, blockSize)
             pygame.draw.rect(screen, WHITE, rect, 1)
+
+
 def odswiez_ekran(wozek):
     screen.fill((51, 51, 51))  # removes object trail
     screen.blit(miejsce, (430, 400))
-    drawGrid()
+    narysuj_siatke()
     narysuj_regaly()
     wozek.draw()
-    # pygame.draw.rect(screen, (255,0,0),(70,70,10,10))
     pygame.display.flip()
 
 
@@ -55,6 +57,8 @@ def sprawdz_ktory_wiersz(x):
         if x < i:
             return nr_wiersza
         nr_wiersza = nr_wiersza + 1
+
+
 def sprawdz_ktora_kolumna(y):
     nr_kolumny = 0
     for i in range(70, EKRAN_SZEROKOSC + 70, 70):

main.py

@@ -30,12 +30,8 @@ def main():
                     wiersz = ekran.sprawdz_ktory_wiersz(x)
                     kolumna = ekran.sprawdz_ktora_kolumna(y)
                     docelowy_stan = wyszukiwanie.Stan(wiersz*70, kolumna*70, 0)
-                    # print(f'{docelowy_stan.x} + {docelowy_stan.y}')
-                    # wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan)
-                    # wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, wyszukiwanie.Stan(905, 527))
                     wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan)
                     sciezka = wyszukiwanie.znajdz_sciezke(wezel)
-                    # print(sciezka)
                     wozek.przemiesc_wozek_po_sciezce(sciezka)
 
             if event.type == pygame.KEYDOWN:
@@ -66,40 +62,6 @@ def main():
         elif wozek.obecnyStan.x >= 916:
             wozek.obecnyStan.x = 916
 
-        # grid = SearchSpace()
-        # # create start and goal states
-        # start_state = Stan(x=1, y=0, kierunek=0)  # for example
-        # goal_state = Stan(x=12, y=0, kierunek=0)  # for example
-
-        # # Drawing
-        # screen.fill((51, 51, 51))  # removes object trail
-        # screen.blit(miejsce, (430, 400))
-
-        # idRegału, Długość regału podana w kratkach, Współrzędne od których ma być tworzony regał (wiersz,kolumna) - poziomo
-        # Współrzędne od (1,1) do (10,10)
-        # regal.Regal(1, 1, 2, 2)
-        # regal.Regal(2, 1, 2, 3)
-        # regal.Regal(3, 1, 3, 2)
-        # regal.Regal(4, 1, 3, 3)
-        #
-        # regal.Regal(5, 1, 8, 2)
-        # regal.Regal(6, 1, 8, 3)
-        # regal.Regal(7, 1, 9, 2)
-        # regal.Regal(8, 1, 9, 3)
-        #
-        # regal.Regal(9, 1, 2, 8)
-        # regal.Regal(10, 1, 2, 9)
-        # regal.Regal(11, 1, 3, 8)
-        # regal.Regal(12, 1, 3, 9)
-        #
-        # regal.Regal(13, 1, 8, 8)
-        # regal.Regal(14, 1, 8, 9)
-        # regal.Regal(15, 1, 9, 8)
-        # regal.Regal(16, 1, 9, 9)
-
-        # wozek.draw()
-        #
-        # pygame.display.flip()  # updating frames
         ekran.odswiez_ekran(wozek)
 
 

regal.py

@@ -1,12 +1,13 @@
 import pygame
-
+from ekran import screen
 
 
 def obliczPixeleNaPodstawieKratek(wymiar): #Przeliczanie współrzędnych podanych w kratkach na pixele
     i = 1
-    pixele = 100
+    # pixele = 100
+    pixele = 73
     while (i < wymiar):
-        pixele = pixele + 80
+        pixele = pixele + 70
         i = i + 1
     return pixele
 
@@ -29,7 +30,8 @@ class Regal:
         self.kolumna = obliczPixeleNaPodstawieKratek(numerKolumny)
         self.dlugosc = obliczPixeleDlugosciRegalu(self)
 
-        from main import screen
+        # from main import screen
+        # from ekran import screen
 
         if(self.numerRegalu >= 0 and self.numerRegalu <= 4):
             reg = pygame.Surface([self.dlugosc, self.wysokoscRegalu])

wozek.py

@@ -1,9 +1,10 @@
 import pygame
+import ekran
 
-# screen nie działa
 
 class Wozek():
     def __init__(self):
+        self.obecnyStan = None
         self.x = 55
         self.y = 55
         self.x_change = 0
@@ -16,9 +17,7 @@ class Wozek():
         self.__zainicjuj_stan_poczatkowy()
 
     def draw(self):
-        from main import screen
+        ekran.screen.blit(self.image, (self.obecnyStan.x, self.obecnyStan.y))
-       # screen.blit(self.image, (self.x, self.y))
-        screen.blit(self.image, (self.obecnyStan.x, self.obecnyStan.y))
 
     # storage = ["none"] * 10
     storage = []
@@ -49,9 +48,31 @@ class Wozek():
 
     def __zainicjuj_stan_poczatkowy(self):
         from wyszukiwanie import Stan
-        # self.obecnyStan = Stan(55, 55, 3)
+        self.obecnyStan = Stan(70, 70, 1)
-        self.obecnyStan = Stan(0, 0, 3)
 
-    # def ustaw_wozek_w_kierunku(self, kierunek):
+    def przemiesc_wozek_po_sciezce(self, sciezka):
-    # TODO
+        kierunek_poprzedni = self.obecnyStan.kierunek
+        for wezel in sciezka:
+            self.obecnyStan = wezel.stan
+            kierunek_obecny = self.obecnyStan.kierunek
+            self.ustaw_wozek_w_kierunku(kierunek_obecny, kierunek_poprzedni)
+            kierunek_poprzedni = kierunek_obecny
+            ekran.odswiez_ekran(self)
+            pygame.time.wait(500)
+
+    def ustaw_wozek_w_kierunku(self, kierunek_obecny, kierunek_poprzedni):
+            if kierunek_poprzedni < kierunek_obecny:
+                #obrot w lewo
+                if kierunek_poprzedni == 0 and kierunek_obecny == 3:
+                    self.image = pygame.transform.rotate(self.image, 90)
+                # obrot w prawo
+                else:
+                    self.image = pygame.transform.rotate(self.image, -90)
+            elif kierunek_poprzedni > kierunek_obecny:
+                # obrot w prawo
+                if kierunek_poprzedni == 3 and kierunek_obecny == 0:
+                    self.image = pygame.transform.rotate(self.image, -90)
+                # obrot w lewo
+                else:
+                    self.image = pygame.transform.rotate(self.image, 90)
 

wyszukiwanie.py

@@ -17,96 +17,71 @@ class Stan:
 
 
 class Wezel:
-    def __init__(self, stan):
+    def __init__(self, stan, rodzic):
         self.stan = stan
+        self.rodzic = rodzic
 
-
+def nastepnik(wezel, licznik):
-def poprzednik(wezel, search_space):
     # gora -> prawo -> dol -> lewo          | obrot w prawo
     # gora -> lewo -> dol -> prawo          | obrot w lewo
     # 0 gora 1 prawo 2 dol 3 lewo
-    y = wezel.stan.x
+    x = wezel.stan.x
-    x = wezel.stan.y
+    y = wezel.stan.y
-    obrot_w_prawo = Stan(x, y, (wezel.stan.kierunek + 1) % 4)
+    obrot_w_prawo = Wezel(Stan(x, y, (wezel.stan.kierunek + 1) % 4), licznik)
-    # obrot_w_lewo = Stan(x, y, (wezel.stan.kierunek - 1) % 4)
+    obrot_w_lewo = Wezel(Stan(x, y, 3 if wezel.stan.kierunek == 0 else wezel.stan.kierunek - 1), licznik)
-    obrot_w_lewo = Stan(x, y, 3 if wezel.stan.kierunek == 0 else wezel.stan.kierunek - 1)
 
     if wezel.stan.kierunek == 0:
-        y -= 1
+        y -= 70
     elif wezel.stan.kierunek == 1:
-        x += 1
+        x += 70
     elif wezel.stan.kierunek == 2:
-        y += 1
+        y += 70
     elif wezel.stan.kierunek == 3:
-        x -= 1
+        x -= 70
 
     wezly = [obrot_w_prawo, obrot_w_lewo]
-    ruch_w_przod = Stan(x, y, wezel.stan.kierunek)
+    ruch_w_przod = Wezel(Stan(x, y, wezel.stan.kierunek), licznik)
 
     # sprawdzenie czy nie wyjdzie poza plansze
-    if 0 <= x <= 916 and 0 <= y <= 916:
+    if 0 <= x <= 910 and 0 <= y <= 910:
         wezly.append(ruch_w_przod)
 
     return wezly
 
-
+def wyszukiwanie_bfs(stan_poczatkowy, stan_docelowy):
-# def wyszukiwanie_bfs(stan_poczatkowy, stan_docelowy, search_space):
+    pierwszy_wezel = Wezel(stan_poczatkowy, 0)
-#     pierwszy_wezel = Wezel(stan_poczatkowy)
-#     fringe = [pierwszy_wezel]
-#
-#     odwiedzone = []
-#     odwiedzone.append(pierwszy_wezel)
-#     while fringe:
-#         wezel = fringe.pop(0)
-#         if stan_docelowy.x == wezel.stan.x and stan_docelowy.y == wezel.stan.y:
-#             return odwiedzone
-#
-#         # odwiedzone.add(wezel.stan)
-#
-#         for stan in poprzednik(wezel, search_space):
-#             if stan not in odwiedzone:
-#                 nowy_wezel = Wezel(stan)
-#                 fringe.append(nowy_wezel)
-#                 odwiedzone.append(nowy_wezel)
-#                 if stan_docelowy.x == nowy_wezel.stan.x and stan_docelowy.y == nowy_wezel.stan.y:
-#                     return odwiedzone
-#     return odwiedzone
-
-def wyszukiwanie_bfs(stan_poczatkowy, stan_docelowy, search_space):
-    pierwszy_wezel = Wezel(stan_poczatkowy)
     fringe = [pierwszy_wezel]
-    odl_x = 100
+    odwiedzone = [pierwszy_wezel]
-    odl_y = 100
+    licznik = 0
-    # odleglosci = [[odleglosc_x, odleglosc_y]]
+    global mapa
-    odwiedzone = [stan_poczatkowy]
+    mapa = dict()
     while fringe:
         wezel = fringe.pop(0)
-
+        licznik = licznik + 1
+        mapa[licznik] = wezel
         if stan_docelowy.x == wezel.stan.x and stan_docelowy.y == wezel.stan.y:
-            return odwiedzone
+            return wezel
-
+        lista1 = nastepnik(wezel, licznik)
-        # odwiedzone.append(wezel.stan)
+        for obecny_wezel in lista1:
-        for stan in poprzednik(wezel, search_space):
+            flag_juz_odwiedzony = 0
-            flag = 0
+            for odwiedzony_wezel in odwiedzone:
-            for x in odwiedzone:
+                # sprawdzenie czy odwiedzilismy juz ten stan
-                if x.x == stan.x and x.y == stan.y and x.kierunek == stan.kierunek:
+                if odwiedzony_wezel.stan.x == obecny_wezel.stan.x and odwiedzony_wezel.stan.y == obecny_wezel.stan.y\
-                    flag = 1
+                        and odwiedzony_wezel.stan.kierunek == obecny_wezel.stan.kierunek:
+                    flag_juz_odwiedzony = 1
                     break
-            if flag == 1:
+            if flag_juz_odwiedzony == 1:
                 continue
             else:
-                odleglosc_x = abs(stan.x - stan_docelowy.x)
+                fringe.append(obecny_wezel)
-                odleglosc_y = abs(stan.y - stan_docelowy.y)
+                odwiedzone.append(obecny_wezel)
-                if odl_x + odl_y >= odleglosc_x + odleglosc_y:
+    return pierwszy_wezel
-                    odl_x = odleglosc_x
+def znajdz_sciezke(wezel):
-                    odl_y = odleglosc_y
+    sciezka = [wezel]
-                # else:
+    index = wezel.rodzic
-                #                 #     # print("JEST")
+    while index != 0:
-                #                 #     pass
+        wezel = mapa[index]
-
+        sciezka.append(wezel)
-                nowy_wezel = Wezel(stan)
+        index = wezel.rodzic
-                fringe.append(nowy_wezel)
+    sc = list(reversed(sciezka))
-                odwiedzone.append(stan)
+    return sc
-                if stan_docelowy.x == stan.x and stan_docelowy.y == stan.y:
-                    return odwiedzone
-    return odwiedzone