bfs

# Conflicts:
#	etykieta.py
#	main.py

.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.10 (Sztuczna_Inteligencja_Gr16)" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.9 (Sztuczna_Inteligencja_Gr16_0304)" 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.10 (Sztuczna_Inteligencja_Gr16)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (Sztuczna_Inteligencja_Gr16_0304)" project-jdk-type="Python SDK" />
 </project>

agent.py

@@ -0,0 +1,185 @@
+import random
+
+from krata import *
+
+
+class Agent:
+    bok = BOK_AGENTA1
+    bokWPolach = BOK_AGENTA1_W_POLACH
+
+    def __init__(self, Krata, poleStartoweGorne, tekstura):
+        self.krata = Krata
+        self.poleStartoweGorne = poleStartoweGorne
+        self.tekstura = tekstura
+        self.okreslPolozenie()
+        self.obierzNowyKierunek()
+        self.okreslDlugoscDrogi()
+        Krata.agent = self
+
+    def ruszSie(self):
+        if self.droga <= 0:
+            self.obierzNowyKierunek()
+            self.okreslDlugoscDrogi()
+        self.zrobKrokWMoimKierunku()
+        self.droga -= 1
+        self.okreslPolozenie()
+        if self.wyszedlemPozaKrate() or self.wszedlemWSciane():
+            self.cofnijSie()
+            self.zawroc()
+            self.okreslDlugoscDrogi()
+
+    def obierzNowyKierunek(self):
+        self.kierunek = Kierunek(random.randint(0, 3))
+        if self.maxDlugoscDrogiWMoimKierunku() < 1:
+            self.obierzNowyKierunek()
+
+    def okreslDlugoscDrogi(self):
+        self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
+
+    def cofnijSie(self):
+        self.zrobKrokWOdwrotnymKierunku()
+        self.okreslPolozenie()
+
+    def okreslPolozenie(self):
+        self.okreslPoleKoncoweDolne()
+        self.okreslHitbox()
+
+    def okreslHitbox(self):
+        self.hitbox = pygame.Rect(self.poleStartoweGorne.start, self.poleStartoweGorne.gora, self.bok, self.bok)
+
+    def okreslPoleKoncoweDolne(self):
+        wiersz = self.poleStartoweGorne.wiersz + self.bokWPolach - 1
+        kolumna = self.poleStartoweGorne.kolumna + self.bokWPolach - 1
+        self.poleKoncoweDolne = PoleKraty(self.krata, wiersz, kolumna)
+
+    def wyszedlemPozaKrate(self):
+        if self.poleStartoweGorne.wiersz < 0:
+            return True
+        elif self.poleKoncoweDolne.wiersz > self.krata.liczbaPolPionowo - 1:
+            return True
+        elif self.poleStartoweGorne.kolumna < 0:
+            return True
+        elif self.poleKoncoweDolne.kolumna > self.krata.liczbaPolPoziomo - 1:
+            return True
+        else:
+            return False
+
+    # ZROBIC sciany
+    def wszedlemWSciane(self):
+        for wiersz in range (self.poleStartoweGorne.wiersz,self.poleKoncoweDolne.wiersz+1):
+            for kolumna in range(self.poleStartoweGorne.kolumna,self.poleKoncoweDolne.kolumna+1):
+               if self.krata.krata[wiersz][kolumna]==ZawartoscPola.SCIANA:
+                  return True
+        return False
+
+    def zawroc(self):
+        if self.kierunek == Kierunek.GORA:
+            self.kierunek = Kierunek.DOL
+        elif self.kierunek == Kierunek.DOL:
+            self.kierunek = Kierunek.GORA
+        elif self.kierunek == Kierunek.LEWO:
+            self.kierunek = Kierunek.PRAWO
+        elif self.kierunek == Kierunek.PRAWO:
+            self.kierunek = Kierunek.LEWO
+
+    def maxDlugoscDrogiWMoimKierunku(self):
+        if self.kierunek == Kierunek.GORA:
+            return self.poleStartoweGorne.wiersz
+        elif self.kierunek == Kierunek.DOL:
+            return self.krata.liczbaPolPionowo - self.poleKoncoweDolne.wiersz - 1
+        elif self.kierunek == Kierunek.LEWO:
+            return self.poleStartoweGorne.kolumna
+        elif self.kierunek == Kierunek.PRAWO:
+            return self.krata.liczbaPolPoziomo - self.poleKoncoweDolne.kolumna - 1
+
+    def zrobKrokWMoimKierunku(self):
+        if self.kierunek == Kierunek.GORA:
+            self.idzWGore()
+        elif self.kierunek == Kierunek.DOL:
+            self.idzWDol()
+        elif self.kierunek == Kierunek.LEWO:
+            self.idzWLewo()
+        elif self.kierunek == Kierunek.PRAWO:
+            self.idzWPrawo()
+
+    def zrobKrokWOdwrotnymKierunku(self):
+        if self.kierunek == Kierunek.GORA:
+            self.idzWDol()
+        elif self.kierunek == Kierunek.DOL:
+            self.idzWGore()
+        elif self.kierunek == Kierunek.LEWO:
+            self.idzWPrawo()
+        elif self.kierunek == Kierunek.PRAWO:
+            self.idzWLewo()
+
+    def idzWGore(self):
+        self.poleStartoweGorne.wiersz -= 1
+
+    def idzWDol(self):
+        self.poleStartoweGorne.wiersz += 1
+
+    def idzWLewo(self):
+        self.poleStartoweGorne.kolumna -= 1
+
+    def idzWPrawo(self):
+        self.poleStartoweGorne.kolumna += 1
+
+    #def bfs(self, start:PoleKraty, cel:PoleKraty):
+    #    sciezka = [start]
+    #    wierzcholek_sciezka = [start, sciezka]
+    #    bfs_kolejka = [wierzcholek_sciezka]
+    #    odwiedzone = set()
+    #    while bfs_kolejka:
+    #        aktualne, sciezka = bfs_kolejka.pop(0)
+    #        odwiedzone.add(aktualne)
+    #        for neighbor in graph[aktualne]:
+    #            if neighbor not in odwiedzone:
+    #                if neighbor is cel:
+    #                    return sciezka + [neighbor]
+    #                else:
+    #                    bfs_kolejka.append([neighbor, sciezka + [neighbor]])
+    def bfs2(self, start: PoleKraty, cel: PoleKraty):
+        #sciezka = []
+        wierzcholek_sciezka = [["start",start], [["start",start]]]
+        bfs_kolejka = [wierzcholek_sciezka]
+        odwiedzone = set()
+        while bfs_kolejka:
+            #sciezka = []
+            elem=bfs_kolejka.pop(0)
+            odwA=str(elem[0][1].wiersz)+"/"+str(elem[0][1].kolumna)
+            odwiedzone.add(odwA)
+            polaObok=self.succ(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(self, poleKraty: PoleKraty):
+        polaDostepneObok=list()
+        if poleKraty.kolumna-1>=0: #nie poza kratę
+            if self.krata.krata[poleKraty.wiersz][poleKraty.kolumna-1]!=ZawartoscPola.SCIANA: #nie szafka (szafka to ściana)
+                poleLewe=PoleKraty(self.krata, poleKraty.wiersz, poleKraty.kolumna-1)
+                naLewo=["Kierunek.LEWO", poleLewe]
+                polaDostepneObok.append(naLewo)
+        if poleKraty.wiersz - 1>= 0:  # nie poza kratę
+            if self.krata.krata[poleKraty.wiersz-1][poleKraty.kolumna] != ZawartoscPola.SCIANA:
+                poleGorne = PoleKraty(self.krata, poleKraty.wiersz-1, poleKraty.kolumna)
+                naGore = ["Kierunek.GORA", poleGorne]
+                polaDostepneObok.append(naGore)
+        if poleKraty.kolumna+1<LICZBA_POL_W_POZIOMIE: #nie poza kratę
+            if self.krata.krata[poleKraty.wiersz][poleKraty.kolumna+1]!=ZawartoscPola.SCIANA:
+                polePrawe=PoleKraty(self.krata, poleKraty.wiersz, poleKraty.kolumna+1)
+                naPrawo = ["Kierunek.PRAWO", polePrawe]
+                polaDostepneObok.append(naPrawo)
+        if poleKraty.wiersz+1<LICZBA_POL_W_PIONIE:  # nie poza kratę
+            if self.krata.krata[poleKraty.wiersz+1][poleKraty.kolumna] != ZawartoscPola.SCIANA:
+                poleDolne = PoleKraty(self.krata, poleKraty.wiersz+1, poleKraty.kolumna)
+                naDol = ["Kierunek.DOL", poleDolne]
+                polaDostepneObok.append(naDol)
+        return polaDostepneObok

bfs.py

@@ -0,0 +1,45 @@
+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):
+    polaDostepneObok = list()
+    if poleKraty.kolumna - 1 >= 0:  # nie poza kratę
+        if Krata.krata[poleKraty.wiersz][poleKraty.kolumna - 1] != ZawartoscPola.SCIANA:  # nie szafka (szafka to ściana)
+            poleLewe = PoleKraty(Krata, poleKraty.wiersz, poleKraty.kolumna - 1)
+            naLewo = ["Kierunek.LEWO", poleLewe]
+            polaDostepneObok.append(naLewo)
+    if poleKraty.wiersz - 1 >= 0:  # nie poza kratę
+        if Krata.krata[poleKraty.wiersz - 1][poleKraty.kolumna] != ZawartoscPola.SCIANA:
+            poleGorne = PoleKraty(Krata, poleKraty.wiersz - 1, poleKraty.kolumna)
+            naGore = ["Kierunek.GORA", poleGorne]
+            polaDostepneObok.append(naGore)
+    if poleKraty.kolumna + 1 < LICZBA_POL_W_POZIOMIE:  # nie poza kratę
+        if Krata.krata[poleKraty.wiersz][poleKraty.kolumna + 1] != ZawartoscPola.SCIANA:
+            polePrawe = PoleKraty(Krata, poleKraty.wiersz, poleKraty.kolumna + 1)
+            naPrawo = ["Kierunek.PRAWO", polePrawe]
+            polaDostepneObok.append(naPrawo)
+    if poleKraty.wiersz + 1 < LICZBA_POL_W_PIONIE:  # nie poza kratę
+        if Krata.krata[poleKraty.wiersz + 1][poleKraty.kolumna] != ZawartoscPola.SCIANA:
+            poleDolne = PoleKraty(Krata, poleKraty.wiersz + 1, poleKraty.kolumna)
+            naDol = ["Kierunek.DOL", poleDolne]
+            polaDostepneObok.append(naDol)
+    return polaDostepneObok

