bfs

.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.8 (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.8 (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>

a_gwiazdka.py

@@ -1,124 +0,0 @@
-from collections import deque
-from queue import PriorityQueue
-
-from stan_nastepnik import *
-
-
-class NastepnikZKosztemSciezki:
-    def __init__(self, kosztSciezki: int, nastepnik: Nastepnik):
-        self.kosztSciezki = kosztSciezki
-        self.nastepnik = nastepnik
-
-    def skopiuj(self):
-        return NastepnikZKosztemSciezki(self.kosztSciezki, self.nastepnik.skopiuj())
-
-    def __lt__(self, other):
-        return self.kosztSciezki <= other.kosztSciezki
-
-
-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 stan_w_kolejce_nastepnikow(stan: Stan, kolejka_nastepnikow: PriorityQueue):
-    pom = []
-    znaleziono = False
-    while not kolejka_nastepnikow.empty():
-        element = kolejka_nastepnikow.get()
-        pom.append(element)
-        nastepnik_z_kosztem_sciezki: NastepnikZKosztemSciezki = element[1]
-        n = nastepnik_z_kosztem_sciezki.nastepnik
-        if n.stan.kierunek != stan.kierunek:
-            continue
-        elif n.stan.poleStartoweGorne.wiersz != stan.poleStartoweGorne.wiersz:
-            continue
-        elif n.stan.poleStartoweGorne.kolumna != stan.poleStartoweGorne.kolumna:
-            continue
-        else:
-            znaleziono = True
-            break
-    for e in pom:
-        kolejka_nastepnikow.put(e)
-    return znaleziono
-
-
-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 heurystyka(z: Stan, cel: Stan):
-    kroki_w_pionie = abs(cel.poleStartoweGorne.wiersz - z.poleStartoweGorne.wiersz)
-    kroki_w_poziomie = abs(cel.poleStartoweGorne.kolumna - z.poleStartoweGorne.kolumna)
-    return kroki_w_pionie + kroki_w_poziomie
-
-
-def koszt_wjechania(z: Stan, do: Stan):
-    z_wiersz = z.poleStartoweGorne.wiersz
-    z_kolumna = z.poleStartoweGorne.kolumna
-    do_wiersz = do.poleStartoweGorne.wiersz
-    do_kolumna = do.poleStartoweGorne.kolumna
-    krata = z.poleStartoweGorne.krata.krata
-    if z_wiersz == do_wiersz and z_kolumna == do_kolumna and z.kierunek == do.kierunek:
-        return 0
-    elif z_wiersz == do_wiersz and z_kolumna == do_kolumna and z.kierunek != do.kierunek:
-        return ZawartoscPolaNaKosztObrotu[krata[do_wiersz][do_kolumna]]
-    elif z.kierunek == do.kierunek:
-        krok_w_pionie = (abs(z_wiersz - do_wiersz) == 1 and z_kolumna == do_kolumna)
-        krok_w_poziomie = (abs(z_kolumna - do_kolumna) == 1 and z_kolumna == z_kolumna)
-        if krok_w_pionie or krok_w_poziomie:
-            return ZawartoscPolaNaKosztWjechania[krata[do_wiersz][do_kolumna]]
-        else:
-            raise "Stany nie są połączone."
-
-
-def priorytet(koszt_sciezki: int, z: Stan, do: Stan, cel: Stan):
-    return koszt_sciezki + koszt_wjechania(z, do) + heurystyka(do, cel)
-
-
-def graphsearch(istate: Stan, cel: Stan):
-    fringe = PriorityQueue()
-    explored = []
-    pom = NastepnikZKosztemSciezki(0, Nastepnik(None, istate, None))
-    fringe.put((priorytet(0, istate, istate, cel), pom))
-    # fringe.append(Nastepnik(None, istate, None))
-    while not fringe.empty():
-        # for i in fringe:
-        #     print("F",i.stan.kierunek,i.stan.poleStartoweGorne.wiersz,i.stan.poleStartoweGorne.kolumna,end=" ")
-        # print()
-        element: NastepnikZKosztemSciezki = fringe.get()[1]
-        koszt_sciezki = element.kosztSciezki
-        nastepnik = element.nastepnik
-        if goaltest(nastepnik.stan, cel):
-            return stos_akcji(nastepnik)
-        explored.append(nastepnik)
-        for nowy in succ(nastepnik):
-            if not stan_w_kolejce_nastepnikow(nowy.stan, fringe) and not stan_w_liscie_nastepnikow(nowy.stan, explored):
-                z = nastepnik.stan
-                do = nowy.stan
-                pom = NastepnikZKosztemSciezki(koszt_sciezki + koszt_wjechania(z, do), nowy)
-                pom2 = (priorytet(koszt_sciezki, z, do, cel), pom)
-                fringe.put(pom2)
-                # print("dodano",pom.nastepnik.stan.kierunek,pom.nastepnik.stan.poleStartoweGorne.wiersz,pom.nastepnik.stan.poleStartoweGorne.kolumna)
-    return False

agent.py

@@ -1,51 +1,40 @@
 import random
-from collections import deque
 
-# from bfs import graphsearch
-from a_gwiazdka import graphsearch
 from krata import *
-from obserwacja import *
-from stan_nastepnik import Stan, Akcja
 
 
-class Agent(Obserwowany):
+class Agent:
     bok = BOK_AGENTA1
     bokWPolach = BOK_AGENTA1_W_POLACH
-    cel: Stan or None
-    kierunek: Kierunek
-    # droga: int
-    hitbox: pygame.Rect
-    poleKoncoweDolne: PoleKraty
 
-    def __init__(self, krata: Krata, poleStartoweGorne: PoleKraty, tekstura):
-        self.krata = krata
+    def __init__(self, Krata, poleStartoweGorne, tekstura):
+        self.krata = Krata
         self.poleStartoweGorne = poleStartoweGorne
         self.tekstura = tekstura
         self.okreslPolozenie()
-        self.obierzLosowyKierunek()
-        # self.okreslDlugoscDrogi()
-        krata.agent = self
-        self.cel = None
+        self.obierzNowyKierunek()
+        self.okreslDlugoscDrogi()
+        Krata.agent = self
 
-    # def ruszSie(self):
-    #     if self.droga <= 0:
-    #         self.obierzLosowyKierunek()
-    #         self.okreslDlugoscDrogi()
-    #     self.zrobKrokWMoimKierunku()
-    #     self.droga -= 1
-    #     self.okreslPolozenie()
-    #     if self.wyszedlemPozaKrate() or self.wszedlemWSciane():
-    #         self.cofnijSie()
-    #         self.zawroc()
-    #         self.okreslDlugoscDrogi()
+    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 obierzLosowyKierunek(self):
+    def obierzNowyKierunek(self):
         self.kierunek = Kierunek(random.randint(0, 3))
-        # if self.maxDlugoscDrogiWMoimKierunku() < 1:
-        #     self.obierzLosowyKierunek()
+        if self.maxDlugoscDrogiWMoimKierunku() < 1:
+            self.obierzNowyKierunek()
 
-    # def okreslDlugoscDrogi(self):
-    #     self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
+    def okreslDlugoscDrogi(self):
+        self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
 
     def cofnijSie(self):
         self.zrobKrokWOdwrotnymKierunku()
@@ -54,7 +43,6 @@ class Agent(Obserwowany):
     def okreslPolozenie(self):
         self.okreslPoleKoncoweDolne()
         self.okreslHitbox()
-        self.powiadomObserwatorow()
 
     def okreslHitbox(self):
         self.hitbox = pygame.Rect(self.poleStartoweGorne.start, self.poleStartoweGorne.gora, self.bok, self.bok)
@@ -76,114 +64,122 @@ class Agent(Obserwowany):
         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
+        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.POLNOC:
-            self.kierunek = Kierunek.POLUDNIE
-        elif self.kierunek == Kierunek.POLUDNIE:
-            self.kierunek = Kierunek.POLNOC
-        elif self.kierunek == Kierunek.ZACHOD:
-            self.kierunek = Kierunek.WSCHOD
-        elif self.kierunek == Kierunek.WSCHOD:
-            self.kierunek = Kierunek.ZACHOD
+        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.POLNOC:
+        if self.kierunek == Kierunek.GORA:
             return self.poleStartoweGorne.wiersz
-        elif self.kierunek == Kierunek.POLUDNIE:
+        elif self.kierunek == Kierunek.DOL:
             return self.krata.liczbaPolPionowo - self.poleKoncoweDolne.wiersz - 1
-        elif self.kierunek == Kierunek.ZACHOD:
+        elif self.kierunek == Kierunek.LEWO:
             return self.poleStartoweGorne.kolumna
-        elif self.kierunek == Kierunek.WSCHOD:
+        elif self.kierunek == Kierunek.PRAWO:
             return self.krata.liczbaPolPoziomo - self.poleKoncoweDolne.kolumna - 1
 
     def zrobKrokWMoimKierunku(self):
-        if self.kierunek == Kierunek.POLNOC:
-            self.idzNaPolnoc()
-        elif self.kierunek == Kierunek.POLUDNIE:
-            self.idzNaPoludnie()
-        elif self.kierunek == Kierunek.ZACHOD:
-            self.idzNaZachod()
-        elif self.kierunek == Kierunek.WSCHOD:
-            self.idzNaWschod()
+        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.POLNOC:
-            self.idzNaPoludnie()
-        elif self.kierunek == Kierunek.POLUDNIE:
-            self.idzNaPolnoc()
-        elif self.kierunek == Kierunek.ZACHOD:
-            self.idzNaWschod()
-        elif self.kierunek == Kierunek.WSCHOD:
-            self.idzNaZachod()
+        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 idzNaPolnoc(self):
+    def idzWGore(self):
         self.poleStartoweGorne.wiersz -= 1
 
-    def idzNaPoludnie(self):
+    def idzWDol(self):
         self.poleStartoweGorne.wiersz += 1
 
-    def idzNaZachod(self):
+    def idzWLewo(self):
         self.poleStartoweGorne.kolumna -= 1
 
-    def idzNaWschod(self):
+    def idzWPrawo(self):
         self.poleStartoweGorne.kolumna += 1
 
-    def idzDoCelu(self):
-        stan_poczatkowy = Stan(self.kierunek, self.poleStartoweGorne)
-        stos_akcji = graphsearch(stan_poczatkowy, self.cel)
-        if not stos_akcji:
-            print("Nie można dotrzeć.")
-        else:
-            self.wykonaj_stos_akcji(stos_akcji)
-            print("Dotarłem.")
-        self.usunCel()
+    #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 ustawCel(self, cel):
-        self.cel = cel
-        wiersz = self.cel.poleStartoweGorne.wiersz
-        kolumna = self.cel.poleStartoweGorne.kolumna
-        if self.krata.krata[wiersz][kolumna] == ZawartoscPola.PUSTE:
-            self.krata.krata[wiersz][kolumna] = ZawartoscPola.CEL
-
-    def usunCel(self):
-        wiersz = self.cel.poleStartoweGorne.wiersz
-        kolumna = self.cel.poleStartoweGorne.kolumna
-        if self.krata.krata[wiersz][kolumna] == ZawartoscPola.CEL:
-            self.krata.krata[wiersz][kolumna] = ZawartoscPola.PUSTE
-        self.cel = None
-
-    def wykonaj_stos_akcji(self, stos_akcji: deque):
-        while stos_akcji:
-            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()
-            self.okreslPolozenie()
-        # print()
-
-    def obrocSieWLewo(self):
-        self.kierunek = self.kierunek.kierunekNaLewo()
-        self.tekstura = pygame.transform.rotate(self.tekstura, 90)
-
-    def obrocSieWPrawo(self):
-        self.kierunek = self.kierunek.kierunekNaPrawo()
-        self.tekstura = pygame.transform.rotate(self.tekstura, 270)
-
-    def narysujAgenta(self):
-        self.krata.okno.blit(self.tekstura, (self.hitbox.x, self.hitbox.y))
-
-    def powiadomObserwatorow(self):
-        for obserwator in self.obserwatorzy:
-            obserwator.odbierzPowiadomienie(self)
+    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

algorytmy_genetyczne.py

@@ -1,374 +0,0 @@
-
-import numpy as np
-from .decay import GeomDecay
-
-
-def hill_climb(problem, max_iters=np.inf, restarts=0, init_state=None,
-               curve=False, random_state=None):
-    """
-    best_state array containing state that optimizes the fitness function.
-    best_fitness Value of fitness function at best state.
-    fitness_curve array containing the fitness at every iteration.
-    """
-    if (not isinstance(max_iters, int) and max_iters != np.inf
-            and not max_iters.is_integer()) or (max_iters < 0):
-        raise Exception("""max_iters must be a positive integer.""")
-
-    if (not isinstance(restarts, int) and not restarts.is_integer()) \
-       or (restarts < 0):
-        raise Exception("""restarts must be a positive integer.""")
-
-    if init_state is not None and len(init_state) != problem.get_length():
-        raise Exception("""init_state must have same length as problem.""")
-
-    # Set random seed
-    if isinstance(random_state, int) and random_state > 0:
-        np.random.seed(random_state)
-
-    best_fitness = -1*np.inf
-    best_state = None
-
-    if curve:
-        fitness_curve = []
-
-    for _ in range(restarts + 1):
-        # Initialize optimization problem
-        if init_state is None:
-            problem.reset()
-        else:
-            problem.set_state(init_state)
-
-        iters = 0
-
-        while iters < max_iters:
-            iters += 1
-
-            # Find neighbors and determine best neighbor
-            problem.find_neighbors()
-            next_state = problem.best_neighbor()
-            next_fitness = problem.eval_fitness(next_state)
-
-            # If best neighbor is an improvement, move to that state
-            if next_fitness > problem.get_fitness():
-                problem.set_state(next_state)
-
-            else:
-                break
-
-            if curve:
-                fitness_curve.append(problem.get_fitness())
-
-        # Update best state and best fitness
-        if problem.get_fitness() > best_fitness:
-            best_fitness = problem.get_fitness()
-            best_state = problem.get_state()
-
-    best_fitness = problem.get_maximize()*best_fitness
-
-    if curve:
-        return best_state, best_fitness, np.asarray(fitness_curve)
-
-    return best_state, best_fitness
-
-
-def random_hill_climb(problem, max_attempts=10, max_iters=np.inf, restarts=0,
-                      init_state=None, curve=False, random_state=None):
-
-    if (not isinstance(max_attempts, int) and not max_attempts.is_integer()) \
-       or (max_attempts < 0):
-        raise Exception("""max_attempts must be a positive integer.""")
-
-    if (not isinstance(max_iters, int) and max_iters != np.inf
-            and not max_iters.is_integer()) or (max_iters < 0):
-        raise Exception("""max_iters must be a positive integer.""")
-
-    if (not isinstance(restarts, int) and not restarts.is_integer()) \
-       or (restarts < 0):
-        raise Exception("""restarts must be a positive integer.""")
-
-    if init_state is not None and len(init_state) != problem.get_length():
-        raise Exception("""init_state must have same length as problem.""")
-
-    # Set random seed
-    if isinstance(random_state, int) and random_state > 0:
-        np.random.seed(random_state)
-
-    best_fitness = -1*np.inf
-    best_state = None
-
-    if curve:
-        fitness_curve = []
-
-    for _ in range(restarts + 1):
-        # Initialize optimization problem and attempts counter
-        if init_state is None:
-            problem.reset()
-        else:
-            problem.set_state(init_state)
-
-        attempts = 0
-        iters = 0
-
-        while (attempts < max_attempts) and (iters < max_iters):
-            iters += 1
-
-            # Find random neighbor and evaluate fitness
-            next_state = problem.random_neighbor()
-            next_fitness = problem.eval_fitness(next_state)
-
-            # If best neighbor is an improvement,
-            # move to that state and reset attempts counter
-            if next_fitness > problem.get_fitness():
-                problem.set_state(next_state)
-                attempts = 0
-
-            else:
-                attempts += 1
-
-            if curve:
-                fitness_curve.append(problem.get_fitness())
-
-        # Update best state and best fitness
-        if problem.get_fitness() > best_fitness:
-            best_fitness = problem.get_fitness()
-            best_state = problem.get_state()
-
-    best_fitness = problem.get_maximize()*best_fitness
-
-    if curve:
-        return best_state, best_fitness, np.asarray(fitness_curve)
-
-    return best_state, best_fitness
-
-
-def simulated_annealing(problem, schedule=GeomDecay(), max_attempts=10,
-                        max_iters=np.inf, init_state=None, curve=False,
-                        random_state=None):
-    
-    if (not isinstance(max_attempts, int) and not max_attempts.is_integer()) \
-       or (max_attempts < 0):
-        raise Exception("""max_attempts must be a positive integer.""")
-
-    if (not isinstance(max_iters, int) and max_iters != np.inf
-            and not max_iters.is_integer()) or (max_iters < 0):
-        raise Exception("""max_iters must be a positive integer.""")
-
-    if init_state is not None and len(init_state) != problem.get_length():
-        raise Exception("""init_state must have same length as problem.""")
-
-    # Set random seed
-    if isinstance(random_state, int) and random_state > 0:
-        np.random.seed(random_state)
-
-    # Initialize problem, time and attempts counter
-    if init_state is None:
-        problem.reset()
-    else:
-        problem.set_state(init_state)
-
-    if curve:
-        fitness_curve = []
-
-    attempts = 0
-    iters = 0
-
-    while (attempts < max_attempts) and (iters < max_iters):
-        temp = schedule.evaluate(iters)
-        iters += 1
-
-        if temp == 0:
-            break
-
-        else:
-            # Find random neighbor and evaluate fitness
-            next_state = problem.random_neighbor()
-            next_fitness = problem.eval_fitness(next_state)
-
-            # Calculate delta E and change prob
-            delta_e = next_fitness - problem.get_fitness()
-            prob = np.exp(delta_e/temp)
-
-            # If best neighbor is an improvement or random value is less
-            # than prob, move to that state and reset attempts counter
-            if (delta_e > 0) or (np.random.uniform() < prob):
-                problem.set_state(next_state)
-                attempts = 0
-
-            else:
-                attempts += 1
-
-        if curve:
-            fitness_curve.append(problem.get_fitness())
-
-    best_fitness = problem.get_maximize()*problem.get_fitness()
-    best_state = problem.get_state()
-
-    if curve:
-        return best_state, best_fitness, np.asarray(fitness_curve)
-
-    return best_state, best_fitness
-
-
-def genetic_alg(problem, pop_size=200, mutation_prob=0.1, max_attempts=10,
-                max_iters=np.inf, curve=False, random_state=None):
-    
-    if pop_size < 0:
-        raise Exception("""pop_size must be a positive integer.""")
-    elif not isinstance(pop_size, int):
-        if pop_size.is_integer():
-            pop_size = int(pop_size)
-        else:
-            raise Exception("""pop_size must be a positive integer.""")
-
-    if (mutation_prob < 0) or (mutation_prob > 1):
-        raise Exception("""mutation_prob must be between 0 and 1.""")
-
-    if (not isinstance(max_attempts, int) and not max_attempts.is_integer()) \
-       or (max_attempts < 0):
-        raise Exception("""max_attempts must be a positive integer.""")
-
-    if (not isinstance(max_iters, int) and max_iters != np.inf
-            and not max_iters.is_integer()) or (max_iters < 0):
-        raise Exception("""max_iters must be a positive integer.""")
-
-    # Set random seed
-    if isinstance(random_state, int) and random_state > 0:
-        np.random.seed(random_state)
-
-    if curve:
-        fitness_curve = []
-
-    # Initialize problem, population and attempts counter
-    problem.reset()
-    problem.random_pop(pop_size)
-    attempts = 0
-    iters = 0
-
-    while (attempts < max_attempts) and (iters < max_iters):
-        iters += 1
-
-        # Calculate breeding probabilities
-        problem.eval_mate_probs()
-
-        # Create next generation of population
-        next_gen = []
-
-        for _ in range(pop_size):
-            # Select parents
-            selected = np.random.choice(pop_size, size=2,
-                                        p=problem.get_mate_probs())
-            parent_1 = problem.get_population()[selected[0]]
-            parent_2 = problem.get_population()[selected[1]]
-
-            # Create offspring
-            child = problem.reproduce(parent_1, parent_2, mutation_prob)
-            next_gen.append(child)
-
-        next_gen = np.array(next_gen)
-        problem.set_population(next_gen)
-
-        next_state = problem.best_child()
-        next_fitness = problem.eval_fitness(next_state)
-
-        # If best child is an improvement,
-        # move to that state and reset attempts counter
-        if next_fitness > problem.get_fitness():
-            problem.set_state(next_state)
-            attempts = 0
-
-        else:
-            attempts += 1
-
-        if curve:
-            fitness_curve.append(problem.get_fitness())
-
-    best_fitness = problem.get_maximize()*problem.get_fitness()
-    best_state = problem.get_state()
-
-    if curve:
-        return best_state, best_fitness, np.asarray(fitness_curve)
-
-    return best_state, best_fitness
-
-
-def mimic(problem, pop_size=200, keep_pct=0.2, max_attempts=10,
-          max_iters=np.inf, curve=False, random_state=None, fast_mimic=False):
-    """Use MIMIC to find the optimum for a given optimization problem.
-
-    """
-    if problem.get_prob_type() == 'continuous':
-        raise Exception("""problem type must be discrete or tsp.""")
-
-    if pop_size < 0:
-        raise Exception("""pop_size must be a positive integer.""")
-    elif not isinstance(pop_size, int):
-        if pop_size.is_integer():
-            pop_size = int(pop_size)
-        else:
-            raise Exception("""pop_size must be a positive integer.""")
-
-    if (keep_pct < 0) or (keep_pct > 1):
-        raise Exception("""keep_pct must be between 0 and 1.""")
-
-    if (not isinstance(max_attempts, int) and not max_attempts.is_integer()) \
-       or (max_attempts < 0):
-        raise Exception("""max_attempts must be a positive integer.""")
-
-    if (not isinstance(max_iters, int) and max_iters != np.inf
-            and not max_iters.is_integer()) or (max_iters < 0):
-        raise Exception("""max_iters must be a positive integer.""")
-
-    # Set random seed
-    if isinstance(random_state, int) and random_state > 0:
-        np.random.seed(random_state)
-
-    if curve:
-        fitness_curve = []
-
-    if fast_mimic not in (True, False):
-        raise Exception("""fast_mimic mode must be a boolean.""")
-    else:
-        problem.mimic_speed = fast_mimic
-
-    # Initialize problem, population and attempts counter
-    problem.reset()
-    problem.random_pop(pop_size)
-    attempts = 0
-    iters = 0
-
-    while (attempts < max_attempts) and (iters < max_iters):
-        iters += 1
-
-        # Get top n percent of population
-        problem.find_top_pct(keep_pct)
-
-        # Update probability estimates
-        problem.eval_node_probs()
-
-        # Generate new sample
-        new_sample = problem.sample_pop(pop_size)
-        problem.set_population(new_sample)
-
-        next_state = problem.best_child()
-
-        next_fitness = problem.eval_fitness(next_state)
-
-        # If best child is an improvement,
-        # move to that state and reset attempts counter
-        if next_fitness > problem.get_fitness():
-            problem.set_state(next_state)
-            attempts = 0
-
-        else:
-            attempts += 1
-
-        if curve:
-            fitness_curve.append(problem.get_fitness())
-
-    best_fitness = problem.get_maximize()*problem.get_fitness()
-    best_state = problem.get_state().astype(int)
-
-    if curve:
-        return best_state, best_fitness, np.asarray(fitness_curve)
-
-    return best_state, best_fitness

bfs.py

@@ -1,52 +1,45 @@
-from collections import deque
+from krata import *
 
-from stan_nastepnik 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 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
+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

dataset.csv

@@ -1,201 +0,0 @@
-plec;wiek;czas_w_pom;temp_w_pom;poziom_kurzu;poziom_oswietlenia;niebezp_towary;decyzja
-2;54;40;0;60;59;0;1
-2;55;40;0;60;59;0;1
-2;25;40;0;60;59;0;1
-2;60;40;0;60;59;0;1
-2;25;50;0;60;59;0;1
-2;55;50;0;60;59;0;1
-2;54;40;0;87;32;0;1
-2;55;40;0;87;32;0;1
-2;19;51;0;71;48;0;1
-2;68;51;0;62;48;0;1
-2;54;40;0;59;59;1;1
-2;55;40;0;60;60;1;1
-2;25;40;0;59;59;1;1
-2;60;40;0;60;60;1;1
-2;25;50;0;45;45;1;1
-2;55;50;0;71;71;1;1
-2;54;40;0;33;33;1;1
-2;55;40;0;87;87;1;1
-2;19;51;0;50;50;1;1
-2;68;51;0;62;62;1;1
-2;54;40;0;59;59;0;0
-2;55;40;0;60;60;0;0
-2;25;40;0;59;59;0;0
-2;60;40;0;60;60;0;0
-2;25;50;0;45;45;0;0
-2;55;50;0;71;71;0;0
-2;54;40;0;33;33;0;0
-2;55;40;0;87;87;0;0
-2;19;51;0;50;50;0;0
-2;68;51;0;62;62;0;0
-2;54;40;0;59;60;0;0
-2;55;40;0;59;60;0;0
-2;25;40;0;59;60;0;0
-2;60;40;0;59;60;0;0
-2;25;50;0;59;60;0;0
-2;55;50;0;59;60;0;0
-2;54;40;0;32;87;0;0
-2;55;40;0;32;87;0;0
-2;19;51;0;45;71;0;0
-2;68;51;0;47;62;0;0
-1;54;40;0;59;59;0;1
-1;55;40;0;60;60;0;1
-1;25;40;0;59;59;0;1
-1;60;40;0;60;60;0;1
-1;25;50;0;45;45;0;1
-1;55;50;0;71;71;0;1
-1;54;40;0;33;33;0;1
-1;55;40;0;87;87;0;1
-1;19;51;0;50;50;0;1
-1;68;51;0;62;62;0;1
-2;54;39;0;60;59;1;1
-2;55;39;0;60;59;1;1
-2;25;39;0;60;59;1;1
-2;60;39;0;60;59;1;1
-2;25;20;0;60;59;1;1
-2;55;20;0;60;59;1;1
-2;54;39;0;87;32;1;1
-2;55;39;0;87;32;1;1
-2;19;24;0;71;48;1;1
-2;68;24;0;62;48;1;1
-2;54;39;0;60;60;1;1
-2;55;39;0;59;59;1;1
-2;25;39;0;60;60;1;1
-2;60;39;0;59;59;1;1
-2;25;20;0;71;71;1;1
-2;55;20;0;45;45;1;1
-2;54;39;0;87;87;1;1
-2;55;39;0;33;33;1;1
-2;19;24;0;62;62;1;1
-2;68;24;0;50;50;1;1
-2;54;39;0;59;59;1;0
-2;55;39;0;60;60;1;0
-2;25;39;0;59;59;1;0
-2;60;39;0;60;60;1;0
-2;25;20;0;45;45;1;0
-2;55;20;0;71;71;1;0
-2;54;39;0;33;33;1;0
-2;55;39;0;87;87;1;0
-2;19;24;0;50;50;1;0
-2;68;24;0;62;62;1;0
-2;54;39;0;59;60;1;0
-2;55;39;0;59;60;1;0
-2;25;39;0;59;60;1;0
-2;60;39;0;59;60;1;0
-2;25;20;0;59;60;1;0
-2;55;20;0;59;60;1;0
-2;54;39;0;32;87;1;0
-2;55;39;0;32;87;1;0
-2;19;24;0;45;71;1;0
-2;68;24;0;47;62;1;0
-1;54;39;0;59;59;1;1
-1;55;39;0;60;60;1;1
-1;25;39;0;59;59;1;1
-1;60;39;0;60;60;1;1
-1;25;20;0;45;45;1;1
-1;55;20;0;71;71;1;1
-1;54;39;0;33;33;1;1
-1;55;39;0;87;87;1;1
-1;19;24;0;50;50;1;1
-1;68;24;0;62;62;1;1
-1;54;39;0;60;59;0;0
-1;55;39;0;60;59;0;0
-1;25;39;0;60;59;0;0
-1;60;39;0;60;59;0;0
-1;25;20;0;60;59;0;0
-1;55;20;0;60;59;0;0
-1;54;39;0;87;32;0;0
-1;55;39;0;87;32;0;0
-1;19;24;0;71;48;0;0
-1;68;24;0;62;48;0;0
-2;54;40;1;60;59;1;1
-2;55;40;1;60;59;1;1
-2;25;40;1;60;59;1;1
-2;60;40;1;60;59;1;1
-2;25;50;1;60;59;1;1
-2;55;50;1;60;59;1;1
-2;54;40;1;87;32;1;1
-2;55;40;1;87;32;1;1
-2;19;51;1;71;48;1;1
-2;68;51;1;62;48;1;1
-2;54;40;1;60;60;1;1
-2;55;40;1;59;59;1;1
-2;25;40;1;60;60;1;1
-2;60;40;1;59;59;1;1
-2;25;50;1;71;71;1;1
-2;55;50;1;45;45;1;1
-2;54;40;1;87;87;1;1
-2;55;40;1;33;33;1;1
-2;19;51;1;62;62;1;1
-2;68;51;1;50;50;1;1
-2;54;40;1;59;59;1;0
-2;55;40;1;60;60;1;0
-2;25;40;1;59;59;1;0
-2;60;40;1;60;60;1;0
-2;25;50;1;45;45;1;0
-2;55;50;1;71;71;1;0
-2;54;40;1;33;33;1;0
-2;55;40;1;87;87;1;0
-2;19;51;1;50;50;1;0
-2;68;51;1;62;62;1;0
-1;54;40;1;59;59;1;1
-1;55;40;1;60;60;1;1
-1;25;40;1;59;59;1;1
-1;60;40;1;60;60;1;1
-1;25;50;1;45;45;1;1
-1;55;50;1;71;71;1;1
-1;54;40;1;33;33;1;1
-1;55;40;1;87;87;1;1
-1;19;51;1;50;50;1;1
-1;68;51;1;62;62;1;1
-1;54;40;1;59;60;1;1
-1;55;40;1;59;60;1;1
-1;25;40;1;59;60;1;1
-1;60;40;1;59;60;1;1
-1;25;50;1;59;60;1;1
-1;55;50;1;59;60;1;1
-1;54;40;1;32;87;1;1
-1;55;40;1;32;87;1;1
-1;19;51;1;45;71;1;1
-1;68;51;1;47;62;1;1
-1;54;40;1;60;59;0;0
-1;55;40;1;60;59;0;0
-1;25;40;1;60;59;0;0
-1;60;40;1;60;59;0;0
-1;25;50;1;60;59;0;0
-1;55;50;1;60;59;0;0
-1;54;40;1;87;32;0;0
-1;55;40;1;87;32;0;0
-1;19;51;1;71;48;0;0
-1;68;51;1;62;48;0;0
-2;54;39;1;60;59;1;0
-2;55;39;1;60;59;1;0
-2;25;39;1;60;59;1;0
-2;60;39;1;60;59;1;0
-2;25;20;1;60;59;1;0
-2;55;20;1;60;59;1;0
-2;54;39;1;87;32;1;0
-2;55;39;1;87;32;1;0
-2;19;24;1;71;48;1;0
-2;68;24;1;62;48;1;0
-1;54;39;1;60;59;1;0
-1;55;39;1;60;59;1;0
-1;25;39;1;60;59;1;0
-1;60;39;1;60;59;1;0
-1;25;20;1;60;59;1;0
-1;55;20;1;60;59;1;0
-1;54;39;1;87;32;1;0
-1;55;39;1;87;32;1;0
-1;19;24;1;71;48;1;0
-1;68;24;1;62;48;1;0
-1;54;19;0;60;59;1;0
-1;55;19;0;60;59;1;0
-1;25;19;0;60;59;1;0
-1;60;5;0;60;59;1;0
-1;25;5;0;60;59;1;0
-1;55;10;0;60;59;1;0
-1;54;18;0;87;32;1;0
-1;55;18;0;87;32;1;0
-1;19;3;0;71;48;1;0
-1;68;12;0;62;48;1;0

enumy_i_slowniki.py

@@ -4,68 +4,18 @@ from stale import *
 
 
 class Kierunek(Enum):
-    POLNOC = 0
-    POLUDNIE = 1
-    ZACHOD = 2
-    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
+    GORA = 0
+    DOL = 1
+    LEWO = 2
+    PRAWO = 3
 
 
 class ZawartoscPola(Enum):
     PUSTE = 0
     SCIANA = 1
-    CEL = 2
-    DYWAN = 3
-    KALUZA = 4
-    SCIANA2 = 5
-    OSOBA = 6
 
 
 ZawartoscPolaNaKolorPola = {
     ZawartoscPola.PUSTE: BIALY,
-    ZawartoscPola.SCIANA: CIEMNY_BRAZOWY1,
-    ZawartoscPola.CEL: PACZKA,
-    ZawartoscPola.DYWAN: DYWAN,
-    ZawartoscPola.KALUZA: KALUZA,
-    ZawartoscPola.SCIANA2: SZARY1,
-    ZawartoscPola.OSOBA: IKONA
-}
-
-ZawartoscPolaNaKosztObrotu = {
-    ZawartoscPola.PUSTE: 1,
-    ZawartoscPola.SCIANA: None,
-    ZawartoscPola.CEL: 1,
-    ZawartoscPola.DYWAN: 5,
-    ZawartoscPola.KALUZA: 3,
-    ZawartoscPola.SCIANA2: None,
-    ZawartoscPola.OSOBA: None
-}
-
-ZawartoscPolaNaKosztWjechania = {
-    ZawartoscPola.PUSTE: 2,
-    ZawartoscPola.SCIANA: None,
-    ZawartoscPola.CEL: 2,
-    ZawartoscPola.DYWAN: 5,
-    ZawartoscPola.KALUZA: 35,
-    ZawartoscPola.SCIANA2: None,
-    ZawartoscPola.OSOBA: None
+    ZawartoscPola.SCIANA: CIEMNY_BRAZOWY1
 }

etykieta.py

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

genetyczny.py

@@ -1,14 +0,0 @@
-import mlrose
-
-def best_route (lista_paczek):
-
-    koordynaty_paczek = mlrose.TravellingSales(coords = lista_paczek)
-    
-    #length oznacza liczbe paczek w naszej liscie
-    problem_fit = mlrose.TSPOpt(length = 5, fitness_fn = koordynaty_paczek, maximize = False)
-
-    # Znalesc najlepsza paczke za pomocy algorytmu genetycznego
-    best_state, best_fitness = mlrose.genetic_alg(problem_fit, mutation_prob = 0.2, max_attempts = 200, random_state = 2)
-
-    print('Najlepsza sciezka: ', best_state)
-    return best_state

krata.py

@@ -1,16 +1,12 @@
 import pygame
 
 from enumy_i_slowniki import *
-from obserwacja import *
 from stale import *
 
 
 class PoleKraty:
-    gora: any
-    start: any
-
-    def __init__(self, krata, wiersz, kolumna):
-        self.krata = krata
+    def __init__(self, Krata, wiersz, kolumna):
+        self.krata = Krata
         self.bok = self.krata.bokPola
         self._wiersz = wiersz
         self._kolumna = kolumna
@@ -40,13 +36,8 @@ class PoleKraty:
     wiersz = property(getWiersz, setWiersz)
     kolumna = property(getKolumna, setKolumna)
 
-    def skopiuj(self):
-        return PoleKraty(self.krata, self.wiersz, self.kolumna)
-
-
-class Krata(Obserwowany):
-    krata: []
 
+class Krata:
     def __init__(self, okno):
         self.okno = okno
         self.liczbaPolPoziomo = LICZBA_POL_W_POZIOMIE
@@ -62,8 +53,21 @@ class Krata(Obserwowany):
             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):
@@ -71,33 +75,27 @@ class Krata(Obserwowany):
                 start = (self.odstepMiedzyPolami + self.bokPola) * kolumna + self.odstepMiedzyPolami
                 gora = (self.odstepMiedzyPolami + self.bokPola) * wiersz + self.odstepMiedzyPolami
                 kolor_pola = ZawartoscPolaNaKolorPola[self.krata[wiersz][kolumna]]
-                if kolor_pola == IKONA:
-                    osoba_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'osoba2.png')),
-                                                         (BOK_AGENTA1, BOK_AGENTA1))
-                    self.okno.blit(osoba_ikona, [start, gora, self.bokPola, self.bokPola])
-                elif kolor_pola == KALUZA:
-                    osoba_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'kaluza.png')),
-                                                         (BOK_AGENTA1, BOK_AGENTA1))
-                    self.okno.blit(osoba_ikona, [start, gora, self.bokPola, self.bokPola])
-                elif kolor_pola == DYWAN:
-                    osoba_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'dywan.png')),
-                                                         (BOK_AGENTA1, BOK_AGENTA1))
-                    self.okno.blit(osoba_ikona, [start, gora, self.bokPola, self.bokPola])
-                elif kolor_pola == PACZKA:
-                    osoba_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'paczka.png')),
-                                                        (BOK_AGENTA1, BOK_AGENTA1))
-                    self.okno.blit(osoba_ikona, [start, gora, self.bokPola, self.bokPola])
-                else:
-                    pygame.draw.rect(self.okno, kolor_pola, [start, gora, self.bokPola, self.bokPola])
+                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 powiadomObserwatorow(self):
-        for obserwator in self.obserwatorzy:
-            obserwator.odbierzPowiadomienie(self)
+    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,263 +1,59 @@
-import ctypes
 import os
