algorytm_genetyczny.py

@@ -1,109 +0,0 @@
-import random
-
-EKRAN_SZEROKOSC = 770
-EKRAN_WYSOKOSC = 770
-blockSize = 70
-LICZBA_REGALOW = 4
-LICZBA_MIEJSC_NA_PACZKE = 1
-LICZBA_SKRZYNEK_NA_LISTY = 1
-
-ROZMIAR_POPULACJI = 100
-LICZBA_GENERACJI = 100
-
-
-def wygeneruj_osobnika(zasieg_wspolrzednych, ilosc_wspolrzednych):
-    osobnik = list()
-    for j in range(ilosc_wspolrzednych):
-        x = random.randint(1, zasieg_wspolrzednych)
-        y = random.randint(1, zasieg_wspolrzednych)
-        e = (x, y)
-        osobnik.append(e)
-    return osobnik
-
-
-def wygeneruj_populacje_poczatkowa(liczebnosc_populacji):
-    populacja = list()
-    zasieg = int((EKRAN_WYSOKOSC / blockSize) - 3)
-    ilosc_wspolrzednych = (LICZBA_REGALOW + LICZBA_MIEJSC_NA_PACZKE + LICZBA_SKRZYNEK_NA_LISTY)
-    for i in range(liczebnosc_populacji):
-        osobnik = wygeneruj_osobnika(zasieg, ilosc_wspolrzednych)
-        while osobnik in populacja:
-            osobnik = wygeneruj_osobnika(zasieg, ilosc_wspolrzednych)
-        populacja.append(osobnik)
-    return populacja
-
-
-def ocena_osobnika(osobnik):
-    ocena = 0
-
-    # Czy koordynaty sie nie powtarzaja
-    if len(osobnik) == len(set(osobnik)):
-        ocena += 10
-    else:
-        ocena -= 10
-
-    # Czy zachowany jest minimalny dystans miedzy koordynatami
-    for i in range(len(osobnik)):
-        for j in range(i + 1, len(osobnik)):
-            x1, y1 = osobnik[i]
-            x2, y2 = osobnik[j]
-            distance = max(abs(x2 - x1), abs(y2 - y1))
-            if distance >= 3:
-                ocena += 10
-            else: 
-                ocena -= 10
-
-    return ocena
-
-def mutacja(osobnik):
-    # mutacja poprzez zamiane randomowej pary koordynatow
-    index_osobnika = random.randint(0, len(osobnik) - 1)
-    x = random.randint(1, (EKRAN_SZEROKOSC / blockSize) - 3)
-    y = random.randint(1, (EKRAN_WYSOKOSC / blockSize) - 3)
-    osobnik[index_osobnika] = (x, y)
-
-def krzyzowanie(rodzic1, rodzic2):
-    # krzyzowanie pomiedzy dwojka rodzicow i tworzenie dziecka
-    dziecko = []
-    for i in range(len(rodzic1)):
-        dziecko.append(rodzic1[i] if random.random() < 0.5 else rodzic2[i])
-    return dziecko
-
-def ewolucja():
-
-    populacja = (wygeneruj_populacje_poczatkowa(ROZMIAR_POPULACJI))
-
-    for i in range(LICZBA_GENERACJI):
-
-        # sortowanie populacji wynikami oceny osobnikow
-        populacja = sorted(populacja, key=lambda x: ocena_osobnika(x), reverse=True)
-
-        # wybranie jedynie najlepszych osobnikow
-        rodzice = populacja[:int(ROZMIAR_POPULACJI * 0.2)]
-
-        # stworz nowa generacje poprzez krzyzowanie i mutacje
-        potomek = rodzice[:]
-        while len(potomek) < ROZMIAR_POPULACJI:
-            rodzic1 = random.choice(rodzice)
-            rodzic2 = random.choice(rodzice)
-            dziecko = krzyzowanie(rodzic1, rodzic2)
-            mutacja(dziecko)
-            potomek.append(dziecko)
-
-        populacja = potomek
-
-    return populacja[0]
-
-def print_board(osobnik):
-    board = [['-' for _ in range(EKRAN_SZEROKOSC // blockSize)] for _ in range(EKRAN_WYSOKOSC // blockSize)]
-
-    for x, y in osobnik:
-        if 0 <= x < EKRAN_SZEROKOSC // blockSize and 0 <= y < EKRAN_WYSOKOSC // blockSize:
-            board[y][x] = 'X'
-
-    for row in board:
-        print(' '.join(row))
-
-# uruchomienie algorytmu genetycznego
-# najlepszy_osobnik = ewolucja()
-# print_board(najlepszy_osobnik)

ekran.py

@@ -109,7 +109,3 @@ def dodaj_na_rampe(p1, p2, l1, l2):
     p2.update_position(plansza.a_pix, plansza.b_pix)
     l1.update_position(plansza.a_pix, plansza.b_pix)
     l2.update_position(plansza.a_pix, plansza.b_pix)
-
-def dodaj_na_rampe_jedno(order):
-    lista_itemow.append(order)
-    order.update_position(plansza.a_pix, plansza.b_pix)

grid.py

@@ -9,9 +9,16 @@ class GridCellType(Enum):
     RACK = 1
     PLACE = 2
 
+# class RackCellType(Enum):
+#     OGROD = 0
+#     NARZEDZIA = 1
+#     KUCHNIA = 2
+#     MOTORYZACJA = 3
+
 
 class SearchGrid:
     grid: Dict[Tuple[int, int], GridCellType] = {}
+    # rack_grid : Dict[Tuple[int, int], GridCellType] = {}
 
     def __init__(self) -> None:
         self._init_grid()
@@ -25,3 +32,5 @@ class SearchGrid:
             self.grid[(c,d)] = GridCellType.RACK
         for e, f in [(plansza.a, plansza.b),(plansza.c, plansza.d)]:
             self.grid[(e,f)] = GridCellType.PLACE
+
+

itemList.py

@@ -1,5 +1,7 @@
 import pygame
 
+# from paczka import Paczka
+
 class listOfItems:
     list = []
     item_group = pygame.sprite.Group()
@@ -11,3 +13,14 @@ class listOfItems:
     def remove(self):
         last_item = self.list.pop()
         self.item_group.remove(last_item)
+
+
+# def zainicjuj_liste_paczek(init_x, init_y):
+#     packageList = listOfPackages()
+#     demo_paczka = Paczka('duzy', 10, any, False, True, False, any, any, any, any, any)
+#     demo_paczka.update_position(init_x, init_y)
+#     packageList.add(demo_paczka)
+#     return packageList
+
+
+

main.py

@@ -1,5 +1,4 @@
 import sys
-import random
 
 import joblib
 import pygame
@@ -20,10 +19,8 @@ pygame.init()
 def main():
     wozek = Wozek()
     pred_list = prediction.prediction_keys()
-    p1 = Paczka('duzy', 12, 'narzedzia', False, True, False,
+    p1 = Paczka('duzy', 12, 'narzedzia', False, True, False, any, any, any, any, any, pred_list[3])
-                any, any, any, any, any, pred_list[3])
+    p2 = Paczka('maly', 1, 'ogród', False, True, False, any, any, any, any, any, pred_list[1])
-    p2 = Paczka('maly', 1, 'ogród', False, True, False,
-                any, any, any, any, any, pred_list[1])
     l1 = Letter(pred_list[0])
     l2 = Letter(pred_list[2])
     ekran.dodaj_na_rampe(p2, l1, p1, l2)
@@ -38,15 +35,58 @@ def main():
                 sys.exit(0)
             if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                 sys.exit(0)
-
             if event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_SPACE:
-                    while len(ekran.lista_itemow) > 0:
-                        wozek_serves_orders(wozek, grid_points, drzewo)
                         
-                if event.key == pygame.K_n:
+                    ## wozek jedzie po itemy
-                    add_another_order(ekran, pred_list)
+                    wiersz = ekran.sprawdz_ktory_wiersz(a_pix)
-                    wozek_serves_orders(wozek, grid_points, drzewo)
+                    kolumna = ekran.sprawdz_ktora_kolumna(b_pix)
+                    docelowy_stan = wyszukiwanie.Stan(wiersz * 70, kolumna * 70, 1)
+                    
+                    #wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan, grid_points)
+                    wezel = wyszukiwanie.wyszukiwanie_a_star(wozek.obecnyStan, docelowy_stan, grid_points)
+                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
+                    wozek.przemiesc_wozek_po_sciezce(sciezka)
+
+                    ## sprawdzenie czy lista itemow nie jest pusta
+                    if ekran.lista_itemow:
+                        if grid_points.grid[(wiersz, kolumna)] is GridCellType.PLACE:   #picks up item
+                            if wozek.ln == 0:
+                                wozek.picks_up_item()
+                                wozek.dynamic_wozek_picture()
+                                                      
+                                przenoszony_item = wozek.storage[-1]
+                                if (prediction.predict_one(przenoszony_item.img_path)=='package'):
+                                ## wozek jedzie odlozyc paczke na regal
+                                    przenoszona_paczka = przenoszony_item
+
+                                    array, reg = przenoszona_paczka.tablica_do_drzewa(przenoszona_paczka.kategoria)
+
+                                    predictions = drzewo.predict([array])
+
+                                    if predictions == 0:
+                                        print('odklada na dolna polke!')
+                                    else:
+                                        print('odklada na gorna polke!')
+
+                                    docelowy_stan = wyszukiwanie.Stan(reg.numerWiersza * 70, reg.numerKolumny * 70, 1)
+                                    wezel = wyszukiwanie.wyszukiwanie_a_star(wozek.obecnyStan, docelowy_stan, grid_points)
+                                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
+                                    wozek.przemiesc_wozek_po_sciezce(sciezka)
+
+                                    if wozek.ln != 0:   # drops package
+                                        wozek.drops_package(przenoszona_paczka, reg, predictions)
+                                        wozek.dynamic_wozek_picture()
+                                else:
+                                #list przenoszony do skrzynki
+                                    docelowy_stan = wyszukiwanie.Stan(plansza.c_pix, plansza.d_pix, 1)
+                                    wezel = wyszukiwanie.wyszukiwanie_a_star(wozek.obecnyStan, docelowy_stan, grid_points)
+                                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
+                                    wozek.przemiesc_wozek_po_sciezce(sciezka)
+
+                                    if wozek.ln != 0:   # drops letter
+                                        wozek.drops_letter(przenoszony_item)
+                                        wozek.dynamic_wozek_picture()
 
 
             if event.type == pygame.MOUSEBUTTONDOWN: 
@@ -57,94 +97,33 @@ def main():
                     wiersz = ekran.sprawdz_ktory_wiersz(x)
                     kolumna = ekran.sprawdz_ktora_kolumna(y)
 
-                    docelowy_stan = wyszukiwanie.Stan(
+                    docelowy_stan = wyszukiwanie.Stan(wiersz * 70, kolumna * 70, 1)
-                        wiersz * 70, kolumna * 70, 1)
                     
-                    # wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan, grid_points)
+                    #wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan, grid_points)
-                    wezel = wyszukiwanie.wyszukiwanie_a_star(
+                    wezel = wyszukiwanie.wyszukiwanie_a_star(wozek.obecnyStan, docelowy_stan, grid_points)
-                        wozek.obecnyStan, docelowy_stan, grid_points)
                     sciezka = wyszukiwanie.znajdz_sciezke(wezel)
                     wozek.przemiesc_wozek_po_sciezce(sciezka)
 
+                    # if grid_points.grid[(wiersz, kolumna)] is GridCellType.PLACE:   #picks up package
+                    #     if wozek.ln == 0:
+                    #         wozek.load_package()
+                    #         wozek.dynamic_wozek_picture
+                    # else:
+                    #     if wozek.ln != 0:   # drops package
+                    #         wozek.drop_package()
+                    #         wozek.dynamic_wozek_picture()
+
+            # if event.type == pygame.KEYDOWN:
+            #     if event.key == pygame.K_SPACE:
+            #         if wozek.ln == 0:
+            #             wozek.load_package()
+            #             wozek.dynamic_wozek_picture()
+            #         else:
+            #             wozek.drop_package()
+            #             wozek.dynamic_wozek_picture()
+
         ekran.odswiez_ekran(wozek)
 
 
-
-
-def wozek_serves_orders(wozek, grid_points, drzewo):
-    # wozek jedzie po itemy
-    wiersz = ekran.sprawdz_ktory_wiersz(a_pix)
-    kolumna = ekran.sprawdz_ktora_kolumna(b_pix)
-    docelowy_stan = wyszukiwanie.Stan(wiersz * 70, kolumna * 70, 1)
-
-    # wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan, grid_points)
-    wezel = wyszukiwanie.wyszukiwanie_a_star(
-        wozek.obecnyStan, docelowy_stan, grid_points)
-    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
-    wozek.przemiesc_wozek_po_sciezce(sciezka)
-
-    # sprawdzenie czy lista itemow nie jest pusta
-    if ekran.lista_itemow:
-        if grid_points.grid[(wiersz, kolumna)] is GridCellType.PLACE:  # picks up item
-            if wozek.ln == 0:
-                wozek.picks_up_item()
-                wozek.dynamic_wozek_picture()
-
-                przenoszony_item = wozek.storage[-1]
-                if (prediction.predict_one(przenoszony_item.img_path) == 'package'):
-                    # wozek jedzie odlozyc paczke na regal
-                    przenoszona_paczka = przenoszony_item
-
-                    array, reg = przenoszona_paczka.tablica_do_drzewa(
-                        przenoszona_paczka.kategoria)
-
-                    predictions = drzewo.predict([array])
-
-                    if predictions == 0:
-                        print('odklada na dolna polke!')
-                    else:
-                        print('odklada na gorna polke!')
-
-                    docelowy_stan = wyszukiwanie.Stan(
-                        reg.numerWiersza * 70, reg.numerKolumny * 70, 1)
-                    wezel = wyszukiwanie.wyszukiwanie_a_star(
-                        wozek.obecnyStan, docelowy_stan, grid_points)
-                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
-                    wozek.przemiesc_wozek_po_sciezce(sciezka)
-
-                    if wozek.ln != 0:   # drops package
-                        wozek.drops_package(
-                            przenoszona_paczka, reg, predictions)
-                        wozek.dynamic_wozek_picture()
-                else:
-                    # list przenoszony do skrzynki
-                    docelowy_stan = wyszukiwanie.Stan(
-                        plansza.c_pix, plansza.d_pix, 1)
-                    wezel = wyszukiwanie.wyszukiwanie_a_star(
-                        wozek.obecnyStan, docelowy_stan, grid_points)
-                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
-                    wozek.przemiesc_wozek_po_sciezce(sciezka)
-
-                    if wozek.ln != 0:   # drops letter
-                        wozek.drops_letter(przenoszony_item)
-                        wozek.dynamic_wozek_picture()
-
-def add_another_order(ekran, pred_list):
-    if random.random() < 0.5:
-        if random.random() < 0.5:
-            order = Paczka('duzy', 12, 'motoryzacja', False, True, False,
-                any, any, any, any, any, pred_list[6])
-        else:
-            order = Paczka('maly', 1, 'kuchnia', False, True, False,
-                any, any, any, any, any, pred_list[7])
-    else:
-        if random.random() < 0.5:
-            order = Letter(pred_list[5])
-        else:
-            order = Letter(pred_list[4])
-    
-    ekran.dodaj_na_rampe_jedno(order)
-        
-
 if __name__ == "__main__":
     main()

plansza.py

@@ -1,4 +1,4 @@
-import algorytm_genetyczny as genetic
+import random
 
 def obliczPixeleNaPodstawieKratek(wymiar): #Przeliczanie współrzędnych podanych w kratkach na pixele
     i = 1
@@ -17,11 +17,45 @@ blockSize = 70
 
 x1, y1, x2, y2, x3, y3, x4, y4 = [None] * 8
 
-najlepszy_osobnik = genetic.ewolucja()
+while True:
-print("Generowana plansza:")
-genetic.print_board(najlepszy_osobnik)
 
-(x1, y1), (x2, y2), (x3, y3), (x4, y4), (a, b), (c, d) = najlepszy_osobnik[:6] 
+    #wspolrzedne regalow
+    x1 = random.randint(1, 3)
+    x2 = random.randint(1, 3)
+    x3 = random.randint(6, 8)
+    x4 = random.randint(6, 8)
+
+    y1 = random.randint(1, 3)
+    y2 = random.randint(6, 8)
+    y3 = random.randint(1, 3)
+    y4 = random.randint(6, 8)
+
+    #wspolrzedne miejsca paczek
+    a = 5
+    b = 5
+
+    #wspolrzedne skrzynki na listy
+    c = 5
+    d = 0
+    
+    #dodane wspolrzedne (0, 0), (4, 4), (4, 6), (6, 4), (6, 6) zeby regaly sie nie stykaly
+    table = [(0, 0), (4, 4), (4, 6), (6, 4), (6, 6),
+              (x1, y1), (x1+1, y1), (x1, y1+1), (x1+1, y1+1),
+              (x2, y2), (x2+1, y2), (x2, y2+1), (x2+1, y2+1),
+              (x3, y3), (x3+1, y3), (x3, y3+1), (x3+1, y3+1),
+              (x4, y4), (x4+1, y4), (x4, y4+1), (x4+1, y4+1)]
+    
+    #sprawdzenie czy jakies wspolrzedne sie pokrywaja
+    if len(table) == len(set(table)):
+        break
+
+coordinates = [(x1, y1), (x2, y2), (x3, y3), (x4, y4)]
+
+#przemieszanie koordynatów w parach
+random.shuffle(coordinates)
+
+#przypisanie przemieszanych wartości do zmiennych
+(x1, y1), (x2, y2), (x3, y3), (x4, y4) = coordinates
 
 x1, x2, x3, x4, y1, y2, y3, y4 = map(int, [x1, x2, x3, x4, y1, y2, y3, y4])
 

regal.py

@@ -4,6 +4,7 @@ MAX_STORAGE = 3
 
 def obliczPixeleNaPodstawieKratek(wymiar): #Przeliczanie współrzędnych podanych w kratkach na pixele
     i = 1
+    # pixele = 100
     pixele = 73
     while (i < wymiar):
         pixele = pixele + 70
@@ -32,6 +33,13 @@ class Regal(pygame.sprite.Sprite):
         self.kolumna = obliczPixeleNaPodstawieKratek(numerKolumny)
         self.dlugosc = obliczPixeleDlugosciRegalu(self)
 
+        package_storage = []
+        shelfs = {                      # here packages are stored 
+            "dolna": package_storage,
+            "gorna": package_storage
+        }
+        
+        
         storage_dolna = []
         storage_gorna = []
 
@@ -82,3 +90,6 @@ class Regal(pygame.sprite.Sprite):
             self.dolna.append(package)
         else:
             self.gorna.append(package)
+    
+    
+

wozek.py

@@ -1,5 +1,6 @@
 import ekran
-import pygame
+import pygame,math
+# from packageList import listOfPackages
 from ekran import lista_itemow
 from letter import Letter
 import plansza
@@ -12,19 +13,40 @@ class Wozek(pygame.sprite.Sprite):
         self.obecnyStan = None
         self.height = 64
         self.width = 64
-        # Credit: Forklift icons created by Smashicons - Flaticon
-        # https://www.flaticon.com/free-icons/forklift
         self.image = pygame.image.load("images/pusty_wozek.png")
         self.rect = self.image.get_rect()
+        # Credit: Forklift icons created by Smashicons - Flaticon
+        # https://www.flaticon.com/free-icons/forklift
         self.__zainicjuj_stan_poczatkowy()
 
     def draw(self):
         ekran.screen.blit(self.image, (self.obecnyStan.x, self.obecnyStan.y))
+        # self.update_position(self.obecnyStan.x, self.obecnyStan.y)
 
+    #storage = ["none"] * 10 
     storage = []
     max_size = 10
     ln = len(storage)
 
+    def add_element(self, element):
+        if self.ln < self.max_size:
+            self.storage.append(element)
+            self.ln=self.ln+1
+        else:
+            print("I'm full!")
+    def remove_element(self):
+        if self.ln > 0:
+            element = self.storage.pop()
+            self.ln=self.ln-1
+            return element
+        else:
+            print("I'm empty!")
+    
+    def update_position(self, x, y):
+        self.obecnyStan.x = x
+        self.obecnyStan.y = y
+        self.rect.topleft = (x, y)
+    
     def dynamic_wozek_picture(self):
         if self.ln == 0:
             self.image = pygame.image.load("images/pusty_wozek.png")
@@ -37,6 +59,37 @@ class Wozek(pygame.sprite.Sprite):
         
         self.rect = self.image.get_rect()
 
+
+    def load_package(self):
+        #for package in listOfPackages.list:
+        # for package in listOfPackages:
+        #     dist = math.sqrt((self.obecnyStan.x - package.x)**2 + (self.obecnyStan.y - package.y)**2)
+        #     if dist <= 50:
+        #         self.add_element(package)
+        #         # listOfPackages.list.pop()
+        #         listOfPackages.pop()
+        package = listOfPackages.pop()
+        dist = math.sqrt((self.obecnyStan.x - package.x)**2 + (self.obecnyStan.y - package.y)**2)
+        if dist <= 50:
+            self.add_element(package)
+                # listOfPackages.list.pop()               
+
+    def load_packages_collision(self):
+        pass
+        # packages_collision = pygame.sprite.spritecollide(self, listOfPackages.package_group, False)
+        # if packages_collision:
+        #     for package in packages_collision:
+        #         self.add_element(package)
+        #         listOfPackages.list.remove(package)       # collision doesn't work, collision always happens
+
+    def drop_package(self):
+        package = self.remove_element()
+        if package is not None:
+            package.x = self.obecnyStan.x
+            package.y = self.obecnyStan.y
+            # listOfPackages.list.append(package)
+            listOfPackages.append(package)
+
     def __zainicjuj_stan_poczatkowy(self):
         from wyszukiwanie import Stan
         self.obecnyStan = Stan(0, 0, 1)