bfs_z_agenta.txt

@@ -0,0 +1,59 @@
+#def bfs(self, start:PoleKraty, cel:PoleKraty):
+    #    sciezka = [start]
+    #    wierzcholek_sciezka = [start, sciezka]
+    #    bfs_kolejka = [wierzcholek_sciezka]
+    #    odwiedzone = set()
+    #    while bfs_kolejka:
+    #        aktualne, sciezka = bfs_kolejka.pop(0)
+    #        odwiedzone.add(aktualne)
+    #        for neighbor in graph[aktualne]:
+    #            if neighbor not in odwiedzone:
+    #                if neighbor is cel:
+    #                    return sciezka + [neighbor]
+    #                else:
+    #                    bfs_kolejka.append([neighbor, sciezka + [neighbor]])
+    def bfs(self, start: PoleKraty, cel: PoleKraty):
+        #sciezka = []
+        wierzcholek_sciezka = [["start",start], [["start",start]]]
+        bfs_kolejka = [wierzcholek_sciezka]
+        odwiedzone = set()
+        while bfs_kolejka:
+            #sciezka = []
+            elem=bfs_kolejka.pop(0)
+            odwA=str(elem[0][1].wiersz)+"/"+str(elem[0][1].kolumna)
+            odwiedzone.add(odwA)
+            polaObok=self.succ(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(self, poleKraty: PoleKraty):
+        polaDostepneObok=list()
+        if poleKraty.kolumna-1>=0: #nie poza kratę
+            if self.krata.krata[poleKraty.wiersz][poleKraty.kolumna-1]!=ZawartoscPola.SCIANA: #nie szafka (szafka to ściana)
+                poleLewe=PoleKraty(self.krata, poleKraty.wiersz, poleKraty.kolumna-1)
+                naLewo=["Kierunek.LEWO", poleLewe]
+                polaDostepneObok.append(naLewo)
+        if poleKraty.wiersz - 1>= 0:  # nie poza kratę
+            if self.krata.krata[poleKraty.wiersz-1][poleKraty.kolumna] != ZawartoscPola.SCIANA:
+                poleGorne = PoleKraty(self.krata, poleKraty.wiersz-1, poleKraty.kolumna)
+                naGore = ["Kierunek.GORA", poleGorne]
+                polaDostepneObok.append(naGore)
+        if poleKraty.kolumna+1<LICZBA_POL_W_POZIOMIE: #nie poza kratę
+            if self.krata.krata[poleKraty.wiersz][poleKraty.kolumna+1]!=ZawartoscPola.SCIANA:
+                polePrawe=PoleKraty(self.krata, poleKraty.wiersz, poleKraty.kolumna+1)
+                naPrawo = ["Kierunek.PRAWO", polePrawe]
+                polaDostepneObok.append(naPrawo)
+        if poleKraty.wiersz+1<LICZBA_POL_W_PIONIE:  # nie poza kratę
+            if self.krata.krata[poleKraty.wiersz+1][poleKraty.kolumna] != ZawartoscPola.SCIANA:
+                poleDolne = PoleKraty(self.krata, poleKraty.wiersz+1, poleKraty.kolumna)
+                naDol = ["Kierunek.DOL", poleDolne]
+                polaDostepneObok.append(naDol)
+        return polaDostepneObok

enumy_i_slowniki.py

@@ -0,0 +1,21 @@
+from enum import Enum
+
+from stale import *
+
+
+class Kierunek(Enum):
+    GORA = 0
+    DOL = 1
+    LEWO = 2
+    PRAWO = 3
+
+
+class ZawartoscPola(Enum):
+    PUSTE = 0
+    SCIANA = 1
+
+
+ZawartoscPolaNaKolorPola = {
+    ZawartoscPola.PUSTE: BIALY,
+    ZawartoscPola.SCIANA: CIEMNY_BRAZOWY1
+}

etykieta.py

@@ -0,0 +1,7 @@
+class Etykieta:
+    def __init__(self,nazwa_paczki,producent,numer_paczki,cecha_paczki,data_wysylki):
+        self.nazwa_paczki = nazwa_paczki
+        self.producent=producent
+        self.numer_paczki = numer_paczki
+        self.cecha_paczki = cecha_paczki
+        self.data_wysylki = data_wysylki

krata.py

@@ -0,0 +1,101 @@
+import pygame
+
+from enumy_i_slowniki import *
+from stale import *
+
+
+class PoleKraty:
+    def __init__(self, Krata, wiersz, kolumna):
+        self.krata = Krata
+        self.bok = self.krata.bokPola
+        self._wiersz = wiersz
+        self._kolumna = kolumna
+        self.okreslGore()
+        self.okreslStart()
+
+    def okreslGore(self):
+        self.gora = (self.bok + self.krata.odstepMiedzyPolami) * self.wiersz + self.krata.odstepMiedzyPolami
+
+    def okreslStart(self):
+        self.start = (self.bok + self.krata.odstepMiedzyPolami) * self.kolumna + self.krata.odstepMiedzyPolami
+
+    def getWiersz(self):
+        return self._wiersz
+
+    def setWiersz(self, x):
+        self._wiersz = x
+        self.okreslGore()
+
+    def getKolumna(self):
+        return self._kolumna
+
+    def setKolumna(self, x):
+        self._kolumna = x
+        self.okreslStart()
+
+    wiersz = property(getWiersz, setWiersz)
+    kolumna = property(getKolumna, setKolumna)
+
+
+class Krata:
+    def __init__(self, okno):
+        self.okno = okno
+        self.liczbaPolPoziomo = LICZBA_POL_W_POZIOMIE
+        self.liczbaPolPionowo = LICZBA_POL_W_PIONIE
+        self.bokPola = BOK_POLA
+        self.odstepMiedzyPolami = ODSTEP_MIEDZY_POLAMI
+        self.utworzPustaKrate()
+        self.agent = None
+
+    def utworzPustaKrate(self):
+        self.krata = []
+        for wiersz in range(self.liczbaPolPionowo):
+            self.krata.append([])
+            for kolumna in range(self.liczbaPolPoziomo):
+                zawartosc_pola = ZawartoscPola.PUSTE
+                # ZROBIC sciany
+                # if wiersz in (0, self.liczbaPolPionowo - 1) or kolumna in (0, self.liczbaPolPoziomo - 1):
+                #      zawartosc_pola = ZawartoscPola.SCIANA
+                # if wiersz in range(6,18) and kolumna in (5,15,25,35):
+                #      zawartosc_pola = ZawartoscPola.SCIANA
+                # if wiersz in (4,22) and kolumna in range (10,35):
+                #      zawartosc_pola = ZawartoscPola.SCIANA
+                self.krata[wiersz].append(zawartosc_pola)
+
+    def wyswietlKrate(self):
+        self.narysujKrate()
+        # self.narysujKrateAlternatywnie()
+        self.narysujAgenta()
+        pygame.display.update()
+
+    def narysujKrate(self):
+        self.okno.fill(SZARY1)
+        for wiersz in range(self.liczbaPolPionowo):
+            for kolumna in range(self.liczbaPolPoziomo):
+                start = (self.odstepMiedzyPolami + self.bokPola) * kolumna + self.odstepMiedzyPolami
+                gora = (self.odstepMiedzyPolami + self.bokPola) * wiersz + self.odstepMiedzyPolami
+                kolor_pola = ZawartoscPolaNaKolorPola[self.krata[wiersz][kolumna]]
+                pygame.draw.rect(self.okno, kolor_pola, [start, gora, self.bokPola, self.bokPola])
+
+    def narysujKrateAlternatywnie(self):
+        self.okno.fill(SZARY1)
+        # for i in range(stale.NUMBER_OF_BLOCKS_WIDE):
+        #     new_height = round(i * BLOCK_HEIGHT)
+        #     new_width = round(i * BLOCK_HEIGHT)
+        #     pygame.draw.line(surface, BLACK, (0, new_height), (SZEROKOSC_OKNA, new_height), 2)
+        #     pygame.draw.line(surface, BLACK, (new_width, 0), (new_width, WYSOKOSC_OKNA), 2)
+        for i in range(LICZBA_POL_W_POZIOMIE + 1):
+            new_height = i * (BOK_POLA + ODSTEP_MIEDZY_POLAMI)
+            new_width = i * (BOK_POLA + ODSTEP_MIEDZY_POLAMI)
+            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):
+        if self.agent is not None:
+            self.okno.blit(self.agent.tekstura, (self.agent.hitbox.x, self.agent.hitbox.y))
+            self.agent.ruszSie()
+
+    def bfsA(self, start: PoleKraty, cel: PoleKraty):
+        if self.agent is not None:
+            odp= self.agent.bfs(start,cel)
+            return odp