-import random
-import threading
+import ctypes
 
-import pygame.transform
-
-import szafka2
 from agent import *
-from neural_network import *
-from okno import *
 from ramy_czyli_wiedza_agenta import *
-from rescue import *
-from genetyczny import *
+from bfs import *
 
-# aby działalo w oknie + rozdzielczość ekranu
-# ctypes.windll.shcore.SetProcessDpiAwareness(1)
+#aby działalo w oknie + rozdzielczość ekranu
+#ctypes.windll.shcore.SetProcessDpiAwareness(1)
 
-okno_pygame = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
+Okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
 pygame.display.set_caption("Okno1")
-krata_magazynu = Krata(okno_pygame)
-Pomieszczenie = Pomieszczenie(WarunkiPowietrza(0, 0), 0)
+Krata = Krata(Okno)
+Pomieszczenie=Pomieszczenie(0,0)
 
 
 def dodaj_agenta():
-    # pole_lewe_gorne = PoleKraty(krata_magazynu, random.randint(0, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH),
+    # 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_magazynu, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH, int(LICZBA_POL_W_POZIOMIE / 2))
-    pole_lewe_gorne = PoleKraty(krata_magazynu, 0, 0)
-    pom = 'wozek_widlowy.png'
+    pole_lewe_gorne = PoleKraty(Krata, LICZBA_POL_W_PIONIE-BOK_AGENTA1_W_POLACH, int(LICZBA_POL_W_POZIOMIE/2))
+    pom = 'traktor_ikona.png'
     ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', pom)),
                                    (BOK_AGENTA1, BOK_AGENTA1))
