.idea/Sztuczna_Inteligencja_Gr16.iml

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

.idea/misc.xml

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

a_gwiazdka.py

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,189 @@
+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):
+    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
+        self.poleStartoweGorne = poleStartoweGorne
+        self.tekstura = tekstura
+        self.okreslPolozenie()
+        self.obierzLosowyKierunek()
+        # self.okreslDlugoscDrogi()
+        krata.agent = self
+        self.cel = None
+
+    # 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 obierzLosowyKierunek(self):
+        self.kierunek = Kierunek(random.randint(0, 3))
+        # if self.maxDlugoscDrogiWMoimKierunku() < 1:
+        #     self.obierzLosowyKierunek()
+
+    # def okreslDlugoscDrogi(self):
+    #     self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
+
+    def cofnijSie(self):
+        self.zrobKrokWOdwrotnymKierunku()
+        self.okreslPolozenie()
+
+    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)
+
+    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
+
+    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.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
+
+    def maxDlugoscDrogiWMoimKierunku(self):
+        if self.kierunek == Kierunek.POLNOC:
+            return self.poleStartoweGorne.wiersz
+        elif self.kierunek == Kierunek.POLUDNIE:
+            return self.krata.liczbaPolPionowo - self.poleKoncoweDolne.wiersz - 1
+        elif self.kierunek == Kierunek.ZACHOD:
+            return self.poleStartoweGorne.kolumna
+        elif self.kierunek == Kierunek.WSCHOD:
+            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()
+
+    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()
+
+    def idzNaPolnoc(self):
+        self.poleStartoweGorne.wiersz -= 1
+
+    def idzNaPoludnie(self):
+        self.poleStartoweGorne.wiersz += 1
+
+    def idzNaZachod(self):
+        self.poleStartoweGorne.kolumna -= 1
+
+    def idzNaWschod(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 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)

algorytmy_genetyczne.py

@@ -0,0 +1,374 @@
+
+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

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

dataset.csv

@@ -0,0 +1,201 @@
+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

@@ -3,27 +3,69 @@ from enum import Enum
 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
+
+
 class ZawartoscPola(Enum):
     PUSTE = 0
     SCIANA = 1
-    SCIANA2 = 2
+    CEL = 2
-    SYGNALIZATOR_CZERWONY = 3
+    DYWAN = 3
-    SYGNALIZATOR_ZOLTY = 4
+    KALUZA = 4
-    SYGNALIZATOR_ZIELONY = 5
+    SCIANA2 = 5
-
+    OSOBA = 6
-
-class Swiatlo(Enum):
-    CZERWONE = 0
-    CZERWONE_Z_ZOLTYM = 1
-    ZIELONE = 2
-    ZOLTE = 3
 
 
 ZawartoscPolaNaKolorPola = {
-    ZawartoscPola.PUSTE: CZARNY,
+    ZawartoscPola.PUSTE: BIALY,
-    ZawartoscPola.SCIANA: JASNOSZARY,
+    ZawartoscPola.SCIANA: CIEMNY_BRAZOWY1,
-    ZawartoscPola.SCIANA2: SZARY,
+    ZawartoscPola.CEL: PACZKA,
-    ZawartoscPola.SYGNALIZATOR_CZERWONY: CZERWONY,
+    ZawartoscPola.DYWAN: DYWAN,
-    ZawartoscPola.SYGNALIZATOR_ZOLTY: ZOLTY,
+    ZawartoscPola.KALUZA: KALUZA,
-    ZawartoscPola.SYGNALIZATOR_ZIELONY: ZIELONY
+    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
 }

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

genetyczny.py

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,103 @@
+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
+        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)
+
+    def skopiuj(self):
+        return PoleKraty(self.krata, self.wiersz, self.kolumna)
+
+
+class Krata(Obserwowany):
+    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
+                self.krata[wiersz].append(zawartosc_pola)
+
+    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]]
+                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])
+
+    def narysujKrateAlternatywnie(self):
+        self.okno.fill(SZARY1)
+        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)