main.py

@@ -1,29 +1,49 @@
 import os
+import ctypes
 
-import pygame
+from agent import *
+from ramy_czyli_wiedza_agenta import *
+from bfs import *
 
-FPS = 60
+#aby działalo w oknie + rozdzielczość ekranu
-SZEROKOSC_OKNA = 800
+#ctypes.windll.shcore.SetProcessDpiAwareness(1)
-WYSOKOSC_OKNA = 600
-BIALY = (255, 255, 255)
 
-OKNO = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
+Okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
 pygame.display.set_caption("Okno1")
-
+Krata = Krata(Okno)
-TEST1_IKONA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'test1_ikona.png')), (500, 500))
+Pomieszczenie=Pomieszczenie(0,0)
-TRAKTOR_IKONA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'traktor_ikona.png')), (100, 100))
 
 
-def wyswietl_okno():
+def dodaj_agenta():
-    OKNO.fill((150, 200, 150))
+    # pole_lewe_gorne = PoleKraty(Krata, random.randint(0, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH),
-    OKNO.blit(TEST1_IKONA,
+    # random.randint(0, LICZBA_POL_W_POZIOMIE - BOK_AGENTA1_W_POLACH))
-              (SZEROKOSC_OKNA / 2 - TEST1_IKONA.get_width() / 2, WYSOKOSC_OKNA / 2 - TEST1_IKONA.get_height() / 2))
+    pole_lewe_gorne = PoleKraty(Krata, LICZBA_POL_W_PIONIE-BOK_AGENTA1_W_POLACH, int(LICZBA_POL_W_POZIOMIE/2))
-    OKNO.blit(TRAKTOR_IKONA, (0, 0))
+    pom = 'traktor_ikona.png'
-    OKNO.blit(TRAKTOR_IKONA, (SZEROKOSC_OKNA - TRAKTOR_IKONA.get_width(), 0))
+    ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', pom)),
-    OKNO.blit(TRAKTOR_IKONA, (SZEROKOSC_OKNA - TRAKTOR_IKONA.get_width(), WYSOKOSC_OKNA - TRAKTOR_IKONA.get_height()))
+                                   (BOK_AGENTA1, BOK_AGENTA1))
-    OKNO.blit(TRAKTOR_IKONA, (0, WYSOKOSC_OKNA - TRAKTOR_IKONA.get_height()))
+    Agent(Krata, pole_lewe_gorne, ikona)
-    pygame.display.update()
 
