Succ używający akcji i stanów; poprawa bfs - tworzenie ciągu akcji; interpretacja ciągu akcji przez agenta.

.idea/Sztuczna_Inteligencja_Gr16.iml

@@ -4,7 +4,7 @@
     <content url="file://$MODULE_DIR$">
       <excludeFolder url="file://$MODULE_DIR$/venv" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.9 (Sztuczna_Inteligencja_Gr1627_03dodaje)" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.10 (Sztuczna_Inteligencja_Gr16)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
 </module>

.idea/misc.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (Sztuczna_Inteligencja_Gr1627_03dodaje)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (Sztuczna_Inteligencja_Gr16)" project-jdk-type="Python SDK" />
 </project>

agent.py

@@ -1,24 +1,28 @@
 import random
+from collections import deque
 
+from bfs import Stan, Akcja, graphsearch
 from krata import *
 
 
 class Agent:
+    cel: Stan
     bok = BOK_AGENTA1
     bokWPolach = BOK_AGENTA1_W_POLACH
 
-    def __init__(self, Krata, poleStartoweGorne, tekstura):
+    def __init__(self, Krata, poleStartoweGorne: PoleKraty, tekstura):
         self.krata = Krata
         self.poleStartoweGorne = poleStartoweGorne
         self.tekstura = tekstura
         self.okreslPolozenie()
-        self.obierzNowyKierunek()
+        self.obierzLosowyKierunek()
         self.okreslDlugoscDrogi()
         Krata.agent = self
+        self.cel = None
 
     def ruszSie(self):
         if self.droga <= 0:
-            self.obierzNowyKierunek()
+            self.obierzLosowyKierunek()
             self.okreslDlugoscDrogi()
         self.zrobKrokWMoimKierunku()
         self.droga -= 1
@@ -28,10 +32,10 @@ class Agent:
             self.zawroc()
             self.okreslDlugoscDrogi()
 
-    def obierzNowyKierunek(self):
+    def obierzLosowyKierunek(self):
         self.kierunek = Kierunek(random.randint(0, 3))
         if self.maxDlugoscDrogiWMoimKierunku() < 1:
-            self.obierzNowyKierunek()
+            self.obierzLosowyKierunek()
 
     def okreslDlugoscDrogi(self):
         self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
@@ -73,68 +77,108 @@ class Agent:
         return False
 
     def zawroc(self):
-        if self.kierunek == Kierunek.GORA:
+        if self.kierunek == Kierunek.POLNOC:
-            self.kierunek = Kierunek.DOL
+            self.kierunek = Kierunek.POLUDNIE
-        elif self.kierunek == Kierunek.DOL:
+        elif self.kierunek == Kierunek.POLUDNIE:
-            self.kierunek = Kierunek.GORA
+            self.kierunek = Kierunek.POLNOC
-        elif self.kierunek == Kierunek.LEWO:
+        elif self.kierunek == Kierunek.ZACHOD:
-            self.kierunek = Kierunek.PRAWO
+            self.kierunek = Kierunek.WSCHOD
-        elif self.kierunek == Kierunek.PRAWO:
+        elif self.kierunek == Kierunek.WSCHOD:
-            self.kierunek = Kierunek.LEWO
+            self.kierunek = Kierunek.ZACHOD
 
     def maxDlugoscDrogiWMoimKierunku(self):
-        if self.kierunek == Kierunek.GORA:
+        if self.kierunek == Kierunek.POLNOC:
             return self.poleStartoweGorne.wiersz
-        elif self.kierunek == Kierunek.DOL:
+        elif self.kierunek == Kierunek.POLUDNIE:
             return self.krata.liczbaPolPionowo - self.poleKoncoweDolne.wiersz - 1
-        elif self.kierunek == Kierunek.LEWO:
+        elif self.kierunek == Kierunek.ZACHOD:
             return self.poleStartoweGorne.kolumna
-        elif self.kierunek == Kierunek.PRAWO:
+        elif self.kierunek == Kierunek.WSCHOD:
             return self.krata.liczbaPolPoziomo - self.poleKoncoweDolne.kolumna - 1
 
     def zrobKrokWMoimKierunku(self):
