chwilowo wyswietlanie datasetu z opisem

.gitignore

@@ -0,0 +1,7 @@
+venv/
+.vscode/
+.ideagit
+.idea
+__pycache__/
+/resources/smieci w kontenerach
+  

README.md

@@ -0,0 +1,3 @@
+**Credits**
+
+- Do projektu użyliśmy zdjęć z [tego](https://github.com/garythung/trashnet) repozytorium.

astar.py

@@ -0,0 +1,58 @@
+import heapq
+
+
+def heurystyka(a, b):
+    return abs((b[0] - a[0])) + abs((b[1] - a[1]))
+
+
+def stepcost(obiekty, b):
+    cost = 1
+    if obiekty["plansza"][b[0], b[1]].jestDomem is True:
+        cost += 2
+    if obiekty["plansza"][b[0], b[1]].jestWysypiskiem is True:
+        cost += 1
+    if obiekty["plansza"][b[0], b[1]].jestKontenerem is True:
+        cost += 2
+    return cost
+
+
+def astar(obiekty, start, cel):
+    sasiedzi = [(0, 1), (0, -1), (1, 0), (-1, 0)]
+    close_set = set()
+    came_from = {}
+    hscore = {start: heurystyka(start, cel)}
+    gscore = {start: 0}
+    fscore = {start: heurystyka(start, cel)}
+    fringe = []
+    heapq.heappush(fringe, (fscore[start], start))
+    while fringe:
+        current = heapq.heappop(fringe)[1]
+        if current == cel:
+            data = []
+            while current in came_from:
+                data.append(current)
+                current = came_from[current]
+            return data[::-1]
+        close_set.add(current)
+
+        for i, j in sasiedzi:
+            sasiad = current[0] + i, current[1] + j
+            if 14 < sasiad[0] or sasiad[0] < 0:
+                continue
+            elif 14 < sasiad[1] or sasiad[1] < 0:
+                continue
+            elif 6 <= sasiad[0] <= 7 and 10 <= sasiad[1] <= 11:
+                continue
+
+            tentative_h_score = heurystyka(sasiad, cel) + stepcost(obiekty, sasiad)
+            if sasiad in [i[1] for i in fringe] and tentative_h_score < hscore.get(current, 0):
+                continue
+            elif sasiad not in close_set and sasiad not in [i[1] for i in fringe]:
+                came_from[sasiad] = current
+                hscore[sasiad] = tentative_h_score
+                fscore[sasiad] = tentative_h_score + gscore[current]
+                gscore[sasiad] = gscore[current] + heurystyka(current, sasiad)
+                heapq.heappush(fringe, (fscore[sasiad], sasiad))
+    return False
+
+

environment.md

@@ -0,0 +1,68 @@
+# Sztuczna Inteligencja
+
+**Temat projektu:** Inteligenta Śmieciarka
+
+**Zespół:** Kacper Borkowski, Adam Borowski, Adam Osiowy
+
+---
+
+## 1. Ogólne działanie:
+
+![gif](resources/screenShots/gifProjektu.gif)
+
+---
+
+## 2. Struktura katalogów:
+
+![katalogi](resources/screenShots/strukturaKatalogu.png)
+
+**Resources**:
+
+- _plansza_ - folder zawierający zdjęcia niezbędne do generowania planszy - domy, jezioro, pojemniki, wysypisko,
+- _śmieci_ - zawiera podfoldery z klaysifkacją zdjęć śmieci,
+- _śmieci w kontenerach_ - folder, który będzie zawierał posegregowane już smieci
+
+**Pliki**:
+
+**[game.py](game.py)** - plik zawierający całą funkcjonalność projektu:
+
+- główna pętla programu,
+- tworzenie planszy,
+- tworzenie i usytuowanie obiektów z katalogu [modeli](modele.py),
+- generowanie tekstowej interpretacji zebranej wiedzy
+
+**[main.py](main.py)** - klasa odpowiedzialna za uruchomienie programu
+
+**[modele.py](modele.py)** - zawiera klasy aplikacji
+
+**[requirements.txt](requirements.txt)** - posiada biblioteki niezbędne do uruchomienia programu, które instalujemy za pomocą poniższego polecenia:
+
+```
+pip install -r requirements.txt
+```
+
+---
+
+## 3. Opis funkcjonalności programu:
+
+* śmieciarka porusza się w losowy sposób po planszy 15 x 15 (koloruje na niebiesko przebytą trasę)
+![ruch śmieciarki](resources/screenShots/randMove.png)
+* domy generowane są losowo na mapie z pominięciem kolizji z innymi obiektami
+![generowanie_domów](resources/screenShots/wspolrzedneDomow.png)
+* pozycja wysypiska, przeszkody (jeziorko) i kontenerów jest statyczna
+![statyczna_pozycja](resources/screenShots/statycznaPozycja.png)
+* w kontenerach przechowywane będą posegregowane, odpowiednio według kategorii, zdjęcia śmieci
+
+* zdjęcia śmieci będą przydzielane w sposób losowy do każdego z domów na planszy
+![losowanie_śmieci](resources/screenShots/wyborSmieci.png)
+* śmieciarka zbiera śmieci po najechaniu na pozycję danego domu
+
+* po każdym uruchomieniu programu tworzona jest struktura katalogów dla posegregowanych śmieci
+![tworzenie_struktury](resources/screenShots/tworzenieStrukturyKatalogow.png)
+* śmieciarka sprawdza w każdym ruchu czy nie dojdzie do kolizji z innym obiektem lub nie wyjedzie poza planszę
+![sprawdzanie_kolizcji](resources/screenShots/sprawdzanieKolizji.png)
+* po prawej stronie wypisywane są aktualne, najważniejsze informacje
+![wiedza](resources/screenShots/wiedzaPoPrawejStronie.png)
+* każdy obiekt na planszy posiada atrybuty odpowiedzalne za 
+przechowywanie wiedzy o danym obiekcie np.: obiekt śmieciarka przechowuje informacje o odwiedzonych domach
+![atrybuty](resources/screenShots/atrybutySmieciarki.png)

game.py

@@ -0,0 +1,332 @@
+import pygame
+import modele
+import numpy as np
+import random
+import os
+import shutil
+import astar
+import uczenie_kacper as kacper
+import uczenie_adamO as adamO
+import uczenie_adamB as adamB
+
+
+smieci_path = ''
+smieci_w_kontenerach = "resources/smieci w kontenerach"
+
+# PODAJ OSOBE PRZED URUCHOMIENIEM (kacper/adamB/adamO)
+osoba = 'kacper'
+rfc = None
+
+if osoba == 'kacper':
+    smieci_path = 'resources/smieci'
+elif osoba == 'adamB':
+    smieci_path = 'resources/smieci_stare'
+else:
+    smieci_path = 'resources/smieci_stare'
+    rfc = adamO.rozpocznijUczenie()
+
+pygame.init()
+
+# kolory
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+GREEN = (0, 255, 0)
+RED = (255, 0, 0)
+BLUE = (40, 50, 200)
+GREY = (128, 128, 128)
+
+# wysokosc i szerokosc kazdej kratki
+WIDTH = 60
+HEIGHT = 60
+
+# margines pomiedzy kratkami
+MARGIN = 5
+
+# rozmiar kratki
+ILOSC_WIERSZY = 15
+ILOSC_KOLUMN = 15
+
+# rozmiar okna
+WINDOW_SIZE = [1300, 980]
+
+
+# def game():
+#     obiekty = utworzObiekty()
+#     nieodwiedzone_domy = obiekty["wspolrzedne_domow"]
+#     nieodwiedzone_kontenery = [(obiekty["kontener_szklo"].x, obiekty["kontener_szklo"].y),
+#                                (obiekty["kontener_papier"].x,
+#                                 obiekty["kontener_papier"].y),
+#                                (obiekty["kontener_metal"].x,
+#                                 obiekty["kontener_metal"].y),
+#                                (obiekty["kontener_plastik"].x, obiekty["kontener_plastik"].y), ]
+#     # Petla az uzytkownik zamknie program
+#     done = False
+#     clock = pygame.time.Clock()
+
+#     # -------- Glowna petla programu -----------
+#     while not done:
+
+#         # obsluga zdarzen typu nacisniecie klawisza lub przycisku myszy
+#         for event in pygame.event.get():
+#             if event.type == pygame.QUIT:
+#                 done = True
+#             elif event.type == pygame.MOUSEBUTTONDOWN:
+#                 # Zapisywanie pozycji myszki po kliknieciu
+#                 pozycja_myszki = pygame.mouse.get_pos()
+
+#                 # Zamiana pozycji na konkretne koordy
+#                 kolumna = pozycja_myszki[0] // (WIDTH + MARGIN)
+#                 wiersz = pozycja_myszki[1] // (HEIGHT + MARGIN)
+#                 print("Click ", pozycja_myszki,
+#                       "Grid coordinates: ", wiersz, kolumna)
+#             elif event.type == pygame.KEYDOWN:
+#                 if event.key == pygame.K_LEFT:
+#                     obiekty["smieciarka"].w_lewo()
+#                 if event.key == pygame.K_RIGHT:
+#                     # kacper.trainModel()
+#                     obiekty["smieciarka"].w_prawo()
+#                 if event.key == pygame.K_UP:
+#                     obiekty["smieciarka"].w_gore()
+#                 if event.key == pygame.K_DOWN:
+#                     obiekty["smieciarka"].w_dol()
+
+#         rysowaniePlanszy(obiekty)
+#         while nieodwiedzone_domy:
+#             nieodwiedzone_domy.sort(
+#                 key=lambda x: astar.heurystyka((obiekty["smieciarka"].x, obiekty["smieciarka"].y), x))
+#             cel = nieodwiedzone_domy.pop(0)
+#             obiekty["smieciarka"].astar_move(
+#                 obiekty, (obiekty["smieciarka"].x, obiekty["smieciarka"].y), cel)
+#             pozX = cel[0]
+#             pozY = cel[1]
+#             for dom in obiekty["domy"]:
+#                 if dom.x == pozX and dom.y == pozY:
+#                     while dom.smieci:
+#                         smiec = dom.smieci.pop(0)
+
+#                         rodzaj = ""
+#                         if osoba == 'kacper':
+#                             rodzaj = kacper.przewidz(smiec)
+#                         elif osoba == 'adamB':
+#                             pass
+#                         else:
+#                             rodzaj = adamO.przewidz(smiec, rfc)
+
+#                         if rodzaj == "paper":
+#                             obiekty["smieciarka"].dodajPapier(smiec)
+#                         elif rodzaj == "glass":
+#                             obiekty["smieciarka"].dodajSzklo(smiec)
+#                         elif rodzaj == "metal":
+#                             obiekty["smieciarka"].dodajMetal(smiec)
+#                         elif rodzaj == "plastic":
+#                             obiekty["smieciarka"].dodajPlastik(smiec)
+
+#         while nieodwiedzone_kontenery:
+#             nieodwiedzone_kontenery.sort(
+#                 key=lambda x: astar.heurystyka((obiekty["smieciarka"].x, obiekty["smieciarka"].y), x))
+#             cel = nieodwiedzone_kontenery.pop(0)
+#             obiekty["smieciarka"].astar_move(
+#                 obiekty, (obiekty["smieciarka"].x, obiekty["smieciarka"].y), cel)
+#             pozX = cel[0]
+#             pozY = cel[1]
+
+#             if obiekty["plansza"][pozX, pozY].obiekt == obiekty["kontener_papier"]:
+#                 while obiekty["smieciarka"].papier:
+#                     smiec = obiekty["smieciarka"].papier.pop(0)
+#                     obiekty["kontener_papier"].dodajSmiec(smiec)
+#             elif obiekty["plansza"][pozX, pozY].obiekt == obiekty["kontener_szklo"]:
+#                 while obiekty["smieciarka"].szklo:
+#                     smiec = obiekty["smieciarka"].szklo.pop(0)
+#                     obiekty["kontener_szklo"].dodajSmiec(smiec)
+#             elif obiekty["plansza"][pozX, pozY].obiekt == obiekty["kontener_metal"]:
+#                 while obiekty["smieciarka"].metal:
+#                     smiec = obiekty["smieciarka"].metal.pop(0)
+#                     obiekty["kontener_metal"].dodajSmiec(smiec)
+#             elif obiekty["plansza"][pozX, pozY].obiekt == obiekty["kontener_plastik"]:
+#                 while obiekty["smieciarka"].plastik:
+#                     smiec = obiekty["smieciarka"].plastik.pop(0)
+#                     obiekty["kontener_plastik"].dodajSmiec(smiec)
+
+#         clock.tick(7)
+#     pygame.quit()
+#     return rfc
+
+
+# def rysowaniePlanszy(obiekty):
+#     obiekty["obraz"].fill(BLACK)
+#     # rysowanie planszy
+#     for i in range(ILOSC_WIERSZY):
+#         for j in range(ILOSC_KOLUMN):
+#             pygame.draw.rect(obiekty["obraz"],
+#                              obiekty["plansza"][i, j].kolor,
+#                              [(MARGIN + WIDTH) * obiekty["plansza"][i, j].pozY + MARGIN,
+#                               (MARGIN + HEIGHT) *
+#                               obiekty["plansza"][i, j].pozX + MARGIN,
+#                               WIDTH,
+#                               HEIGHT])
+
+#     obiekty["obraz"].blit(pygame.image.load(
+#         "resources/plansza/wysypisko.jpg"), (5, 5))
+#     obiekty["obraz"].blit(pygame.image.load(
+#         "resources/plansza/jezioro.png"), (395, 655))
+#     obiekty["plansza"][6, 10].setJestPrzeszkoda(True)
+#     obiekty["plansza"][6, 11].setJestPrzeszkoda(True)
+#     obiekty["plansza"][7, 10].setJestPrzeszkoda(True)
+#     obiekty["plansza"][7, 11].setJestPrzeszkoda(True)
+#     obiekty["sprajty"].draw(obiekty["obraz"])
+#     text_metal, text_papier, text_plastik, text_szklo, text_pozostale, text_odwiedzone_domy = liczSmieci(
+#         obiekty["domy"], obiekty)
+#     obiekty["obraz"].blit(obiekty["text_pozostalo"],
+#                           (1020, 240))
+#     obiekty["obraz"].blit(text_metal, (1020, 280))
+#     obiekty["obraz"].blit(text_plastik, (1020, 320))
+#     obiekty["obraz"].blit(text_szklo, (1020, 360))
+#     obiekty["obraz"].blit(text_papier, (1020, 400))
+#     # obiekty["obraz"].blit(text_pozostale, (1020, 440))
+#     obiekty["obraz"].blit(text_odwiedzone_domy, (1020, 480))
+
+#     pygame.display.update()
+
+
+# def utworzObiekty():
+#     # Tworzenie planszy i kratek
+#     plansza = np.array([[modele.Kratka(i, j) for i in range(ILOSC_KOLUMN)]
+#                         for j in range(ILOSC_WIERSZY)])
+#     all_sprites_list = pygame.sprite.Group()
+#     # smieciarka
+#     smieciarka = modele.Smieciarka(10, 10)
+#     plansza[10, 10].setKolor(BLUE)
+#     plansza[10, 10].setObiekt(smieciarka)
+
+#     # tworzenie wyswietlanego okna
+#     os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (0, 30)
+#     obraz = pygame.display.set_mode(WINDOW_SIZE)
+#     smieciarka.setObraz(obraz)
+#     pygame.display.set_caption("Inteligentna śmieciarka")
+
+#     # kontenery
+#     if not os.path.exists(smieci_w_kontenerach):
+#         os.makedirs(smieci_w_kontenerach)
+#     else:
+#         for dir in os.listdir(os.getcwd() + "/" + smieci_w_kontenerach):
+#             files = os.listdir(os.getcwd() + "/" +
+#                                smieci_w_kontenerach + "/" + dir)
+#             for file in files:
+#                 os.remove(os.getcwd() + "/" +
+#                           smieci_w_kontenerach + "/" + dir + "/" + file)
+
+#     kontener_szklo = modele.Kontener(4, 4, "glass")
+#     kontener_szklo.setImage(pygame.image.load(
+#         "resources/plansza/pojemnik_szklo.png"))
+#     plansza[4, 4].setJestKontenerem(True)
+#     plansza[4, 4].setObiekt(kontener_szklo)
+
+#     kontener_metal = modele.Kontener(0, 4, "metal")
+#     kontener_metal.setImage(pygame.image.load(
+#         "resources/plansza/pojemnik_metal.png"))
+#     plansza[0, 4].setJestKontenerem(True)
+#     plansza[0, 4].setObiekt(kontener_metal)
+
+#     kontener_papier = modele.Kontener(4, 0, "paper")
+#     kontener_papier.setImage(pygame.image.load(
+#         "resources/plansza/pojemnik_papier.png"))
+#     plansza[4, 0].setJestKontenerem(True)
+#     plansza[4, 0].setObiekt(kontener_papier)
+
+#     kontener_plastik = modele.Kontener(0, 0, "plastic")
+#     kontener_plastik.setImage(pygame.image.load(
+#         "resources/plansza/pojemnik_plastik.png"))
+#     plansza[0, 0].setJestKontenerem(True)
+#     plansza[0, 0].setObiekt(kontener_plastik)
+
+#     # domy
+#     doms_array = ['resources/plansza/domy/dom1.png', 'resources/plansza/domy/dom2.png',
+#                   'resources/plansza/domy/dom3.png', 'resources/plansza/domy/dom4.png',
+#                   'resources/plansza/domy/dom5.png']
+
+#     domy_lista = pygame.sprite.Group()
+
+#     smieci_lista = [os.path.join(path, filename)
+#                     for path, dirs, files in os.walk(smieci_path)
+#                     for filename in files]
+
+#     # informacje o ilosci smieci w domach
+#     font = pygame.font.SysFont("arial", 20, bold=True)
+#     text_pozostalo = font.render("Pozostało śmieci w domach:", True, WHITE)
+
+#     wspolrzedne_domow = modele.generujWspolrzedneDomow(10)
+#     for i in range(len(wspolrzedne_domow)):
+#         dom = modele.Dom(wspolrzedne_domow[i][0], wspolrzedne_domow[i][1])
+#         dom.setImage(pygame.image.load(random.choice(doms_array)))
+#         plansza[wspolrzedne_domow[i][0],
+#                 wspolrzedne_domow[i][1]].setJestDomem(True)
+#         plansza[wspolrzedne_domow[i][0],
+#                 wspolrzedne_domow[i][1]].setObiekt(dom)
+#         domy_lista.add(dom)
+#         all_sprites_list.add(dom)
+
+#     lista_domow = domy_lista.sprites()
+#     for d in lista_domow:
+#         for j in range(5):
+#             smiec = random.choice(smieci_lista)
+#             d.dodajSmiec(smiec)
+
+#     # ustawienie wysypiska, rozmiar wysypiska 5x5
+#     for i in range(5):
+#         for j in range(5):
+#             plansza[i, j].setJestWysypiskiem(True)
+
+#     all_sprites_list.add(kontener_plastik, kontener_metal, kontener_papier, kontener_szklo,
+#                          smieciarka)
+
+#     obiekty = {
+#         "plansza": plansza,
+#         "smieciarka": smieciarka,
+#         "obraz": obraz,
+#         "kontener_plastik": kontener_plastik,
+#         "kontener_szklo": kontener_szklo,
+#         "kontener_metal": kontener_metal,
+#         "kontener_papier": kontener_papier,
+#         "sprajty": all_sprites_list,
+#         "domy": lista_domow,
+#         "smieci": smieci_lista,
+#         "font": font,
+#         "text_pozostalo": text_pozostalo,
+#         "wspolrzedne_domow": wspolrzedne_domow
+#     }
+#     smieciarka.setObiekty(obiekty)
+#     smieciarka.setPlansza(plansza)
+#     return obiekty
+
+
+# def liczSmieci(domy, obiekty):
+#     ile_metalu = 0
+#     ile_szkla = 0
+#     ile_papieru = 0
+#     ile_plastiku = 0
+#     ile_pozostalych = 0
+#     for d in domy:
+#         for s in d.smieci:
+#             if "metal" in s:
+#                 ile_metalu += 1
+#             elif "paper" in s:
+#                 ile_papieru += 1
+#             elif "plastic" in s:
+#                 ile_plastiku += 1
+#             elif "glass" in s:
+#                 ile_szkla += 1
+
+#     text_metal = obiekty["font"].render(
+#         "Metal: " + str(ile_metalu), True, WHITE)
+#     text_papier = obiekty["font"].render(
+#         "Papier: " + str(ile_papieru), True, WHITE)
+#     text_plastik = obiekty["font"].render(
+#         "Plastik: " + str(ile_plastiku), True, WHITE)
+#     text_szklo = obiekty["font"].render(
+#         "Szkło: " + str(ile_szkla), True, WHITE)
+#     text_pozostale = obiekty["font"].render(
+#         "Pozostałe: " + str(ile_pozostalych), True, WHITE)
+#     text_odwiedzone_domy = obiekty["font"].render(
+#         "Odwiedzone domy: " + str(obiekty["smieciarka"].getOdwiedzoneDomy()), True, WHITE)
+
+#     return text_metal, text_papier, text_plastik, text_szklo, text_pozostale, text_odwiedzone_domy

main.py

@@ -0,0 +1,11 @@
+import game
+import uczenie_adamO
+import uczenie_adamB
+
+
+def main():
+    uczenie_adamB.Siec()
+
+
+if __name__ == '__main__':
+    main()

modele.py

@@ -0,0 +1,286 @@
+import pygame
+import game
+import random
+import os
+import shutil
+import astar
+
+# wysokosc i szerokosc kazdej kratki
+WIDTH = 60
+HEIGHT = 60
+
+# margines pomiedzy kratkami
+MARGIN = 5
+
+# kolory
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+GREEN = (0, 255, 0)
+RED = (255, 0, 0)
+BLUE = (40, 50, 200)
+GREY = (128, 128, 128)
+
+
+class Smieciarka(pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+        self.image = pygame.image.load('resources/plansza/smieciarka.png')
+        self.obraz = None
+        self.ruch = 1
+        self.plastik = []
+        self.szklo = []
+        self.papier = []
+        self.metal = []
+        self.pozostale = []
+        self.odwiedzone_domy = 0
+        self.wspolrzedne_odwiedzonych_domow = []
+        self.plansza = None
+        self.obiekty = None
+        pygame.sprite.Sprite.__init__(self)
+        self.rect = pygame.Rect(self.x * WIDTH + MARGIN * self.x + MARGIN, self.y * HEIGHT + MARGIN * self.y, WIDTH,
+                                HEIGHT)
+
+    def setObraz(self, obraz):
+        self.obraz = obraz
+
+    def rand_move(self):
+        rand_int = random.randint(0, 3)
+        if rand_int == 0:
+            self.w_lewo()
+        elif rand_int == 1:
+            self.w_prawo()
+        elif rand_int == 2:
+            self.w_gore()
+        elif rand_int == 3:
+            self.w_dol()
+
+    def astar_move(self, obiekty, start, cel):
+
+        sciezka = astar.astar(obiekty, start, (cel[0], cel[1]))
+        # print(sciezka)
+        if sciezka:
+            for koord in sciezka:
+                if koord[0] == self.x - 1 and koord[1] == self.y:
+                    self.w_lewo()
+                elif koord[0] == self.x + 1 and koord[1] == self.y:
+                    self.w_prawo()
+                elif koord[0] == self.x and koord[1] + 1 == self.y:
+                    self.w_gore()
+                elif koord[0] == self.x and koord[1] - 1 == self.y:
+                    self.w_dol()
+
+    def w_lewo(self):
+        if self.x > 0:
+            if self.plansza[self.x - 1, self.y].jestPrzeszkoda is not True:
+                if self.plansza[self.x - 1, self.y].jestDomem is True:
+                    if [self.x - 1, self.y] not in self.wspolrzedne_odwiedzonych_domow:
+                        self.wspolrzedne_odwiedzonych_domow.append([self.x - 1, self.y])
+                        self.zwiekszIloscOdwiedzonychDomow()
+                if self.ruch == 2:
+                    self.image = pygame.image.load(
+                        'resources/plansza/smieciarka.png')
+                    self.ruch = 1
+
+                self.plansza[self.x - 1, self.y].setKolor(BLUE)
+                for i in range((WIDTH + MARGIN) // 5):
+                    self.rect.x -= 5
+                    self.obraz.blit(self.image, (self.rect.x, self.rect.y))
+                    game.rysowaniePlanszy(self.obiekty)
+                self.x -= 1
+
+    def w_prawo(self):
+        if self.x < 14:
+            if self.plansza[self.x + 1, self.y].jestPrzeszkoda is not True:
+                if self.plansza[self.x + 1, self.y].jestDomem is True:
+                    if [self.x + 1, self.y] not in self.wspolrzedne_odwiedzonych_domow:
+                        self.wspolrzedne_odwiedzonych_domow.append([self.x + 1, self.y])
+                        self.zwiekszIloscOdwiedzonychDomow()
+                if self.ruch == 1:
+                    self.image = pygame.transform.flip(self.image, True, False)
+                    self.ruch = 2
+
+                self.plansza[self.x + 1, self.y].setKolor(BLUE)
+                for i in range((WIDTH + MARGIN) // 5):
+                    self.rect.x += 5
+                    self.obraz.blit(self.image, (self.rect.x, self.rect.y))
+                    game.rysowaniePlanszy(self.obiekty)
+                self.x += 1
+
+    def w_gore(self):
+        if self.y > 0:
+            if self.plansza[self.x, self.y - 1].jestPrzeszkoda is not True:
+                if self.plansza[self.x, self.y - 1].jestDomem is True:
+                    if [self.x, self.y - 1] not in self.wspolrzedne_odwiedzonych_domow:
+                        self.wspolrzedne_odwiedzonych_domow.append([self.x, self.y - 1])
+                        self.zwiekszIloscOdwiedzonychDomow()
+
+                self.plansza[self.x, self.y - 1].setKolor(BLUE)
+                for i in range((WIDTH + MARGIN) // 5):
+                    self.rect.y -= 5
+                    self.obraz.blit(self.image, (self.rect.x, self.rect.y))
+                    game.rysowaniePlanszy(self.obiekty)
+                self.y -= 1
+
+    def w_dol(self):
+        if self.y < 14:
+            if self.plansza[self.x, self.y + 1].jestPrzeszkoda is not True:
+                if self.plansza[self.x, self.y + 1].jestDomem is True:
+                    if [self.x, self.y + 1] not in self.wspolrzedne_odwiedzonych_domow:
+                        self.wspolrzedne_odwiedzonych_domow.append([self.x, self.y + 1])
+                        self.zwiekszIloscOdwiedzonychDomow()
+
+                self.plansza[self.x, self.y + 1].setKolor(BLUE)
+                for i in range((WIDTH + MARGIN) // 5):
+                    self.rect.y += 5
+                    self.obraz.blit(self.image, (self.rect.x, self.rect.y))
+                    game.rysowaniePlanszy(self.obiekty)
+                self.y += 1
+
+    def dodajPlastik(self, smiec):
+        self.plastik.append(smiec)
+
+    def dodajSzklo(self, smiec):
+        self.szklo.append(smiec)
+
+    def dodajPapier(self, smiec):
+        self.papier.append(smiec)
+
+    def dodajMetal(self, smiec):
+        self.metal.append(smiec)
+
+    def zwiekszIloscOdwiedzonychDomow(self):
+        self.odwiedzone_domy += 1
+
+    def getOdwiedzoneDomy(self):
+        return self.odwiedzone_domy
+
+    def setPlansza(self, plansza):
+        self.plansza = plansza
+
+    def setObiekty(self, obiekty):
+        self.obiekty = obiekty
+
+
+class Dom(pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+        self.pozycja = (self.x, self.y)
+        pygame.sprite.Sprite.__init__(self)
+        self.image = pygame.image.__class__
+        self.rect = pygame.Rect(self.x * WIDTH + MARGIN * self.x + MARGIN, self.y * HEIGHT + MARGIN * self.y + MARGIN,
+                                WIDTH, HEIGHT)
+        self.smieci = []
+
+    def setImage(self, image):
+        self.image = image
+
+    def dodajSmiec(self, smiec):
+        self.smieci.append(smiec)
+
+    def usunSmiec(self, smiec):
+        self.smieci.remove(smiec)
+
+
+class Kontener(pygame.sprite.Sprite):
+    def __init__(self, x, y, typ):
+        self.x = x
+        self.y = y
+        pygame.sprite.Sprite.__init__(self)
+        self.image = pygame.image.__class__
+        self.rect = pygame.Rect(self.x * WIDTH + MARGIN * self.x + MARGIN, self.y * HEIGHT + MARGIN * self.y + MARGIN,
+                                WIDTH, HEIGHT)
+        self.smieci = []
+        self.typ = typ
+
+    def dodajSmiec(self, smiec):
+        self.smieci.append(smiec)
+        shutil.copy(smiec, "resources/smieci w kontenerach/" + self.typ)
+
+    def setImage(self, image):
+        self.image = image
+
+
+class Kratka(pygame.sprite.Sprite):
+    def __init__(self, poz_x, poz_y):
+        self.pozX = poz_x
+        self.pozY = poz_y
+        self.pozycja = (self.pozX, self.pozY)
+        self.rodzic = None
+        self.jestDomem = False
+        self.jestKontenerem = False
+        self.jestWysypiskiem = False
+        self.jestPrzeszkoda = False
+        self.kolor = GREY
+        self.obiekt = None
+        pygame.sprite.Sprite.__init__(self)
+        self.image = pygame.image.__class__
+        self.rect = pygame.Rect(self.pozX * WIDTH + MARGIN * self.pozX + MARGIN,
+                                self.pozY * HEIGHT + MARGIN * self.pozY + MARGIN,
+                                WIDTH, HEIGHT)
+
+    # Sort nodes
+    def __lt__(self, other):
+        return self.f < other.f
+
+    def __repr__(self):
+        return ('{0}'.format(self.pozycja))
+
+    # Compare nodes
+    def __eq__(self, other):
+        return True if self.pozycja == other.pozycja else False
+
+    def setImage(self, image):
+        self.image = image
+
+    def setRodzic(self, rodzic):
+        self.rodzic = rodzic
+
+    def setObiekt(self, obiekt):
+        self.obiekt = obiekt
+
+    def setJestDomem(self, bool):
+        self.jestDomem = bool
+
+    def setJestSmieciarka(self, bool):
+        self.jestSmieciarka = bool
+
+    def setJestPrzeszkoda(self, bool):
+        self.jestPrzeszkoda = bool
+
+    def setJestKontenerem(self, bool):
+        self.jestKontenerem = bool
+
+    def setJestWysypiskiem(self, bool):
+        self.jestWysypiskiem = bool
+
+    def setKolor(self, kolor):
+        self.kolor = kolor
+
+
+def generujWspolrzedneDomow(ilosc_domow):
+    wspolrzedne_domow = []
+
+    r = len(wspolrzedne_domow)
+
+    while r < ilosc_domow:
+        wspolrzedne_domu = []
+        x = random.randrange(15)
+        if x < 5:
+            y = random.randrange(5, 15)
+        else:
+            y = random.randrange(15)
+        wspolrzedne_domu.append(x)
+        wspolrzedne_domu.append(y)
+
+        if 6 <= wspolrzedne_domu[0] <= 7 and 10 <= wspolrzedne_domu[1] <= 11:
+            continue
+
+        if wspolrzedne_domu[0] == 10 and wspolrzedne_domu[1] == 10:
+            continue
+
+        if wspolrzedne_domu not in wspolrzedne_domow:
+            wspolrzedne_domow.append(wspolrzedne_domu)
+            r += 1
+    return wspolrzedne_domow

requirements.txt

@@ -0,0 +1,2 @@
+pygame==1.9.6
+numpy==1.18