Update 'main.py'

3.9 a miało był 3.8

.idea/Sztuczna_Inteligencja_Gr16.iml

@@ -4,7 +4,7 @@
     <content url="file://$MODULE_DIR$">
       <excludeFolder url="file://$MODULE_DIR$/venv" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.10 (Sztuczna_Inteligencja_Gr16)" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.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.10 (Sztuczna_Inteligencja_Gr16)" 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

@@ -1,40 +1,51 @@
 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:
+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, poleStartoweGorne, tekstura):
+    def __init__(self, krata: Krata, poleStartoweGorne: PoleKraty, tekstura):
-        self.krata = Krata
+        self.krata = krata
         self.poleStartoweGorne = poleStartoweGorne
         self.tekstura = tekstura
         self.okreslPolozenie()
-        self.obierzNowyKierunek()
+        self.obierzLosowyKierunek()
-        self.okreslDlugoscDrogi()
+        # self.okreslDlugoscDrogi()
-        Krata.agent = self
+        krata.agent = self
+        self.cel = None
 
-    def ruszSie(self):
+    # def ruszSie(self):
-        if self.droga <= 0:
+    #     if self.droga <= 0:
-            self.obierzNowyKierunek()
+    #         self.obierzLosowyKierunek()
-            self.okreslDlugoscDrogi()
+    #         self.okreslDlugoscDrogi()
-        self.zrobKrokWMoimKierunku()
+    #     self.zrobKrokWMoimKierunku()
-        self.droga -= 1
+    #     self.droga -= 1
-        self.okreslPolozenie()
+    #     self.okreslPolozenie()
-        if self.wyszedlemPozaKrate():
+    #     if self.wyszedlemPozaKrate() or self.wszedlemWSciane():
-            self.cofnijSie()
+    #         self.cofnijSie()
-            self.zawroc()
+    #         self.zawroc()
-            self.okreslDlugoscDrogi()
+    #         self.okreslDlugoscDrogi()
 
-    def obierzNowyKierunek(self):
+    def obierzLosowyKierunek(self):
         self.kierunek = Kierunek(random.randint(0, 3))
-        if self.maxDlugoscDrogiWMoimKierunku() < 1:
+        # if self.maxDlugoscDrogiWMoimKierunku() < 1:
-            self.obierzNowyKierunek()
+        #     self.obierzLosowyKierunek()
 
-    def okreslDlugoscDrogi(self):
+    # def okreslDlugoscDrogi(self):
-        self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
+    #     self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
 
     def cofnijSie(self):
         self.zrobKrokWOdwrotnymKierunku()
@@ -43,6 +54,7 @@ class Agent:
     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)
@@ -64,54 +76,114 @@ class Agent:
         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.GORA:
+        if self.kierunek == Kierunek.POLNOC:
-            self.kierunek = Kierunek.DOL
+            self.kierunek = Kierunek.POLUDNIE
-        elif self.kierunek == Kierunek.DOL:
+        elif self.kierunek == Kierunek.POLUDNIE:
-            self.kierunek = Kierunek.GORA
+            self.kierunek = Kierunek.POLNOC
-        elif self.kierunek == Kierunek.LEWO:
+        elif self.kierunek == Kierunek.ZACHOD:
-            self.kierunek = Kierunek.PRAWO
+            self.kierunek = Kierunek.WSCHOD
-        elif self.kierunek == Kierunek.PRAWO:
+        elif self.kierunek == Kierunek.WSCHOD:
-            self.kierunek = Kierunek.LEWO
+            self.kierunek = Kierunek.ZACHOD
 
     def maxDlugoscDrogiWMoimKierunku(self):
-        if self.kierunek == Kierunek.GORA:
+        if self.kierunek == Kierunek.POLNOC:
             return self.poleStartoweGorne.wiersz
-        elif self.kierunek == Kierunek.DOL:
+        elif self.kierunek == Kierunek.POLUDNIE:
             return self.krata.liczbaPolPionowo - self.poleKoncoweDolne.wiersz - 1