-        if self.kierunek == Kierunek.GORA:
+        if self.kierunek == Kierunek.POLNOC:
-            self.idzWGore()
+            self.idzNaPolnoc()
-        elif self.kierunek == Kierunek.DOL:
+        elif self.kierunek == Kierunek.POLUDNIE:
-            self.idzWDol()
+            self.idzNaPoludnie()
-        elif self.kierunek == Kierunek.LEWO:
+        elif self.kierunek == Kierunek.ZACHOD:
-            self.idzWLewo()
+            self.idzNaZachod()
-        elif self.kierunek == Kierunek.PRAWO:
+        elif self.kierunek == Kierunek.WSCHOD:
-            self.idzWPrawo()
+            self.idzNaWschod()
 
     def zrobKrokWOdwrotnymKierunku(self):
-        if self.kierunek == Kierunek.GORA:
+        if self.kierunek == Kierunek.POLNOC:
-            self.idzWDol()
+            self.idzNaPoludnie()
-        elif self.kierunek == Kierunek.DOL:
+        elif self.kierunek == Kierunek.POLUDNIE:
-            self.idzWGore()
+            self.idzNaPolnoc()
-        elif self.kierunek == Kierunek.LEWO:
+        elif self.kierunek == Kierunek.ZACHOD:
-            self.idzWPrawo()
+            self.idzNaWschod()
-        elif self.kierunek == Kierunek.PRAWO:
+        elif self.kierunek == Kierunek.WSCHOD:
-            self.idzWLewo()
+            self.idzNaZachod()
 
-    def idzWGore(self):
+    def idzNaPolnoc(self):
         self.poleStartoweGorne.wiersz -= 1
 
-    def idzWDol(self):
+    def idzNaPoludnie(self):
         self.poleStartoweGorne.wiersz += 1
 
-    def idzWLewo(self):
+    def idzNaZachod(self):
         self.poleStartoweGorne.kolumna -= 1
 
-    def idzWPrawo(self):
+    def idzNaWschod(self):
         self.poleStartoweGorne.kolumna += 1
 
-    def bfs(graph, start, cel):
+    # def bfs(self,graph, start, cel):
-        sciezka = [start]
+    #     sciezka = [start]
-        wierzcholek_sciezka = [start, sciezka]
+    #     wierzcholek_sciezka = [start, sciezka]
-        bfs_kolejka = [wierzcholek_sciezka]
+    #     bfs_kolejka = [wierzcholek_sciezka]
-        odwiedzone = set()
+    #     odwiedzone = set()
-        while bfs_kolejka:
+    #     while bfs_kolejka:
-            aktualne, sciezka = bfs_kolejka.pop(0)
+    #         aktualne, sciezka = bfs_kolejka.pop(0)
-            odwiedzone.add(aktualne)
+    #         odwiedzone.add(aktualne)
-            for neighbor in graph[aktualne]:
+    #         for neighbor in graph[aktualne]:
-                if neighbor not in odwiedzone:
+    #             if neighbor not in odwiedzone:
-                    if neighbor is cel:
+    #                 if neighbor is cel:
-                        return sciezka + [neighbor]
+    #                     return sciezka + [neighbor]
+    #                 else:
+    #                     bfs_kolejka.append([neighbor, sciezka + [neighbor]])
+
+    def idzDoCelu(self, klatkaz):
+        stan_poczatkowy = Stan(self.kierunek, self.poleStartoweGorne)
+        stos_akcji = graphsearch(stan_poczatkowy, self.cel)
+        if stos_akcji == False:
+            print("Nie można dotrzeć.")
         else:
-                        bfs_kolejka.append([neighbor, sciezka + [neighbor]])
+            self.wykonaj_stos_akcji(stos_akcji, klatkaz)
+            print("Dotarłem.")
+
+        self.krata.krata[self.cel.poleStartoweGorne.wiersz][
+            self.cel.poleStartoweGorne.kolumna] = ZawartoscPola.PUSTE  ##chwilowo-przeniesc pozniej
+
+        self.cel = None
+
+    def wykonaj_stos_akcji(self, stos_akcji: deque, klatkaz):
+        while stos_akcji:
+            klatkaz.tick(FPS)
+            self.narysujAgenta()
+            akcja = stos_akcji.pop()
+            print(akcja.name, end=" ")
+            if akcja == Akcja.KROK_W_PRZOD:
+                self.zrobKrokWMoimKierunku()
+                self.okreslPolozenie()
+            elif akcja == Akcja.OBROT_W_LEWO:
+                self.obrocSieWLewo()
+            elif akcja == Akcja.OBROT_W_PRAWO:
+                self.obrocSieWPrawo()
+        print()
+
+    def obrocSieWLewo(self):
+        self.kierunek = self.kierunek.kierunekNaLewo()
+
+    def obrocSieWPrawo(self):
+        self.kierunek = self.kierunek.kierunekNaPrawo()
+
+    def narysujAgenta(self):
+        self.krata.narysujKrate()
+        self.krata.okno.blit(self.tekstura, (self.hitbox.x, self.hitbox.y))
+        pygame.display.update()