-    Agent(krata_magazynu, pole_lewe_gorne, ikona)
-    # zawsze na poczatku polnoc
-    krata_magazynu.agent.kierunek = Kierunek.POLNOC
+    Agent(Krata, pole_lewe_gorne, ikona)
 
-
-def dodaj_szafke(numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz, poczatek_kolumna):
+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_wiersz,
-                    poczatek_kolumna, krata_magazynu)
+    szafka = Szafka(numerSzafki,wymiary_szafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna, poczatek_wiersz1, Krata)
     Pomieszczenie.dodajSzafke(szafka)
 
-
-def gdzie_paczka(numerSzafki):
-    global kolumna, wiersz
-    if numerSzafki == 1:
-        kolumna = random.randint(1, 2)
-        if kolumna == 1:
-            wiersz = random.randint(2, 13)
-        else:
-            wiersz = random.choice([1, 14])
-    if numerSzafki == 2:
-        kolumna = random.randint(3, 4)
-        if kolumna == 3:
-            wiersz = random.choice([1, 14])
-        else:
-            wiersz = random.randint(2, 13)
-    if numerSzafki == 3:
-        kolumna = random.randint(5, 8)
-        if kolumna == 5:
-            wiersz = random.randint(1, 5)
-        if kolumna == 6:
-            wiersz = random.choice([0, 6])
-        if kolumna == 7:
-            wiersz = random.choice([0, 7])
-        if kolumna == 8:
-            wiersz = random.randint(1, 6)
-    if numerSzafki == 4:
-        kolumna = random.randint(5, 8)
-        if kolumna == 5:
-            wiersz = random.randint(9, 12)
-        if kolumna == 6:
-            wiersz = random.choice([8, 13])
-        if kolumna == 7:
-            wiersz = random.choice([9, 13])
-        if kolumna == 8:
-            wiersz = random.randint(10, 12)
-    if numerSzafki == 5:
-        kolumna = random.randint(10, 12)
-        if kolumna == 11:
-            wiersz = random.choice([2, 11])
-        else:
-            wiersz = random.randint(3, 10)
-    if numerSzafki == 6:
-        kolumna = random.randint(12, 14)
-        if kolumna == 13:
-            wiersz = random.choice([1, 12])
-        else:
-            wiersz = random.randint(2, 11)
-    if numerSzafki == 7:
-        kolumna = random.randint(17, 19)
-        if kolumna == 18:
-            wiersz = random.choice([0, 13])
-        else:
-            wiersz = random.randint(1, 12)
-    if numerSzafki == 8:
-        kolumna = random.randint(22, 24)
-        if kolumna == 23:
-            wiersz = random.choice([4, 12])
-        else:
-            wiersz = random.randint(5, 11)
-    if numerSzafki == 9:
-        kolumna = random.randint(24, 26)
-        if kolumna == 25:
-            wiersz = random.choice([0, 13])
-        else:
-            wiersz = random.randint(1, 12)
-    if numerSzafki == 10:
-        kolumna = random.randint(27, 29)
-        if kolumna == 28:
-            wiersz = random.choice([4, 14])
-        else:
-            wiersz = random.randint(5, 13)
-    if numerSzafki == 11:
-        kolumna = 0
-        wiersz = 0
-    print(wiersz, kolumna)
-    return wiersz, kolumna
-
-
-def ustawienie():
-    ostatnia = recognition()
-    print(ostatnia)
-    kierunek = Kierunek(random.randint(0, 3))
-    wiersz, kolumna = gdzie_paczka(ostatnia + 1)
-    return Stan(kierunek, PoleKraty(krata_magazynu, wiersz, kolumna))
-
-
-def wroc():
-    kierunek = Kierunek(random.randint(0, 3))
-    wiersz, kolumna = gdzie_paczka(11)
-    return Stan(kierunek, PoleKraty(krata_magazynu, wiersz, kolumna))
-
-
-def zaznacz_cel_na_mapie(cel: Stan):
-    wiersz = cel.poleStartoweGorne.wiersz
-    kolumna = cel.poleStartoweGorne.kolumna
-    if krata_magazynu.krata[wiersz][kolumna] == ZawartoscPola.PUSTE:
-        krata_magazynu.krata[wiersz][kolumna] = ZawartoscPola.CEL
-
-
-def nadaj_cel_agentowi(agent: Agent, cel: Stan):
-    agent.cel = cel
-    zaznacz_cel_na_mapie(agent.cel)
-    print("CEL:", agent.cel.poleStartoweGorne.wiersz, agent.cel.poleStartoweGorne.kolumna)
-
-
-def zdarzenie_osoba():
-    global flaga1
-    flaga1 = 1
-
-
-def losowa_osoba():
-    wiersz = random.randint(0, krata_magazynu.liczbaPolPionowo - 1)
-    kolumna = random.randint(0, krata_magazynu.liczbaPolPoziomo - 1)
-    osoba = PoleKraty(krata_magazynu, wiersz, kolumna)
-    return osoba
-
-
 def main():