-        elif self.kierunek == Kierunek.LEWO:
+        elif self.kierunek == Kierunek.ZACHOD:
             return self.poleStartoweGorne.kolumna
-        elif self.kierunek == Kierunek.PRAWO:
+        elif self.kierunek == Kierunek.WSCHOD:
             return self.krata.liczbaPolPoziomo - self.poleKoncoweDolne.kolumna - 1
 
     def zrobKrokWMoimKierunku(self):
-        if self.kierunek == Kierunek.GORA:
+        if self.kierunek == Kierunek.POLNOC:
-            self.idzWGore()
+            self.idzNaPolnoc()
-        elif self.kierunek == Kierunek.DOL:
+        elif self.kierunek == Kierunek.POLUDNIE:
-            self.idzWDol()
+            self.idzNaPoludnie()
-        elif self.kierunek == Kierunek.LEWO:
+        elif self.kierunek == Kierunek.ZACHOD:
-            self.idzWLewo()
+            self.idzNaZachod()
-        elif self.kierunek == Kierunek.PRAWO:
+        elif self.kierunek == Kierunek.WSCHOD:
-            self.idzWPrawo()
+            self.idzNaWschod()
 
     def zrobKrokWOdwrotnymKierunku(self):
-        if self.kierunek == Kierunek.GORA:
+        if self.kierunek == Kierunek.POLNOC:
-            self.idzWDol()
+            self.idzNaPoludnie()
-        elif self.kierunek == Kierunek.DOL:
+        elif self.kierunek == Kierunek.POLUDNIE:
-            self.idzWGore()
+            self.idzNaPolnoc()
-        elif self.kierunek == Kierunek.LEWO:
+        elif self.kierunek == Kierunek.ZACHOD:
-            self.idzWPrawo()
+            self.idzNaWschod()
-        elif self.kierunek == Kierunek.PRAWO:
+        elif self.kierunek == Kierunek.WSCHOD:
-            self.idzWLewo()
+            self.idzNaZachod()
 
-    def idzWGore(self):
+    def idzNaPolnoc(self):
         self.poleStartoweGorne.wiersz -= 1
 
-    def idzWDol(self):
+    def idzNaPoludnie(self):
         self.poleStartoweGorne.wiersz += 1
 
-    def idzWLewo(self):
+    def idzNaZachod(self):
         self.poleStartoweGorne.kolumna -= 1
 
-    def idzWPrawo(self):
+    def idzNaWschod(self):
         self.poleStartoweGorne.kolumna += 1
+
+    def 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.py

@@ -1,14 +0,0 @@
-from enum import Enum
-
-
-class Kierunek(Enum):
-    GORA = 0
-    DOL = 1
-    LEWO = 2
-    PRAWO = 3
-
-
-class ZawartoscPola(Enum):
-    PUSTE = 0
-    AGENT = 1
-    LAWA = 2

enumy_i_slowniki.py

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

etykieta.py

@@ -1,5 +1,7 @@
-nazwa_paczki =""
+class Etykieta:
-producent =""
+    def __init__(self, nazwa_paczki, producent, numer_paczki, cecha_paczki, data_wysylki):
-numer_paczki=int
+        self.nazwa_paczki = nazwa_paczki
-cecha_paczki =""
+        self.producent = producent
-data_wysylki= ""
+        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

@@ -1,12 +1,16 @@
 import pygame
 
-from enumy import *
+from enumy_i_slowniki import *
+from obserwacja import *
 from stale import *
 
 
 class PoleKraty:
-    def __init__(self, Krata, wiersz, kolumna):
+    gora: any
-        self.krata = Krata
+    start: any
+
+    def __init__(self, krata, wiersz, kolumna):
+        self.krata = krata
         self.bok = self.krata.bokPola
         self._wiersz = wiersz
         self._kolumna = kolumna
@@ -36,38 +40,64 @@ class PoleKraty:
     wiersz = property(getWiersz, setWiersz)
     kolumna = property(getKolumna, setKolumna)
 