bfs.py

@@ -1,45 +1,148 @@
+from collections import deque
+
 from krata import *
 
-def bfs(Krata: Krata, start: PoleKraty, cel: PoleKraty):
-    wierzcholek_sciezka = [["start", start], [["start", start]]]
-    bfs_kolejka = [wierzcholek_sciezka]
-    odwiedzone = set()
-    while bfs_kolejka:
-        elem = bfs_kolejka.pop(0)
-        odwNowe = str(elem[0][1].wiersz) + "/" + str(elem[0][1].kolumna)
-        odwiedzone.add(odwNowe)
-        polaObok = succ(Krata,elem[0][1])
-        for neighbor in polaObok:
-            sciezka = elem[1].copy()
-            sprOdw = str(neighbor[1].wiersz) + "/" + str(neighbor[1].kolumna)
-            if sprOdw not in odwiedzone:
-                if neighbor[1].wiersz == cel.wiersz and neighbor[1].kolumna == cel.kolumna:
-                    sciezka.append(neighbor)
-                    return sciezka
-                else:
-                    sciezka.append([neighbor])
-                    bfs_kolejka.append([neighbor, sciezka])
 
-def succ(Krata: Krata, poleKraty: PoleKraty):
+class Akcja(Enum):
-    polaDostepneObok = list()
+    OBROT_W_LEWO = 0
-    if poleKraty.kolumna - 1 >= 0:  # nie poza kratę
+    OBROT_W_PRAWO = 1
-        if Krata.krata[poleKraty.wiersz][poleKraty.kolumna - 1] != ZawartoscPola.SCIANA:  # nie szafka (szafka to ściana)
+    KROK_W_PRZOD = 2
-            poleLewe = PoleKraty(Krata, poleKraty.wiersz, poleKraty.kolumna - 1)
+
-            naLewo = ["Kierunek.LEWO", poleLewe]
+
-            polaDostepneObok.append(naLewo)
+class Stan:
-    if poleKraty.wiersz - 1 >= 0:  # nie poza kratę
+    def __init__(self, kierunek: Kierunek, poleStartoweGorne: PoleKraty):
-        if Krata.krata[poleKraty.wiersz - 1][poleKraty.kolumna] != ZawartoscPola.SCIANA:
+        self.kierunek = kierunek
-            poleGorne = PoleKraty(Krata, poleKraty.wiersz - 1, poleKraty.kolumna)
+        self.poleStartoweGorne = poleStartoweGorne
-            naGore = ["Kierunek.GORA", poleGorne]
+
-            polaDostepneObok.append(naGore)
+    def skopiuj(self):
-    if poleKraty.kolumna + 1 < LICZBA_POL_W_POZIOMIE:  # nie poza kratę
+        return Stan(self.kierunek, self.poleStartoweGorne.skopiuj())
-        if Krata.krata[poleKraty.wiersz][poleKraty.kolumna + 1] != ZawartoscPola.SCIANA:
+
-            polePrawe = PoleKraty(Krata, poleKraty.wiersz, poleKraty.kolumna + 1)
+
-            naPrawo = ["Kierunek.PRAWO", polePrawe]
+class Nastepnik:
-            polaDostepneObok.append(naPrawo)
+    def __init__(self, akcja: Akcja, stan: Stan, poprzednik):
-    if poleKraty.wiersz + 1 < LICZBA_POL_W_PIONIE:  # nie poza kratę
+        self.akcja = akcja
-        if Krata.krata[poleKraty.wiersz + 1][poleKraty.kolumna] != ZawartoscPola.SCIANA:
+        self.stan = stan
-            poleDolne = PoleKraty(Krata, poleKraty.wiersz + 1, poleKraty.kolumna)
+        self._poprzednik = poprzednik
-            naDol = ["Kierunek.DOL", poleDolne]
+
-            polaDostepneObok.append(naDol)
+    def getPoprzednik(self):
-    return polaDostepneObok
+        return self._poprzednik
+
+    def setPoprzednik(self, x):
+        raise Exception
+
+    poprzednik = property(getPoprzednik, setPoprzednik)
+
+    def skopiuj(self):
+        return Nastepnik(self.akcja, self.stan.skopiuj(), self.poprzednik)
+
+
+def nastepnik_obrotu_w_lewo(nastepnik: Nastepnik):
+    akcja = Akcja.OBROT_W_LEWO
+    stan = Stan(nastepnik.stan.kierunek.kierunekNaLewo(), nastepnik.stan.poleStartoweGorne)
+    return Nastepnik(akcja, stan, nastepnik)
+
+
+def nastepnik_obrotu_w_prawo(nastepnik: Nastepnik):
+    akcja = Akcja.OBROT_W_PRAWO
+    stan = Stan(nastepnik.stan.kierunek.kierunekNaPrawo(), nastepnik.stan.poleStartoweGorne)
+    return Nastepnik(akcja, stan, nastepnik)
+
+
+def nastepnik_kroku_w_przod(nastepnik: Nastepnik):
+    akcja = Akcja.KROK_W_PRZOD
+    stan = Stan(nastepnik.stan.kierunek, nastepnik.stan.poleStartoweGorne)
+    if stan.kierunek == Kierunek.POLNOC:
+        stan.poleStartoweGorne.wiersz -= 1
+    elif stan.kierunek == Kierunek.POLUDNIE:
+        stan.poleStartoweGorne.wiersz += 1
+    elif stan.kierunek == Kierunek.ZACHOD:
+        stan.poleStartoweGorne.kolumna -= 1
+    elif stan.kierunek == Kierunek.WSCHOD:
+        stan.poleStartoweGorne.kolumna += 1
+    return Nastepnik(akcja, stan, nastepnik)
+
+
+def pole_w_granicach_kraty(pole: PoleKraty):
+    if pole.wiersz not in range(0, pole.krata.liczbaPolPionowo):
+        return False
+    elif pole.kolumna not in range(0, pole.krata.liczbaPolPoziomo):
+        return False
+    else:
+        return True
+
+
+def pole_puste(pole: PoleKraty):
+    if pole.krata.krata[pole.wiersz][pole.kolumna] in (ZawartoscPola.PUSTE, ZawartoscPola.CEL):
+        return True
+    else:
+        return False
+
+
+def mozna_zrobic_krok_w_przod(nastepnik: Nastepnik):
+    nastepnik = nastepnik_kroku_w_przod(nastepnik)
+    if pole_w_granicach_kraty(nastepnik.stan.poleStartoweGorne) and pole_puste(nastepnik.stan.poleStartoweGorne):
+        return True
+    else:
+        return False
+
+
+def succ(nastepnik: Nastepnik):
+    wynik = []
+    pom = nastepnik.skopiuj()
+    wynik.append(nastepnik_obrotu_w_lewo(pom))
+    pom = nastepnik.skopiuj()
+    wynik.append(nastepnik_obrotu_w_prawo(pom))
+    pom = nastepnik.skopiuj()
+    if mozna_zrobic_krok_w_przod(pom):
+        pom = nastepnik.skopiuj()
+        wynik.append(nastepnik_kroku_w_przod(pom))
+    return wynik
+
+
+def goaltest(stan: Stan, cel: Stan):
+    if stan.poleStartoweGorne.wiersz != cel.poleStartoweGorne.wiersz:
+        return False
+    elif stan.poleStartoweGorne.kolumna != cel.poleStartoweGorne.kolumna:
+        return False
+    else:
+        return True
+
+
+def stan_w_liscie_nastepnikow(stan: Stan, lista_nastepnikow):
+    for i in lista_nastepnikow:
+        if i.stan.kierunek != stan.kierunek:
+            continue
+        elif i.stan.poleStartoweGorne.wiersz != stan.poleStartoweGorne.wiersz:
+            continue
+        elif i.stan.poleStartoweGorne.kolumna != stan.poleStartoweGorne.kolumna:
+            continue
+        else:
+            return True
+    return False
+
+
+def stos_akcji(stan_koncowy: Nastepnik):
+    stos = deque()
+    while stan_koncowy.poprzednik is not None:
+        stos.append(stan_koncowy.akcja)
+        stan_koncowy = stan_koncowy.poprzednik
+    return stos
+
+
+def graphsearch(istate: Stan, cel: Stan):
+    fringe = deque()
+    explored = []
+    fringe.append(Nastepnik(None, istate, None))
+    while fringe:
+        # for i in fringe:
+        #     print("F",i.stan.kierunek,i.stan.poleStartoweGorne.wiersz,i.stan.poleStartoweGorne.kolumna,end=" ")
+        # print()
+        element: Nastepnik = fringe.popleft()
+        if goaltest(element.stan, cel):
+            return stos_akcji(element)
+        explored.append(element)
+        for nastepnik in succ(element):
+            if not stan_w_liscie_nastepnikow(nastepnik.stan, fringe) and not stan_w_liscie_nastepnikow(nastepnik.stan,
+                                                                                                       explored):
+                fringe.append(nastepnik)
+    return False