-    # dla kraty 30 x 15
-    dodaj_szafke("A", 2, 12, "P", 2, 2)
-    dodaj_szafke("B", 2, 12, "L", 2, 3)
-    dodaj_szafke("C", 2, 5, "P", 1, 6)
-    dodaj_szafke("D", 2, 6, "L", 1, 7)
-    dodaj_szafke("C", 2, 4, "P", 9, 6)
-    dodaj_szafke("D", 2, 3, "L", 10, 7)
-    dodaj_szafke("E", 2, 8, "P", 3, 11)
-    dodaj_szafke("F", 2, 10, "L", 2, 13)
-    dodaj_szafke("H", 2, 12, "L", 1, 18)
-    dodaj_szafke("I", 2, 7, "P", 5, 23)
-    dodaj_szafke("J", 2, 12, "L", 1, 25)
-    dodaj_szafke("G", 2, 9, "P", 5, 28)
-
-    # # dla kraty 10 x 10
-    # dodaj_szafke("A", 1, 8, "P", 1, 1)
-    # dodaj_szafke("B", 1, 8, "L", 1, 4)
-    # dodaj_szafke("C", 1, 8, "P", 1, 6)
-    # dodaj_szafke("C", 1, 8, "P", 1, 8)
-
-    # # dla kraty 5 x 5
-    # dodaj_szafke("A", 1, 3, "P", 1, 1)
-    # dodaj_szafke("B", 1, 3, "L", 1, 3)
-
-    for i in (
-            (1, 10), (1, 3), (3, 23), (2, 23), (5, 15), (4, 15), (9, 12), (11, 20), (11, 27), (11, 26), (14, 19),
-            (14, 18),
-            (14, 20), (8, 29), (9, 29)):
-        krata_magazynu.krata[i[0]][i[1]] = ZawartoscPola.DYWAN
-    for i in (
-            (0, 10), (13, 20), (13, 6), (13, 14), (14, 13), (9, 26), (9, 16), (9, 15), (9, 27), (9, 16), (9, 26),
-            (5, 8),
-            (5, 9), (7, 9), (7, 10)):
-        krata_magazynu.krata[i[0]][i[1]] = ZawartoscPola.KALUZA
-
-    for i in range(LICZBA_POL_W_PIONIE):
-        krata_magazynu.krata[i][21] = ZawartoscPola.SCIANA2
-    krata_magazynu.krata[0][21] = ZawartoscPola.PUSTE
-    krata_magazynu.krata[7][21] = ZawartoscPola.PUSTE
-    krata_magazynu.krata[14][21] = ZawartoscPola.PUSTE
-
+    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()
-    okno1 = Okno(krata_magazynu, krata_magazynu.agent)
-    okno1.wyswietlOkno()
+    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)
 
