htretrhj

.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 (jakiesvirtualneenv)" 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 (jakiesvirtualneenv)" 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,189 +0,0 @@
-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

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

@@ -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

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

etykieta.py

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

@@ -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,103 +0,0 @@
-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,263 +1,369 @@
-import ctypes
 import os
 import random
-import threading
 
-import pygame.transform
+import pygame
 
-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 enumy_i_slowniki import *
 
-# aby działalo w oknie + rozdzielczość ekranu
-# ctypes.windll.shcore.SetProcessDpiAwareness(1)
-
-okno_pygame = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
-pygame.display.set_caption("Okno1")
-krata_magazynu = Krata(okno_pygame)
-Pomieszczenie = Pomieszczenie(WarunkiPowietrza(0, 0), 0)
+#
+okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
+#
+droga_A = [[False, w, 7] for w in range(LICZBA_POL_W_PIONIE)]
+swiatlo_A = Swiatlo.CZERWONE
+pole_postojowe_A = (9, 7)
+sygnalizator_A = ((10, 9), (11, 9), (12, 9))
+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 dodaj_agenta():
-    # pole_lewe_gorne = PoleKraty(krata_magazynu, 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'
-    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 wyswietl_okno():
+    pygame.time.Clock().tick(FPS)
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            # print("Użytkownik spróbował zamknąć okno.")
+            pygame.quit()
+    narysuj_krate()
+    narysuj_pojazdy()
+    pygame.display.update()
 
 
-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 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 gdzie_paczka(numerSzafki):
-    global kolumna, wiersz
-    if numerSzafki == 1:
-        kolumna = random.randint(1, 2)
-        if kolumna == 1:
-            wiersz = random.randint(2, 13)
+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:
-            wiersz = random.choice([1, 14])
-    if numerSzafki == 2:
-        kolumna = random.randint(3, 4)
-        if kolumna == 3:
-            wiersz = random.choice([1, 14])
+                if not droga[i - 1][0]:
+                    nowa_droga[i][0] = False
+                    nowa_droga[i - 1][0] = True
                 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
+                    nowa_droga[i][0] = True
+    return nowa_droga
 
 
-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 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 wroc():
-    kierunek = Kierunek(random.randint(0, 3))
-    wiersz, kolumna = gdzie_paczka(11)
-    return Stan(kierunek, PoleKraty(krata_magazynu, wiersz, kolumna))
+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 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 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 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 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 zdarzenie_osoba():
-    global flaga1
-    flaga1 = 1
+def Czerwone_Czerwone_do_Zielone_Czerwone():
+    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"
 
 
-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 Czerwone_Czerwone_do_Czerwone_Zielone():
+    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"
 
 
-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)
+def CzerwoneZZoltym_Czerwone():
+    return swiatlo_A == Swiatlo.CZERWONE_Z_ZOLTYM and swiatlo_B == Swiatlo.CZERWONE
 
-    # # 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)
+def Zielone_Czerwone_1():
+    return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"
 
-    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
+def Zielone_Czerwone_2():
+    return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"
 
-    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
+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:
-        # 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()
+    # 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

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

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

@@ -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,11 +1,4 @@
-import os
-
-import pygame
-
-FPS = 20
-#
-# SZEROKOSC_OKNA = 1500
-# WYSOKOSC_OKNA = 750
+FPS = 2
 #
 LICZBA_POL_W_POZIOMIE = 30
 LICZBA_POL_W_PIONIE = 15
@@ -14,50 +7,17 @@ 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
+BOK_AGENTA_W_POLACH = 1
+BOK_AGENTA = BOK_AGENTA_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
 #
 BIALY = (255, 255, 255)
-JASNOSZARY1 = (200, 200, 200)
-SZARY1 = (150, 150, 150)
+JASNOSZARY = (200, 200, 200)
+SZARY = (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)
+CZERWONY = (255, 0, 0)
+ZOLTY = (255, 255, 0)
+ZIELONY = (0, 255, 0)
 #
-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
+CZAS_ZMIANY_NA_SYGNALIZATORZE = 1500
+CZAS_CYKLU = 6000

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