enumy_i_slowniki.py

@@ -4,18 +4,40 @@ from stale import *
 
 
 class Kierunek(Enum):
-    GORA = 0
+    POLNOC = 0
-    DOL = 1
+    POLUDNIE = 1
-    LEWO = 2
+    ZACHOD = 2
-    PRAWO = 3
+    WSCHOD = 3
+
+    def kierunekNaLewo(self):
+        if self == Kierunek.POLNOC:
+            return Kierunek.ZACHOD
+        elif self == Kierunek.POLUDNIE:
+            return Kierunek.WSCHOD
+        elif self == Kierunek.ZACHOD:
+            return Kierunek.POLUDNIE
+        elif self == Kierunek.WSCHOD:
+            return Kierunek.POLNOC
+
+    def kierunekNaPrawo(self):
+        if self == Kierunek.POLNOC:
+            return Kierunek.WSCHOD
+        elif self == Kierunek.POLUDNIE:
+            return Kierunek.ZACHOD
+        elif self == Kierunek.ZACHOD:
+            return Kierunek.POLNOC
+        elif self == Kierunek.WSCHOD:
+            return Kierunek.POLUDNIE
 
 
 class ZawartoscPola(Enum):
     PUSTE = 0
     SCIANA = 1
+    CEL = 2
 
 
 ZawartoscPolaNaKolorPola = {
     ZawartoscPola.PUSTE: BIALY,
-    ZawartoscPola.SCIANA: CIEMNY_BRAZOWY1
+    ZawartoscPola.SCIANA: CIEMNY_BRAZOWY1,
+    ZawartoscPola.CEL: ZIELONY1
 }