+    def skopiuj(self):
+        return PoleKraty(self.krata, self.wiersz, self.kolumna)
+
+
+class Krata(Obserwowany):
+    krata: []
 
-class Krata:
     def __init__(self, okno):
         self.okno = okno
         self.liczbaPolPoziomo = LICZBA_POL_W_POZIOMIE
         self.liczbaPolPionowo = LICZBA_POL_W_PIONIE
         self.bokPola = BOK_POLA
         self.odstepMiedzyPolami = ODSTEP_MIEDZY_POLAMI
-        self.krata = self.utworzPustaKrate()
+        self.utworzPustaKrate()
         self.agent = None
 
     def utworzPustaKrate(self):
         self.krata = []
-        for rzad in range(self.liczbaPolPionowo):
+        for wiersz in range(self.liczbaPolPionowo):
             self.krata.append([])
             for kolumna in range(self.liczbaPolPoziomo):
-                self.krata[rzad].append(ZawartoscPola.PUSTE)
+                zawartosc_pola = ZawartoscPola.PUSTE
-
+                self.krata[wiersz].append(zawartosc_pola)
-    def wyswietlKrate(self):
-        self.narysujKrate()
-        self.narysujAgenta()
-        pygame.display.update()
 
     def narysujKrate(self):
         self.okno.fill(SZARY1)
-        for rzad in range(self.liczbaPolPionowo):
+        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) * rzad + self.odstepMiedzyPolami
+                gora = (self.odstepMiedzyPolami + self.bokPola) * wiersz + self.odstepMiedzyPolami
-                pygame.draw.rect(self.okno, BIALY, [start, gora, self.bokPola, self.bokPola])
+                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 narysujAgenta(self):
+    def narysujKrateAlternatywnie(self):
-        if self.agent is not None:
+        self.okno.fill(SZARY1)
-            self.okno.blit(self.agent.tekstura, (self.agent.hitbox.x, self.agent.hitbox.y))
+        for i in range(LICZBA_POL_W_POZIOMIE + 1):
-            self.agent.ruszSie()
+            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,35 +1,263 @@
+import ctypes
 import os
+import random
+import threading
 
+import pygame.transform
+
+import szafka2
 from agent import *
-import etykieta
+from neural_network import *
+from okno import *
+from ramy_czyli_wiedza_agenta import *
+from rescue import *
+from genetyczny import *
 
-Okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
+# 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 = Krata(Okno)
+krata_magazynu = Krata(okno_pygame)
+Pomieszczenie = Pomieszczenie(WarunkiPowietrza(0, 0), 0)
 
 
-#
 def dodaj_agenta():