+def dodaj_szafke(numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1):
+    wymiary_szafki = Wymiary(0, 0, 0)
+    szafka = Szafka(numerSzafki,wymiary_szafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1, Krata)
+    Pomieszczenie.dodajSzafke(szafka)
+
+def main():
+    dodaj_szafke("A", 2, 7, "P", 0, 0)
+    dodaj_szafke("B", 2, 7, "L", 0, 3)
+    dodaj_szafke("C", 2, 7, "P", 0, 4)
+    dodaj_szafke("D", 2, 7, "L", 0, 7)
+    dodaj_szafke("E", 2, 7, "P", 0, 8)
+    dodaj_szafke("F", 2, 7, "L", 0, 11)
+    dodaj_szafke("G", 2, 7, "P", 0, 12)
+    dodaj_szafke("H", 2, 7, "L", 0, 15)
+    dodaj_szafke("I", 2, 7, "P", 0, 16)
+    dodaj_szafke("J", 2, 7, "L", 0, 19)
+    dodaj_agenta()
+    cel = PoleKraty(Krata, 0, 2) #pole kraty gdzie ma stać agent, aby położyć paczkę na półkę, w obiekcie Miejsce artybut dostęp
+    start=PoleKraty(Krata, 11, 10) # pole startowe agenta, == pole_lewe_gorne
+    #bfsList= Krata.bfsA(start, cel)
+    bfsList=bfs(Krata,start,cel)
 
     klatkaz = pygame.time.Clock()
     warunek_dzialania = True