krata.py

@@ -36,6 +36,9 @@ class PoleKraty:
     wiersz = property(getWiersz, setWiersz)
     kolumna = property(getKolumna, setKolumna)
 
+    def skopiuj(self):
+        return PoleKraty(self.krata, self.wiersz, self.kolumna)
+
 
 class Krata:
     def __init__(self, okno):
@@ -65,7 +68,7 @@ class Krata:
     def wyswietlKrate(self):
         self.narysujKrate()
         # self.narysujKrateAlternatywnie()
-        self.narysujAgenta()
+        # self.narysujAgenta()
         pygame.display.update()
 
     def narysujKrate(self):
@@ -90,7 +93,7 @@ class Krata:
             pygame.draw.line(self.okno, CZARNY, (0, new_height), (SZEROKOSC_OKNA, new_height), ODSTEP_MIEDZY_POLAMI)
             pygame.draw.line(self.okno, CZARNY, (new_width, 0), (new_width, WYSOKOSC_OKNA), ODSTEP_MIEDZY_POLAMI)
 
-    def narysujAgenta(self):
+    # def narysujAgenta(self):
-        if self.agent is not None:
+    #     if self.agent is not None:
-            self.okno.blit(self.agent.tekstura, (self.agent.hitbox.x, self.agent.hitbox.y))
+    #         self.okno.blit(self.agent.tekstura, (self.agent.hitbox.x, self.agent.hitbox.y))
-            self.agent.ruszSie()
+    #         self.agent.ruszSie()

main.py