main.py

@@ -1,369 +1,263 @@
+import ctypes
 import os
 import random
+import threading
 
-import pygame
+import pygame.transform
 
-from enumy_i_slowniki import *
+import szafka2
+from agent import *
+from neural_network import *
+from okno import *
+from ramy_czyli_wiedza_agenta import *
+from rescue import *
+from genetyczny import *
 
-#
+# aby działalo w oknie + rozdzielczość ekranu
-okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
+# ctypes.windll.shcore.SetProcessDpiAwareness(1)
-#
+
-droga_A = [[False, w, 7] for w in range(LICZBA_POL_W_PIONIE)]
+okno_pygame = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
-swiatlo_A = Swiatlo.CZERWONE
+pygame.display.set_caption("Okno1")
-pole_postojowe_A = (9, 7)
+krata_magazynu = Krata(okno_pygame)
-sygnalizator_A = ((10, 9), (11, 9), (12, 9))
+Pomieszczenie = Pomieszczenie(WarunkiPowietrza(0, 0), 0)
-indeks_petli_A = None
-for i in range(len(droga_A)):
-    x = droga_A[i]
-    if x[1] == pole_postojowe_A[0] and x[2] == pole_postojowe_A[1]:
-        indeks_petli_A = i
-#
-droga_B = [[False, w, 7] for w in range(0, 7)] + [[False, 7, k] for k in range(7, LICZBA_POL_W_POZIOMIE)]
-swiatlo_B = Swiatlo.ZIELONE
-pole_postojowe_B = (7, 8)
-sygnalizator_B = ((3, 10), (4, 10), (5, 10))
-indeks_petli_B = None
-for i in range(len(droga_B)):
-    x = droga_B[i]
-    if x[1] == pole_postojowe_B[0] and x[2] == pole_postojowe_B[1]:
-        indeks_petli_B = i
-#
-krata = [[_ for _ in range(LICZBA_POL_W_POZIOMIE)] for _ in range(LICZBA_POL_W_PIONIE)]
-#
-for w in range(LICZBA_POL_W_PIONIE):
-    for k in range(LICZBA_POL_W_POZIOMIE):
-        krata[w][k] = ZawartoscPola.SCIANA2
-#
-for w in range(LICZBA_POL_W_PIONIE):
-    krata[w][5] = ZawartoscPola.SCIANA
-    krata[w][6] = ZawartoscPola.PUSTE
-    krata[w][7] = ZawartoscPola.PUSTE
-    krata[w][8] = ZawartoscPola.SCIANA
-#
-krata[7][8] = ZawartoscPola.PUSTE
-krata[8][8] = ZawartoscPola.PUSTE
-#
-for w in [7, 8]:
-    for k in range(8, LICZBA_POL_W_POZIOMIE):
-        krata[w][k] = ZawartoscPola.PUSTE
-#
-for k in range(8, LICZBA_POL_W_POZIOMIE):
-    krata[6][k] = ZawartoscPola.SCIANA
-for k in range(8, LICZBA_POL_W_POZIOMIE):
-    krata[9][k] = ZawartoscPola.SCIANA
 
 
-def wyswietl_okno():
+def dodaj_agenta():
-    pygame.time.Clock().tick(FPS)
+    # pole_lewe_gorne = PoleKraty(krata_magazynu, random.randint(0, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH),
-    for event in pygame.event.get():
+    # random.randint(0, LICZBA_POL_W_POZIOMIE - BOK_AGENTA1_W_POLACH))
-        if event.type == pygame.QUIT:
+    # pole_lewe_gorne = PoleKraty(krata_magazynu, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH, int(LICZBA_POL_W_POZIOMIE / 2))
-            # print("Użytkownik spróbował zamknąć okno.")
+    pole_lewe_gorne = PoleKraty(krata_magazynu, 0, 0)
+    pom = 'wozek_widlowy.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
+
+
+def dodaj_szafke(numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz, poczatek_kolumna):
+    wymiary_szafki = Wymiary(0, 0, 0)
+    szafka = Szafka(numerSzafki, wymiary_szafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz,
+                    poczatek_kolumna, krata_magazynu)
+    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_agenta()
+    okno1 = Okno(krata_magazynu, krata_magazynu.agent)
+    okno1.wyswietlOkno()
+
+    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:
     pygame.quit()