-    t = threading.Timer(5.0, zdarzenie_osoba).start()
-    osoba = PoleKraty(krata_magazynu, 0, 0)
-    clf = drzewo_decyzyjne()
-    global flaga1
-    flaga1 = 0
-
-    while True:
-        # 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_magazynu.agent.cel is None:
-            lista_paczek = []
-            #cyfra 5 oznacza ilosc paczek
-            for i in range(5):
-                cel = ustawienie()
-                wiersz_paczki = cel.poleStartoweGorne.wiersz
-                kolumna_paczki = cel.poleStartoweGorne.kolumna
-                lista_paczek.append((wiersz_paczki, kolumna_paczki))
-            print(lista_paczek)
-
-            algorytm = best_route(lista_paczek)
-            for j in range(5):
-                wiersz_cel = lista_paczek[algorytm[j]][0]
-                kolumna_cel = lista_paczek[algorytm[j]][1]
-                cel_po_algorytmu = Stan(Kierunek(random.randint(0, 3)), PoleKraty(krata_magazynu, wiersz_cel, kolumna_cel))
-                nadaj_cel_agentowi(krata_magazynu.agent, cel_po_algorytmu)
-                krata_magazynu.agent.idzDoCelu()
-        
-            cel = wroc()
-            nadaj_cel_agentowi(krata_magazynu.agent, cel)
-            krata_magazynu.agent.idzDoCelu()
-            
-
-        if flaga1 == 1:
-            osoba.krata.krata[osoba.wiersz][osoba.kolumna] = ZawartoscPola.PUSTE
-            okno1.wyswietlOkno()
-            osoba = losowa_osoba()
-            while osoba.krata.krata[osoba.wiersz][osoba.kolumna] != ZawartoscPola.PUSTE:
-                osoba = losowa_osoba()
-            osoba.krata.krata[osoba.wiersz][osoba.kolumna] = ZawartoscPola.OSOBA
-            okno1.wyswietlOkno()
-            pygame.time.wait(1000)
-            answer = decyzja_osoba(osoba, clf)
-            if answer == 1:
-                osoba.krata.krata[osoba.wiersz][osoba.kolumna] = ZawartoscPola.PUSTE
-                okno1.wyswietlOkno()
-                bieg = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'bieg.png')),
-                                              (BOK_AGENTA1, BOK_AGENTA1))
-                okno_pygame.blit(bieg, (osoba.kolumna * (BOK_POLA + 1) + 1, osoba.wiersz * (BOK_POLA + 1) + 1))
-                pygame.display.flip()
-                pygame.time.wait(1500)
-            flaga1 = 0
-            t = threading.Timer(5.0, zdarzenie_osoba).start()
-
-
-try:
-    main()
-except pygame.error:
+    klatkaz = pygame.time.Clock()
+    warunek_dzialania = True
+    while warunek_dzialania:
+        klatkaz.tick(FPS)
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                warunek_dzialania = False
+                break
+        Krata.wyswietlKrate()
     pygame.quit()