@@ -1,9 +1,7 @@
 import os
-import ctypes
 
 from agent import *
 from ramy_czyli_wiedza_agenta import *
-from bfs import *
 
 # aby działalo w oknie + rozdzielczość ekranu
 # ctypes.windll.shcore.SetProcessDpiAwareness(1)
@@ -11,39 +9,54 @@ from bfs import *
 Okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
 pygame.display.set_caption("Okno1")
 Krata = Krata(Okno)
-Pomieszczenie=Pomieszczenie(0,0)
+Pomieszczenie = Pomieszczenie(WarunkiPowietrza(0, 0), 0)
+
 
 def dodaj_agenta():
     # pole_lewe_gorne = PoleKraty(Krata, random.randint(0, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH),
     # random.randint(0, LICZBA_POL_W_POZIOMIE - BOK_AGENTA1_W_POLACH))
-    pole_lewe_gorne = PoleKraty(Krata, LICZBA_POL_W_PIONIE-BOK_AGENTA1_W_POLACH, int(LICZBA_POL_W_POZIOMIE/2))
+    # pole_lewe_gorne = PoleKraty(Krata, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH, int(LICZBA_POL_W_POZIOMIE / 2))
+    pole_lewe_gorne = PoleKraty(Krata, 0, 0)
     pom = 'traktor_ikona.png'
     ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', pom)),
                                    (BOK_AGENTA1, BOK_AGENTA1))
     Agent(Krata, pole_lewe_gorne, ikona)
+    # zawsze na poczatku polnoc
+    Krata.agent.kierunek = Kierunek.POLNOC
 
-def dodaj_szafke(numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1):
+
+def dodaj_szafke(numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz, poczatek_kolumna):
     wymiary_szafki = Wymiary(0, 0, 0)
-    szafka = Szafka(numerSzafki,wymiary_szafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1, Krata)
+    szafka = Szafka(numerSzafki, wymiary_szafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz,
+                    poczatek_kolumna, Krata)
     Pomieszczenie.dodajSzafke(szafka)
 
+
+def losowy_cel():
+    kierunek = Kierunek(random.randint(0, 3))
+    wiersz = random.randint(-1, Krata.liczbaPolPionowo - 1)
+    kolumna = random.randint(-1, Krata.liczbaPolPoziomo - 1)
+    Krata.krata[wiersz][kolumna] = ZawartoscPola.CEL
+    return Stan(kierunek, PoleKraty(Krata, wiersz, kolumna))
+
+
 def main():
-    dodaj_szafke("A", 2, 7, "P", 0, 0)
+    dodaj_szafke("A", 2, 12, "P", 2, 2)
-    dodaj_szafke("B", 2, 7, "L", 0, 3)
+    dodaj_szafke("B", 2, 12, "L", 2, 3)
-    dodaj_szafke("C", 2, 7, "P", 0, 4)
+    dodaj_szafke("C", 2, 5, "P", 1, 6)
-    dodaj_szafke("D", 2, 7, "L", 0, 7)
+    dodaj_szafke("D", 2, 6, "L", 1, 7)
-    dodaj_szafke("E", 2, 7, "P", 0, 8)
+    dodaj_szafke("C", 2, 4, "P", 9, 6)
-    dodaj_szafke("F", 2, 7, "L", 0, 11)
+    dodaj_szafke("D", 2, 3, "L", 10, 7)
-    dodaj_szafke("G", 2, 7, "P", 0, 12)
+    dodaj_szafke("E", 2, 8, "P", 3, 11)
-    dodaj_szafke("H", 2, 7, "L", 0, 15)
+    dodaj_szafke("F", 2, 10, "L", 2, 13)
-    dodaj_szafke("I", 2, 7, "P", 0, 16)
+    dodaj_szafke("H", 2, 12, "L", 1, 18)
-    dodaj_szafke("J", 2, 7, "L", 0, 19)
+    dodaj_szafke("I", 2, 7, "P", 5, 23)
+    dodaj_szafke("J", 2, 12, "L", 1, 25)
+    dodaj_szafke("G", 2, 10, "P", 5, 29)
+
     dodaj_agenta()