@@ -33,7 +53,7 @@ while warunek_dzialania:
             if event.type == pygame.QUIT:
                 warunek_dzialania = False
                 break
-
+        Krata.wyswietlKrate()
-    wyswietl_okno()
-
     pygame.quit()
+
+main()

miejsce.py

@@ -0,0 +1,10 @@
+class Miejsce:
+    def __init__(self, name, polka, miejsceNaPolce):
+        self.numer = name
+        #self.rozmiar = rozmiar
+        self.polka=polka
+        self.miejsceNaPolce=miejsceNaPolce
+        self.status = 'wolne'
+        self.numerUmieszczonejPaczki=''
+
+

ramy_czyli_wiedza_agenta.py

@@ -0,0 +1,158 @@
+from enumy_i_slowniki import *
+from stale import *
+from krata import *
+
+
+class Wymiary:
+    def __init__(self, dlugosc, szerokosc, wysokosc):
+        self.dlugosc = dlugosc
+        self.szerokosc = szerokosc
+        self.wysokosc = wysokosc
+
+
+class Mapa:
+    def __init__(self):
+        self.liczbaPolPoziomo = LICZBA_POL_W_POZIOMIE
+        self.liczbaPolPionowo = LICZBA_POL_W_PIONIE
+        self.bokPola = BOK_POLA
+        self.odstepMiedzyPolami = ODSTEP_MIEDZY_POLAMI
+        self.utworzPustaMape()
+        self.agent = None
+
+    def utworzPustaMape(self):
+        self.krata = []
+        for wiersz in range(self.liczbaPolPionowo):
+            self.krata.append([])
+            for kolumna in range(self.liczbaPolPoziomo):
+                zawartosc_pola = ZawartoscPola.PUSTE
+                nowe_pole = PoleMapy(self, wiersz, kolumna, zawartosc_pola)
+                self.krata[wiersz].append(nowe_pole)
+
+
+class PoleMapy:
+    def __init__(self, mapa: Mapa, wiersz, kolumna, zawartosc: ZawartoscPola):
+        self.mapa = mapa
+        self.bok = self.mapa.bokPola
+        self.wiersz = wiersz
+        self.kolumna = kolumna
+        self.zawartosc = zawartosc
+
+
+class WarunkiPowietrza:
+    def __init__(self, temperatura, wilgotnosc):
+        self.temperatura = temperatura
+        self.wilgotnosc = wilgotnosc
+
+
+class Miejsce: #wcześniej półka
+    def __init__(self, numer, wymiary: Wymiary, udzwig, wysokoscOdPodlogi):
+        self.numer=numer
+        self.wymiary = wymiary
+        self.udzwig = udzwig
+        self.wysokoscOdPodlogi = wysokoscOdPodlogi
+        #self.status = 'wolne'
+        self.dostep=[]
+        self.zajmowanePola = []
+
+    def dodajPole(self, pole: PoleKraty):
+        self.zajmowanePola.append(pole)
+
+    def dodajDostep(self, pole: PoleKraty):
+        self.dostep.append(pole)
+
+
+class Szafka:
+    def __init__(self, numerSzafki, wymiary: Wymiary, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1, Krata: Krata):
+        self.numerSzafki=numerSzafki
+        self.wymiary = wymiary
+        self.iloscPolek = iloscPolek
+        self.iloscMiejscNaPolce = iloscMiejscNaPolce
+        self.dostepZeStrony=dostepZeStrony
+        self.Miejsca = []
+        self.zajmowanePola = []
+        self.utworzPustaSzafke(numerSzafki,iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1,Krata)
+
+    def dodajMiejsce(self, miejsce: Miejsce):
+        self.Miejsca.append(miejsce)
+
+    def dodajPole(self, pole: PoleKraty):
+        self.zajmowanePola.append(pole)
+
+    def utworzPustaSzafke(self, numerSzafki, iloscPolek, iloscMiejscNaPolce, dostępZeStrony, poczatek_wiersz1, poczatek_kolumna, Krata: Krata):
+        for i in range(iloscPolek):
+            for j in range(iloscMiejscNaPolce):
+                wymiar_miejsca = Wymiary(0, 0, 0)
+                numerMiejsca = self.numerSzafki + "/" + str(i) + "/" + str(j)
+                miejsce = Miejsce(numerMiejsca,wymiar_miejsca, 0, 0)
+                #wypełnianie pól "zajmowane miejsca" i "dostęp"
+                for m in range(DUZA_SZAFA):  # wiersz
+                    poczatek_wiersz = poczatek_wiersz1 + j * DUZA_SZAFA + m
+                    for n in range(DUZA_SZAFA):  # kolumna
+                        Krata.krata[poczatek_wiersz][poczatek_kolumna + n] = ZawartoscPola.SCIANA
+                        pole = PoleKraty(Krata, poczatek_wiersz, poczatek_kolumna+n)
+                        miejsce.dodajPole(pole)
+                        self.dodajPole(pole)
+                        if dostępZeStrony=="L":
+                            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":
+                            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
+        self.wysokoscSufitu = wysokoscSufitu
+        self.Szafki = []
+        self.zajmowanePola = []
+
+    def dodajSzafke(self, szafka: Szafka):
+        self.Szafki.append(szafka)
+
+    def dodajPole(self, pole: PoleMapy):
+        self.zajmowanePola.append(pole)
+
+class Etykieta:
+    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
+        # 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 = []
+
+    def dodajPaczke(self, paczka: Paczka):
+        self.Paczki.append(paczka)
+
+class Nadawca:
+    def __init__(self,nazwa, id):
+        self.nazwa = nazwa
+        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):
+        Palety = []
+        self.dataPrzyjecia = dataPrzyjecia
+        self.nadawca = nadawca
+        self.id = id
+
+    # wyliczanie priorytetu rozpakowania transportu ?
+    # def okrescPriorytet(self):
+    #     self.priorytet =