+
+main()

miejsce.py

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

neural_network.py

@@ -1,59 +0,0 @@
-import os
-import random
-
-import cv2
-import matplotlib.pyplot as plt
-import numpy as np
-import tensorflow as tf
-
-mnist = tf.keras.datasets.mnist
-(x_train, y_train), (x_test, y_test) = mnist.load_data()
-
-x_train = tf.keras.utils.normalize(x_train, axis=1)
-x_test = tf.keras.utils.normalize(x_test, axis=1)
-
-model = tf.keras.models.Sequential()
-model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))
-model.add(tf.keras.layers.Dense(128, activation='relu'))
-model.add(tf.keras.layers.Dense(128, activation='relu'))
-model.add(tf.keras.layers.Dense(10, activation='softmax'))
-
-model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
-
-model.fit(x_train, y_train, epochs=3)
-model.save('handwritten.model')
-
-model = tf.keras.models.load_model('handwritten.model')
-numery_paczek = []
-
-
-def liczby():
-    digits = []
-    for i in range(0, 3):
-        image_number = random.randint(1, 19)
-        img = cv2.imread(f"digits/digit{image_number}.png")[:, :, 0]
-        img = np.invert(np.array([img]))
-        prediction = model.predict(img)
-        print(f"This digit is probably a {np.argmax(prediction)}")
-        digits.append(np.argmax(prediction))
-        plt.imshow(img[0], cmap=plt.cm.binary)
-        plt.show()
-    liczba = int(str(digits[0]) + str(digits[1]) + str(digits[2]))
-    if liczba in numery_paczek or liczba < 100:
-        liczby()
-    else:
-        numery_paczek.append(liczba)
-    return numery_paczek[-1]
-
-
-def recognition():
-    try:
-        liczba = liczby()
-    except:
-        print("Error!")
-    ostatnia = liczba % 10
-    loss, accuracy = model.evaluate(x_test, y_test)
-    print(loss)
-    print(accuracy)
-    print(numery_paczek)
-    return ostatnia