-    # cel to pole kraty gdzie ma stać agent, aby położyć paczkę na półkę, w obiekcie klasy Miejsce jest to artybut dostęp
+
-    cel = PoleKraty(Krata, 1, 14)
+    # Krata.wyswietlKrate()
-    # start to pole startowe agenta, == pole_lewe_gorne
-    start = PoleKraty(Krata, LICZBA_POL_W_PIONIE-BOK_AGENTA1_W_POLACH, int(LICZBA_POL_W_POZIOMIE/2))
-    bfsList = bfs(Krata, start, cel)
 
     klatkaz = pygame.time.Clock()
     warunek_dzialania = True
@@ -53,7 +66,15 @@ def main():
             if event.type == pygame.QUIT:
                 warunek_dzialania = False
                 break
-        Krata.wyswietlKrate()
+
+        # cel to Stan (pole kraty gdzie ma stać agent, aby położyć paczkę na półkę, w obiekcie klasy Miejsce jest to artybut dostęp + kierunek <-na razie niepotrzebny)
+        if Krata.agent.cel is None:
+            Krata.agent.cel = losowy_cel()
+            Krata.krata[Krata.agent.cel.poleStartoweGorne.wiersz][
+                Krata.agent.cel.poleStartoweGorne.kolumna] = ZawartoscPola.CEL
+            print("CEL:", Krata.agent.cel.poleStartoweGorne.wiersz, Krata.agent.cel.poleStartoweGorne.kolumna)
+            Krata.agent.idzDoCelu(klatkaz)
+
     pygame.quit()
 
 

miejsce.py

@@ -6,5 +6,3 @@ class Miejsce:
         self.miejsceNaPolce = miejsceNaPolce
         self.status = 'wolne'
         self.numerUmieszczonejPaczki = ''
-
-

ramy_czyli_wiedza_agenta.py

@@ -1,5 +1,3 @@
-from enumy_i_slowniki import *
-from stale import *
 from krata import *
 
 
@@ -62,7 +60,8 @@ class Miejsce: #wcześniej półka
 
 
 class Szafka:
-    def __init__(self, numerSzafki, wymiary: Wymiary, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1, Krata: Krata):
+    def __init__(self, numerSzafki, wymiary: Wymiary, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna,
+                 poczatek_wiersz1, Krata: Krata):
         self.numerSzafki = numerSzafki
         self.wymiary = wymiary
         self.iloscPolek = iloscPolek
@@ -70,7 +69,8 @@ class Szafka:
         self.dostepZeStrony = dostepZeStrony
         self.Miejsca = []
         self.zajmowanePola = []
-        self.utworzPustaSzafke(numerSzafki,iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1,Krata)
+        self.utworzPustaSzafke(numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna,
+                               poczatek_wiersz1, Krata)
 
     def dodajMiejsce(self, miejsce: Miejsce):
         self.Miejsca.append(miejsce)
@@ -78,7 +78,8 @@ class Szafka:
     def dodajPole(self, pole: PoleKraty):
         self.zajmowanePola.append(pole)
 
-    def utworzPustaSzafke(self, numerSzafki, iloscPolek, iloscMiejscNaPolce, dostępZeStrony, poczatek_wiersz1, poczatek_kolumna, Krata: Krata):
+    def utworzPustaSzafke(self, numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz1,
+                          poczatek_kolumna, Krata: Krata):
         for i in range(iloscPolek):
             for j in range(iloscMiejscNaPolce):
                 wymiar_miejsca = Wymiary(0, 0, 0)
@@ -92,14 +93,17 @@ class Szafka:
                         pole = PoleKraty(Krata, poczatek_wiersz, poczatek_kolumna + n)
                         miejsce.dodajPole(pole)
                         self.dodajPole(pole)
-                        if dostępZeStrony=="L":
+                        if dostepZeStrony == "L":
-                            pole_dostepu = PoleKraty(Krata, poczatek_wiersz, poczatek_kolumna + n - BOK_AGENTA1_W_POLACH) #dostęp z lewej strony
+                            pole_dostepu = PoleKraty(Krata, poczatek_wiersz,
+                                                     poczatek_kolumna + n - BOK_AGENTA1_W_POLACH)  # dostęp z lewej strony
                             miejsce.dodajDostep(pole_dostepu)