-    pole_lewe_gorne = PoleKraty(Krata, random.randint(0, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH),
+    # 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))
+    # random.randint(0, LICZBA_POL_W_POZIOMIE - BOK_AGENTA1_W_POLACH))
-    pom = 'test1_ikona.png'
+    # 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, pole_lewe_gorne, ikona)
+    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()
-    klatkaz = pygame.time.Clock()
+    okno1 = Okno(krata_magazynu, krata_magazynu.agent)
-    warunek_dzialania = True
+    okno1.wyswietlOkno()
-    while warunek_dzialania:
+
-        klatkaz.tick(FPS)
+    t = threading.Timer(5.0, zdarzenie_osoba).start()
-        for event in pygame.event.get():
+    osoba = PoleKraty(krata_magazynu, 0, 0)
-            if event.type == pygame.QUIT:
+    clf = drzewo_decyzyjne()
-                warunek_dzialania = False
+    global flaga1
-                break
+    flaga1 = 0
-        Krata.wyswietlKrate()
+
+    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()
-
-
-main()

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,33 +1,63 @@
-from enum import Enum
+import os
-
+
-FPS = 120
+import pygame
-KROK_AGENTA1 = 2
+
-SZEROKOSC_OKNA = 1080
+FPS = 20
-WYSOKOSC_OKNA = 760
+#
-BOK_AGENTA1 = 100
+# SZEROKOSC_OKNA = 1500
-BIALY = (255, 255, 255)
+# WYSOKOSC_OKNA = 750
-JASNOSZARY1 = (200, 200, 200)
+#
-ZIELONY1 = (26, 122, 26)
+LICZBA_POL_W_POZIOMIE = 30
-GREY =(150,150,150)
+LICZBA_POL_W_PIONIE = 15
-RED =(255,0,0)
+BOK_POLA = 45
-BLUE=(55,55,255)
+ODSTEP_MIEDZY_POLAMI = 1
-BLACK =(0,0,0)
+SZEROKOSC_OKNA = LICZBA_POL_W_POZIOMIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
-GREEN =(0,200,0)
+WYSOKOSC_OKNA = LICZBA_POL_W_PIONIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
-DARKGREY=(150,150,150)
+#
-UGLY_PINK=(255,0,255)
+BOK_AGENTA1_W_POLACH = 1
-BROWN=(153,76,0)
+BOK_AGENTA1 = BOK_AGENTA1_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
-GOLD=(153,153,0)
+#
-DARKGREEN=(0,102,0)
+DUZA_SZAFA = 1
-DARKORANGE=(255,128,0)
+#
-NUMBER_OF_BLOCKS_WIDE=8
+BIALY = (255, 255, 255)
-NUMBER_OF_BLOCKS_HIGH=8
+JASNOSZARY1 = (200, 200, 200)
-BLOCK_HEIGHT=round(SZEROKOSC_OKNA/NUMBER_OF_BLOCKS_HIGH)
+SZARY1 = (150, 150, 150)
-BLOCK_WIDTH=round(WYSOKOSC_OKNA/NUMBER_OF_BLOCKS_WIDE)
+CZARNY = (0, 0, 0)
-MAPFILE="map.txt"
+CIEMNY_BRAZOWY1 = (60, 19, 33)
-TITLE ="Gierka"
+ZOLTY1 = (231, 213, 69)
-
+NIEBIESKI1 = (65, 125, 225)
-class KIERUNEK(Enum):
+IKONA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'osoba2.png')),
-    GORA = 0
+                                               (BOK_AGENTA1, BOK_AGENTA1))
-    DOL = 1
+KALUZA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'kaluza.png')),
-    LEWO = 2
+                                               (BOK_AGENTA1, BOK_AGENTA1))
-    PRAWO = 3
+DYWAN = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'dywan.png')),
+                                               (BOK_AGENTA1, BOK_AGENTA1))
+PACZKA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'paczka.png')),
+                                               (BOK_AGENTA1, BOK_AGENTA1))
+###
+
+###
+GREY = (150, 150, 150)
+RED = (255, 0, 0)
+BLUE = (55, 55, 255)
+BLACK = (0, 0, 0)
+GREEN = (0, 200, 0)
+DARKGREY = (150, 150, 150)
+UGLY_PINK = (255, 0, 255)
+BROWN = (153, 76, 0)
+GOLD = (153, 153, 0)
+DARKGREEN = (0, 102, 0)
+DARKORANGE = (255, 128, 0)
+#
+# NUMBER_OF_BLOCKS_WIDE=8
+# NUMBER_OF_BLOCKS_HIGH=8
+# BLOCK_HEIGHT=round(SZEROKOSC_OKNA/NUMBER_OF_BLOCKS_HIGH)
+# BLOCK_WIDTH=round(WYSOKOSC_OKNA/NUMBER_OF_BLOCKS_WIDE)
+#
+MAPFILE = "map.txt"
+TITLE = "Gierka"
+#
+NUMBER_OF_BLOCKS_WIDE = LICZBA_POL_W_POZIOMIE
+NUMBER_OF_BLOCKS_HIGH = LICZBA_POL_W_PIONIE
+BLOCK_HEIGHT = BOK_POLA
+BLOCK_WIDTH = BOK_POLA

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)