obserwacja.py

@@ -1,31 +0,0 @@
-# https://refactoring.guru/pl/design-patterns/observer/python/example
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-
-
-class Obserwowany(ABC):
-    obserwatorzy = []
-
-    def dolaczObserwatora(self, obserwator: Obserwator):
-        self.obserwatorzy.append(obserwator)
-
-    def odlaczObserwatora(self, obserwator: Obserwator):
-        self.obserwatorzy.remove(obserwator)
-
-    @abstractmethod
-    def powiadomObserwatorow(self):
-        """
-        Notify all observers about an event.
-        """
-        pass
-
-
-class Obserwator(ABC):
-    @abstractmethod
-    def odbierzPowiadomienie(self, obserwowany: Obserwowany):
-        """
-        Receive update from subject.
-        """
-        pass

okno.py

@@ -1,23 +0,0 @@
-from krata import *
-
-
-class Okno(Obserwator):
-    def __init__(self, krata, agent):
-        self.krata = krata
-        self.agent = agent
-        self.krata.dolaczObserwatora(self)
-        self.agent.dolaczObserwatora(self)
-        self.klatkaz = pygame.time.Clock()
-
-    def wyswietlOkno(self):
-        self.klatkaz.tick(FPS)
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                # print("Użytkownik spróbował zamknąć okno.")
-                pygame.quit()
-        self.krata.narysujKrate()
-        self.agent.narysujAgenta()
-        pygame.display.update()
-
-    def odbierzPowiadomienie(self, obserwowany: Obserwowany):
-        self.wyswietlOkno()

ramy_czyli_wiedza_agenta.py

@@ -1,3 +1,5 @@
+from enumy_i_slowniki import *
+from stale import *
 from krata import *
 
 
@@ -9,8 +11,6 @@ class Wymiary:
 
 
 class Mapa:
-    mapa: []
-
     def __init__(self):
         self.liczbaPolPoziomo = LICZBA_POL_W_POZIOMIE
         self.liczbaPolPionowo = LICZBA_POL_W_PIONIE
@@ -20,13 +20,13 @@ class Mapa:
         self.agent = None
 
     def utworzPustaMape(self):
-        self.mapa = []
+        self.krata = []
         for wiersz in range(self.liczbaPolPionowo):
-            self.mapa.append([])
+            self.krata.append([])
             for kolumna in range(self.liczbaPolPoziomo):
                 zawartosc_pola = ZawartoscPola.PUSTE
                 nowe_pole = PoleMapy(self, wiersz, kolumna, zawartosc_pola)
-                self.mapa[wiersz].append(nowe_pole)
+                self.krata[wiersz].append(nowe_pole)
 
 
 class PoleMapy:
@@ -44,14 +44,14 @@ class WarunkiPowietrza:
         self.wilgotnosc = wilgotnosc
 
 