-                        elif dostępZeStrony == "P":
+                        elif dostepZeStrony == "P":
-                            pole_dostepu = PoleKraty(Krata, poczatek_wiersz, poczatek_kolumna + n + BOK_AGENTA1_W_POLACH)  # dostęp z prawej strony strony
+                            pole_dostepu = PoleKraty(Krata, poczatek_wiersz,
+                                                     poczatek_kolumna + n + BOK_AGENTA1_W_POLACH)  # dostęp z prawej strony strony
                             miejsce.dodajDostep(pole_dostepu)
                 self.dodajMiejsce(miejsce)
 
+
 class Pomieszczenie:
     def __init__(self, warunkiPowietrza: WarunkiPowietrza, wysokoscSufitu):
         self.warunkiPowietrza = warunkiPowietrza
@@ -113,26 +117,30 @@ class Pomieszczenie:
     def dodajPole(self, pole: PoleMapy):
         self.zajmowanePola.append(pole)
 
+
 class Etykieta:
-    def __init__(self, nazwaTowaru, nazwaNadawcy, dataZapakowania, id, niePietrowac, zachowacSuchosc, ostroznie, uwagaSzklo):
+    def __init__(self, nazwaTowaru, nazwaNadawcy, dataZapakowania, iD, niePietrowac, zachowacSuchosc, ostroznie,
+                 uwagaSzklo):
         # realistyczne? informacje na paczce
         # kategoryzowanie towaru może odbywać się na podstawie jego nazwy
         self.nazwaTowaru = nazwaTowaru
         self.nazwaNadawcy = nazwaNadawcy
         self.dataZapakowania = dataZapakowania
-        self.id = id
+        self.id = iD
         # nalepki na paczce - być może nie będą na etykiecie, a trzeba je będzie rozpoznać na obrazie
         self.niePietrowac = niePietrowac
         self.zachowacSuchosc = zachowacSuchosc
         self.ostroznie = ostroznie
         self.uwagaSzklo = uwagaSzklo
 
+
 class Paczka:
     def __init__(self, wymiary: Wymiary, waga, etykieta: Etykieta):
         self.wymiary = wymiary
         self.waga = waga
         self.etykieta = etykieta
 
+
 class Paleta:
     def __init__(self):
         self.Paczki = []
@@ -140,18 +148,20 @@ class Paleta:
     def dodajPaczke(self, paczka: Paczka):
         self.Paczki.append(paczka)
 
+
 class Nadawca:
-    def __init__(self,nazwa, id):
+    def __init__(self, nazwa, iD):
         self.nazwa = nazwa
-        self.id = id
+        self.id = iD
         # plus dodatkowe informacje mogące wpływać na priorytet rozpakowania transportu / miejsce składowania paczek?
 
+
 class Transport:
-    def __init__(self, dataPrzyjecia, nadawca: Nadawca, id):
+    def __init__(self, dataPrzyjecia, nadawca: Nadawca, iD):
         Palety = []
         self.dataPrzyjecia = dataPrzyjecia
         self.nadawca = nadawca
-        self.id = id
+        self.id = iD
 
     # wyliczanie priorytetu rozpakowania transportu ?
     # def okrescPriorytet(self):

stale.py

@@ -3,8 +3,8 @@ FPS = 5
 # SZEROKOSC_OKNA = 1500
 # WYSOKOSC_OKNA = 750
 #
-LICZBA_POL_W_POZIOMIE = 20
+LICZBA_POL_W_POZIOMIE = 30
-LICZBA_POL_W_PIONIE = 12
+LICZBA_POL_W_PIONIE = 15
 BOK_POLA = 45
 ODSTEP_MIEDZY_POLAMI = 1
 SZEROKOSC_OKNA = LICZBA_POL_W_POZIOMIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI

szafka2.py

@@ -1,5 +1,6 @@
 import miejsce
 
+
 class Szafka:
     def __init__(self, numerSzafki, rozmiar, iloscPolek, iloscMiejscNaPolce):
         self.numer = numerSzafki
@@ -27,11 +28,8 @@ class Szafka:
 
         self.listaWolnychMiejsc = self.listaMiejsc.copy()
 
-
     def polozPaczke(self, numerPaczki):
         if len(self.listaWolnychMiejsc) != 0:
             self.listaWolnychMiejsc[0].numerUmieszczonejPaczki = numerPaczki
             self.listaWolnychMiejsc[0].status = "zajęte"
             self.listaWolnychMiejsc.pop(0)
-
-