stale.py

@@ -0,0 +1,50 @@
+FPS = 5
+#
+# SZEROKOSC_OKNA = 1500
+# WYSOKOSC_OKNA = 750
+#
+LICZBA_POL_W_POZIOMIE = 20
+LICZBA_POL_W_PIONIE = 12
+BOK_POLA = 45
+ODSTEP_MIEDZY_POLAMI = 1
+SZEROKOSC_OKNA = LICZBA_POL_W_POZIOMIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
+WYSOKOSC_OKNA = LICZBA_POL_W_PIONIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
+#
+BOK_AGENTA1_W_POLACH = 1
+BOK_AGENTA1 = BOK_AGENTA1_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
+#
+DUZA_SZAFA=1
+#
+BIALY = (255, 255, 255)
+JASNOSZARY1 = (200, 200, 200)
+SZARY1 = (150, 150, 150)
+ZIELONY1 = (26, 122, 26)
+CZARNY = (0, 0, 0)
+CIEMNY_BRAZOWY1 = (60, 19, 33)
+###
+
+###
+GREY = (150, 150, 150)
+RED = (255, 0, 0)
+BLUE = (55, 55, 255)
+BLACK = (0, 0, 0)
+GREEN = (0, 200, 0)
+DARKGREY = (150, 150, 150)
+UGLY_PINK = (255, 0, 255)
+BROWN = (153, 76, 0)
+GOLD = (153, 153, 0)
+DARKGREEN = (0, 102, 0)
+DARKORANGE = (255, 128, 0)
+#
+# NUMBER_OF_BLOCKS_WIDE=8
+# NUMBER_OF_BLOCKS_HIGH=8
+# BLOCK_HEIGHT=round(SZEROKOSC_OKNA/NUMBER_OF_BLOCKS_HIGH)
+# BLOCK_WIDTH=round(WYSOKOSC_OKNA/NUMBER_OF_BLOCKS_WIDE)
+#
+MAPFILE = "map.txt"
+TITLE = "Gierka"
+#
+NUMBER_OF_BLOCKS_WIDE = LICZBA_POL_W_POZIOMIE
+NUMBER_OF_BLOCKS_HIGH = LICZBA_POL_W_PIONIE
+BLOCK_HEIGHT = BOK_POLA
+BLOCK_WIDTH = BOK_POLA

szafka2.py

@@ -0,0 +1,37 @@
+import miejsce
+
+class Szafka:
+    def __init__(self, numerSzafki, rozmiar, iloscPolek, iloscMiejscNaPolce):
+        self.numer = numerSzafki
+        # np. A
+        self.rozmiarMiejsc=rozmiar
+        #średni, duży, mały
+        #self.iloscWolnychMiejsc = iloscPolek*iloscMiejscNaPolce
+        self.iloscPolek=iloscPolek
+        self.iloscMiejscNaPolce=iloscMiejscNaPolce
+        self.listaMiejsc=[]
+        self.listaWolnychMiejsc=[]
+        self.stworzMiejsca()
+
+    def stworzMiejsca(self):
+         j=0 #półka
+         k=0
+         while j<self.iloscPolek:
+            name=self.numer+"/"+str(j)+"/"+str(k)
+            nowe_miejsce= miejsce.Miejsce(name,j, k)
+            self.listaMiejsc.append(nowe_miejsce)
+            k=k+1
+            if k>self.iloscMiejscNaPolce-1:
+                j=j+1
+                k=0
+
+         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)
+
+