-class Miejsce:  # wcześniej półka
+class Miejsce: #wcześniej półka
     def __init__(self, numer, wymiary: Wymiary, udzwig, wysokoscOdPodlogi):
-        self.numer = numer
+        self.numer=numer
         self.wymiary = wymiary
         self.udzwig = udzwig
         self.wysokoscOdPodlogi = wysokoscOdPodlogi
-        # self.status = 'wolne'
-        self.dostep = []
+        #self.status = 'wolne'
+        self.dostep=[]
         self.zajmowanePola = []
 
     def dodajPole(self, pole: PoleKraty):
@@ -62,17 +62,15 @@ class Miejsce:  # wcześniej półka
 
 
 class Szafka:
-    def __init__(self, numerSzafki, wymiary: Wymiary, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna,
-                 poczatek_wiersz1, krata: Krata):
-        self.numerSzafki = numerSzafki
+    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.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)
@@ -80,32 +78,28 @@ class Szafka:
     def dodajPole(self, pole: PoleKraty):
         self.zajmowanePola.append(pole)
 
-    def utworzPustaSzafke(self, numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz1,
-                          poczatek_kolumna, krata: Krata):
+    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"
+                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)
+                        Krata.krata[poczatek_wiersz][poczatek_kolumna + n] = ZawartoscPola.SCIANA
+                        pole = PoleKraty(Krata, poczatek_wiersz, poczatek_kolumna+n)
                         miejsce.dodajPole(pole)
                         self.dodajPole(pole)
-                        if dostepZeStrony == "L":
-                            pole_dostepu = PoleKraty(krata, poczatek_wiersz,
-                                                     poczatek_kolumna + n - BOK_AGENTA1_W_POLACH)  # dostęp z lewej strony
+                        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 dostepZeStrony == "P":
-                            pole_dostepu = PoleKraty(krata, poczatek_wiersz,
-                                                     poczatek_kolumna + n + BOK_AGENTA1_W_POLACH)  # dostęp z prawej strony strony
+                        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
@@ -119,30 +113,26 @@ 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):
+    def __init__(self,wymiary: Wymiary, waga, etykieta: Etykieta):
         self.wymiary = wymiary
         self.waga = waga
         self.etykieta = etykieta
 
-
 class Paleta:
     def __init__(self):
         self.Paczki = []
@@ -150,21 +140,19 @@ 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):
-    #     self.priorytet =
+    #     self.priorytet =

rescue.py

@@ -1,53 +0,0 @@
-import random
-
-import pandas as pd
-import pydotplus
-from sklearn import metrics, tree
-from sklearn.tree import DecisionTreeClassifier
-
-from krata import *
-
-
-def drzewo_decyzyjne():
-    columns = ['plec', 'wiek', 'czas_w_pom', 'temp_w_pom', 'poziom_kurzu', 'poziom_oswietlenia', 'niebezp_towary',
-               'decyzja']
-    df = pd.read_csv("dataset.csv", header=0, sep=";", names=columns)
-    kolumny_x = ['plec', 'wiek', 'czas_w_pom', 'temp_w_pom', 'poziom_kurzu', 'poziom_oswietlenia', 'niebezp_towary']
-    x = df[kolumny_x]
-    y = df.decyzja
-    # df.info()
-    # X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
-    clf = DecisionTreeClassifier()
-    clf = clf.fit(x, y)
-    # print("Dokładność: ", metrics.accuracy_score(y_test, y_pred))
-
-    #  dot_data = tree.export_graphviz(clf, out_file=None, feature_names=kolumny_x, class_names=['0', '1'])
-    # graph = pydotplus.graph_from_dot_data(dot_data)
-    # graph.write_png('drzewo.png')
-
-    return clf
-
-
-def decyzja_osoba(osoba: PoleKraty, clf: DecisionTreeClassifier):
-    z = []
-    z.extend(random.choices([1, 2], weights=[1, 2], k=1))  # 1 kobieta, 2 mężczyzna
-    z.append(random.randint(18, 75))  # od 55 osoba starsza
-    z.append(random.randint(1,
-                            60))  # jak długo przebywa w pomieszczeniu, od 40 min długo, od 20 min średnio, do 20 min krótko
-    if osoba.kolumna > 21:
-        z.append(0)  # zimne pomieszczenie
-    else:
-        z.append(1)  # normalne pomieszczenie
-    z.append(random.randint(20, 100))  # poziom kurzu
-    z.append(random.randint(20, 100))  # poziom oświetlenia
-    if (0 <= osoba.wiersz or osoba.wiersz <= 13) and (
-            17 <= osoba.kolumna or osoba.kolumna <= 19):  # obok szafki z niebezpiecznymi towarami
-        z.append(1)
-    else:
-        z.append(0)
-    columns = ['plec', 'wiek', 'czas_w_pom', 'temp_w_pom', 'poziom_kurzu', 'poziom_oswietlenia', 'niebezp_towary']
-    z1 = pd.DataFrame([z], columns=columns)
-    z_pred = clf.predict(z1)
-    # print(z)
-    # print(z_pred)
-    return (z_pred)

stale.py

@@ -1,63 +1,50 @@
-import os
-
-import pygame
-
-FPS = 20
-#
-# SZEROKOSC_OKNA = 1500
-# WYSOKOSC_OKNA = 750
-#
-LICZBA_POL_W_POZIOMIE = 30
-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
-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)
-CZARNY = (0, 0, 0)
-CIEMNY_BRAZOWY1 = (60, 19, 33)
-ZOLTY1 = (231, 213, 69)
-NIEBIESKI1 = (65, 125, 225)
-IKONA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'osoba2.png')),
-                                               (BOK_AGENTA1, BOK_AGENTA1))
-KALUZA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'kaluza.png')),
-                                               (BOK_AGENTA1, BOK_AGENTA1))
-DYWAN = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'dywan.png')),
-                                               (BOK_AGENTA1, BOK_AGENTA1))
-PACZKA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'paczka.png')),
-                                               (BOK_AGENTA1, BOK_AGENTA1))
-###
-
-###
-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
+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

stan_nastepnik.py

@@ -1,99 +0,0 @@
-from krata import *
-
-
-class Akcja(Enum):
-    OBROT_W_LEWO = 0
-    OBROT_W_PRAWO = 1
-    KROK_W_PRZOD = 2
-
-
-class Stan:
-    def __init__(self, kierunek: Kierunek, poleStartoweGorne: PoleKraty):
-        self.kierunek = kierunek
-        self.poleStartoweGorne = poleStartoweGorne
-
-    def skopiuj(self):
-        return Stan(self.kierunek, self.poleStartoweGorne.skopiuj())
-
-
-class Nastepnik:
-    def __init__(self, akcja: Akcja or None, stan: Stan, poprzednik):
-        self.akcja = akcja
-        self.stan = stan
-        self._poprzednik = poprzednik
-
-    def getPoprzednik(self):
-        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 mozna_wjechac_na_pole(pole: PoleKraty):
-    if pole.krata.krata[pole.wiersz][pole.kolumna] != ZawartoscPola.SCIANA and pole.krata.krata[pole.wiersz][
-        pole.kolumna] != ZawartoscPola.SCIANA2 and pole.krata.krata[pole.wiersz][pole.kolumna] != ZawartoscPola.OSOBA:
-        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 mozna_wjechac_na_pole(
-            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

szafka2.py

@@ -1,37 +1,37 @@
-import random
-
 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.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)
+         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
+            k=k+1
+            if k>self.iloscMiejscNaPolce-1:
+                j=j+1
+                k=0
+
+         self.listaWolnychMiejsc = self.listaMiejsc.copy()
 
-        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"
+        if len(self.listaWolnychMiejsc)!=0:
+            self.listaWolnychMiejsc[0].numerUmieszczonejPaczki=numerPaczki
+            self.listaWolnychMiejsc[0].status="zajęte"
             self.listaWolnychMiejsc.pop(0)
+
+