-    narysuj_krate()
-    narysuj_pojazdy()
-    pygame.display.update()
-
-
-def narysuj_krate():
-    okno.fill(SZARY)
-    for wiersz in range(LICZBA_POL_W_PIONIE):
-        for kolumna in range(LICZBA_POL_W_POZIOMIE):
-            start = (ODSTEP_MIEDZY_POLAMI + BOK_POLA) * kolumna + ODSTEP_MIEDZY_POLAMI
-            gora = (ODSTEP_MIEDZY_POLAMI + BOK_POLA) * wiersz + ODSTEP_MIEDZY_POLAMI
-            kolor_pola = ZawartoscPolaNaKolorPola[krata[wiersz][kolumna]]
-            pygame.draw.rect(okno, kolor_pola, [start, gora, BOK_POLA, BOK_POLA])
-
-
-def narysuj_pojazdy():
-    ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'auto.png')), (BOK_AGENTA, BOK_AGENTA))
-    for x in droga_A:
-        if x[0]:
-            okno.blit(ikona, ((BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[2] + ODSTEP_MIEDZY_POLAMI,
-                              (BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[1] + ODSTEP_MIEDZY_POLAMI))
-    ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'auto2.png')), (BOK_AGENTA, BOK_AGENTA))
-    for x in droga_B:
-        if x[0]:
-            okno.blit(ikona, ((BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[2] + ODSTEP_MIEDZY_POLAMI,
-                              (BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[1] + ODSTEP_MIEDZY_POLAMI))
-
-
-def rusz_pojazdy_na_drodze(droga, pole_postojowe, swiatlo):
-    nowa_droga = [[False, x[1], x[2]] for x in droga]
-    for i in range(len(droga) - 1, 0, -1):
-        x = droga[i]
-        if x[0]:
-            if x[1] == pole_postojowe[0] and x[2] == pole_postojowe[1] and swiatlo != Swiatlo.ZIELONE:
-                nowa_droga[i][0] = True
-            else:
-                if not droga[i - 1][0]:
-                    nowa_droga[i][0] = False
-                    nowa_droga[i - 1][0] = True
-                else:
-                    nowa_droga[i][0] = True
-    return nowa_droga
-
-
-def ustaw_czerwone(sygnalizator):
-    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SYGNALIZATOR_CZERWONY
-    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SCIANA2
-    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
-
-
-def ustaw_czerwone_z_zoltym(sygnalizator):
-    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SYGNALIZATOR_CZERWONY
-    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SYGNALIZATOR_ZOLTY
-    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
-
-
-def ustaw_zolte(sygnalizator):
-    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SCIANA2
-    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SYGNALIZATOR_ZOLTY
-    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
-
-
-def ustaw_zielone(sygnalizator):
-    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SCIANA2
-    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SCIANA2
-    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SYGNALIZATOR_ZIELONY
-
-
-def Czerwone_Czerwone_do_Zielone_Czerwone():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"
-
-
-def Czerwone_Czerwone_do_Czerwone_Zielone():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"
-
-
-def CzerwoneZZoltym_Czerwone():
-    return swiatlo_A == Swiatlo.CZERWONE_Z_ZOLTYM and swiatlo_B == Swiatlo.CZERWONE
-
-
-def Zielone_Czerwone_1():
-    return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"
-
-
-def Zielone_Czerwone_2():
-    return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"
-
-
-def Zolte_Czerwone():
-    return swiatlo_A == Swiatlo.ZOLTE and swiatlo_B == Swiatlo.CZERWONE
-
-
-def Czerwone_CzerwoneZZoltym():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE_Z_ZOLTYM
-
-
-def Czerwone_Zielone():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.ZIELONE
-
-
-def Czerwone_Zolte():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.ZOLTE
-
-
-def O_O():
-    return (not droga_A[indeks_petli_A][0]) and (not droga_B[indeks_petli_B][0])
-
-
-def A_O():
-    return (droga_A[indeks_petli_A][0]) and (not droga_B[indeks_petli_B][0])
-
-
-def O_B():
-    return (not droga_A[indeks_petli_A][0]) and (droga_B[indeks_petli_B][0])
-
-
-def A_B():
-    return (droga_A[indeks_petli_A][0]) and (droga_B[indeks_petli_B][0])
-
-
-def ustaw_Czerwone_Czerwone_do_Czerwone_Zielone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-    global poprzednio
-    poprzednio = "A"
-
-
-def ustaw_Czerwone_Czerwone_do_Zielone_Czerwone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-    global poprzednio
-    poprzednio = "B"
-
-
-def ustaw_CzerwoneZZoltym_Czerwone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE_Z_ZOLTYM
-    ustaw_czerwone_z_zoltym(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-
-
-def ustaw_Zielone_Czerwone_1():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.ZIELONE
-    ustaw_zielone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-    global poprzednio
-    poprzednio = "B"
-
-
-def ustaw_Zielone_Czerwone_2():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.ZIELONE
-    ustaw_zielone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-    global poprzednio
-    poprzednio = "A"
-
-
-def ustaw_Zolte_Czerwone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.ZOLTE
-    ustaw_zolte(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-
-
-def ustaw_Czerwone_CzerwoneZZoltym():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE_Z_ZOLTYM
-    ustaw_czerwone_z_zoltym(sygnalizator_B)
-
-
-def ustaw_Czerwone_Zielone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.ZIELONE
-    ustaw_zielone(sygnalizator_B)
-
-
-def ustaw_Czerwone_Zolte():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.ZOLTE
-    ustaw_zolte(sygnalizator_B)
-
-
-droga_A[14][0] = True
-droga_A[12][0] = True
-droga_A[10][0] = True
-droga_A[9][0] = True
-droga_B[len(droga_B) - 1][0] = True
-droga_B[len(droga_B) - 2][0] = True
-droga_B[len(droga_B) - 6][0] = True
-droga_B[5][0] = True
-
-czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-ustaw_Czerwone_Czerwone_do_Zielone_Czerwone()
-poprzednio = "B"
-
-while True:
-    # print(droga_A[indeks_petli_A][0],droga_B[indeks_petli_B][0])
-    if O_O():
-        print("O - O")
-    elif A_O():
-        print("A - O")
-    elif A_B():
-        print("A - B")
-    elif O_B():
-        print("O - B")
-    czas_od_ostatniej_zmiany_swiatel = pygame.time.get_ticks() - czas_ostatniej_zmiany_swiatel
-    if Czerwone_Czerwone_do_Zielone_Czerwone():
-        print("Czerwone - Czerwone do Zielone - Czerwone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if O_O() or A_O() or A_B():
-                ustaw_CzerwoneZZoltym_Czerwone()
-            elif O_B():
-                ustaw_Czerwone_CzerwoneZZoltym()
-    elif CzerwoneZZoltym_Czerwone():
-        print("Czerwone z Zoltym - Czerwone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            ustaw_Zielone_Czerwone_1()
-    elif Zielone_Czerwone_1():
-        print("Zielone - Czerwone 1")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if O_O() or A_O() or A_B():
-                ustaw_Zielone_Czerwone_2()
-            elif O_B():
-                ustaw_Zolte_Czerwone()
-    elif Zielone_Czerwone_2():
-        print("Zielone - Czerwone 2")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if O_O() or A_O():
-                pass
-            elif O_B() or A_B():
-                ustaw_Zolte_Czerwone()
-    elif Zolte_Czerwone():
-        print("Zolte - Czerwone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            ustaw_Czerwone_Czerwone_do_Czerwone_Zielone()
-    elif Czerwone_CzerwoneZZoltym():
-        print("Czerwone  - Czerwone z Zoltym")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            ustaw_Czerwone_Zielone()
-    elif Czerwone_Zielone():
-        print("Czerwone - Zielone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if O_B():
-                pass
-            elif O_O() or A_O() or A_B():
-                ustaw_Czerwone_Zolte()
-    elif Czerwone_Zolte():
-        print("Czerwone - Zolte")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            ustaw_Czerwone_Czerwone_do_Zielone_Czerwone()
-    elif Czerwone_Czerwone_do_Czerwone_Zielone():
-        print("Czerwone - Czerwone do Czerwone - Zielone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if A_O():
-                ustaw_CzerwoneZZoltym_Czerwone()
-            elif O_O() or O_B() or A_B():
-                ustaw_Czerwone_CzerwoneZZoltym()
-    #
-    wyswietl_okno()
-    droga_A = rusz_pojazdy_na_drodze(droga_A, pole_postojowe_A, swiatlo_A)
-    droga_B = rusz_pojazdy_na_drodze(droga_B, pole_postojowe_B, swiatlo_B)
-    #
-    los = random.random()
-    liczba_samochodow = len([x for x in droga_A if x[0]])
-    maks_samochodow = 7
-    szansa = (maks_samochodow - liczba_samochodow) / maks_samochodow -0.7
-    if los < szansa:
-        droga_A[len(droga_A) - 1][0] = True
-    #
-    liczba_samochodow = len([x for x in droga_B if x[0]])
-    maks_samochodow = 6
-    szansa = (maks_samochodow - liczba_samochodow) / maks_samochodow - 0.4
-    if los < szansa:
-        droga_B[len(droga_B) - 1][0] = True

miejsce.py

@@ -0,0 +1,8 @@
+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 = ''

neural_network.py

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,170 @@
+from krata import *
+
+
+class Wymiary:
+    def __init__(self, dlugosc, szerokosc, wysokosc):
+        self.dlugosc = dlugosc
+        self.szerokosc = szerokosc
+        self.wysokosc = wysokosc
+
+
+class Mapa:
+    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.mapa = []
+        for wiersz in range(self.liczbaPolPionowo):
+            self.mapa.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)
+
+
+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, dostepZeStrony, 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 dostepZeStrony == "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
+                            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 =

rescue.py

@@ -0,0 +1,53 @@
+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,4 +1,11 @@
-FPS = 2
+import os
+
+import pygame
+
+FPS = 20
+#
+# SZEROKOSC_OKNA = 1500
+# WYSOKOSC_OKNA = 750
 #
 LICZBA_POL_W_POZIOMIE = 30
 LICZBA_POL_W_PIONIE = 15
@@ -7,17 +14,50 @@ 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_AGENTA_W_POLACH = 1
+BOK_AGENTA1_W_POLACH = 1
-BOK_AGENTA = BOK_AGENTA_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
+BOK_AGENTA1 = BOK_AGENTA1_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
+#
+DUZA_SZAFA = 1
 #
 BIALY = (255, 255, 255)
-JASNOSZARY = (200, 200, 200)
+JASNOSZARY1 = (200, 200, 200)
-SZARY = (150, 150, 150)
+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)
 #
-CZERWONY = (255, 0, 0)
+# NUMBER_OF_BLOCKS_WIDE=8
-ZOLTY = (255, 255, 0)
+# NUMBER_OF_BLOCKS_HIGH=8
-ZIELONY = (0, 255, 0)
+# BLOCK_HEIGHT=round(SZEROKOSC_OKNA/NUMBER_OF_BLOCKS_HIGH)
+# BLOCK_WIDTH=round(WYSOKOSC_OKNA/NUMBER_OF_BLOCKS_WIDE)
 #
-CZAS_ZMIANY_NA_SYGNALIZATORZE = 1500
+MAPFILE = "map.txt"
-CZAS_CYKLU = 6000
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +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.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)