Prześlij pliki do ''

.idea/Sztuczna_Inteligencja_Gr16.iml

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

.idea/misc.xml

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

agent.py

@@ -0,0 +1,117 @@
+import random
+
+from krata import *
+
+
+class Agent:
+    bok = BOK_AGENTA1
+    bokWPolach = BOK_AGENTA1_W_POLACH
+
+    def __init__(self, Krata, poleStartoweGorne, tekstura):
+        self.krata = Krata
+        self.poleStartoweGorne = poleStartoweGorne
+        self.tekstura = tekstura
+        self.okreslPolozenie()
+        self.obierzNowyKierunek()
+        self.okreslDlugoscDrogi()
+        Krata.agent = self
+
+    def ruszSie(self):
+        if self.droga <= 0:
+            self.obierzNowyKierunek()
+            self.okreslDlugoscDrogi()
+        self.zrobKrokWMoimKierunku()
+        self.droga -= 1
+        self.okreslPolozenie()
+        if self.wyszedlemPozaKrate():
+            self.cofnijSie()
+            self.zawroc()
+            self.okreslDlugoscDrogi()
+
+    def obierzNowyKierunek(self):
+        self.kierunek = Kierunek(random.randint(0, 3))
+        if self.maxDlugoscDrogiWMoimKierunku() < 1:
+            self.obierzNowyKierunek()
+
+    def okreslDlugoscDrogi(self):
+        self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
+
+    def cofnijSie(self):
+        self.zrobKrokWOdwrotnymKierunku()
+        self.okreslPolozenie()
+
+    def okreslPolozenie(self):
+        self.okreslPoleKoncoweDolne()
+        self.okreslHitbox()
+
+    def okreslHitbox(self):
+        self.hitbox = pygame.Rect(self.poleStartoweGorne.start, self.poleStartoweGorne.gora, self.bok, self.bok)
+
+    def okreslPoleKoncoweDolne(self):
+        wiersz = self.poleStartoweGorne.wiersz + self.bokWPolach - 1
+        kolumna = self.poleStartoweGorne.kolumna + self.bokWPolach - 1
+        self.poleKoncoweDolne = PoleKraty(self.krata, wiersz, kolumna)
+
+    def wyszedlemPozaKrate(self):
+        if self.poleStartoweGorne.wiersz < 0:
+            return True
+        elif self.poleKoncoweDolne.wiersz > self.krata.liczbaPolPionowo - 1:
+            return True
+        elif self.poleStartoweGorne.kolumna < 0:
+            return True
+        elif self.poleKoncoweDolne.kolumna > self.krata.liczbaPolPoziomo - 1:
+            return True
+        else:
+            return False
+
+    def zawroc(self):
+        if self.kierunek == Kierunek.GORA:
+            self.kierunek = Kierunek.DOL
+        elif self.kierunek == Kierunek.DOL:
+            self.kierunek = Kierunek.GORA
+        elif self.kierunek == Kierunek.LEWO:
+            self.kierunek = Kierunek.PRAWO
+        elif self.kierunek == Kierunek.PRAWO:
+            self.kierunek = Kierunek.LEWO
+
+    def maxDlugoscDrogiWMoimKierunku(self):
+        if self.kierunek == Kierunek.GORA:
+            return self.poleStartoweGorne.wiersz
+        elif self.kierunek == Kierunek.DOL:
+            return self.krata.liczbaPolPionowo - self.poleKoncoweDolne.wiersz - 1
+        elif self.kierunek == Kierunek.LEWO:
+            return self.poleStartoweGorne.kolumna
+        elif self.kierunek == Kierunek.PRAWO:
+            return self.krata.liczbaPolPoziomo - self.poleKoncoweDolne.kolumna - 1
+
+    def zrobKrokWMoimKierunku(self):
+        if self.kierunek == Kierunek.GORA:
+            self.idzWGore()
+        elif self.kierunek == Kierunek.DOL:
+            self.idzWDol()
+        elif self.kierunek == Kierunek.LEWO:
+            self.idzWLewo()
+        elif self.kierunek == Kierunek.PRAWO:
+            self.idzWPrawo()
+
+    def zrobKrokWOdwrotnymKierunku(self):
+        if self.kierunek == Kierunek.GORA:
+            self.idzWDol()
+        elif self.kierunek == Kierunek.DOL:
+            self.idzWGore()
+        elif self.kierunek == Kierunek.LEWO:
+            self.idzWPrawo()
+        elif self.kierunek == Kierunek.PRAWO:
+            self.idzWLewo()
+
+    def idzWGore(self):
+        self.poleStartoweGorne.wiersz -= 1
+
+    def idzWDol(self):
+        self.poleStartoweGorne.wiersz += 1
+
+    def idzWLewo(self):
+        self.poleStartoweGorne.kolumna -= 1
+
+    def idzWPrawo(self):
+        self.poleStartoweGorne.kolumna += 1

enumy.py

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

@@ -1,29 +0,0 @@
-from enum import Enum
-
-from stale import *
-
-
-class ZawartoscPola(Enum):
-    PUSTE = 0
-    SCIANA = 1
-    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: CZARNY,
-    ZawartoscPola.SCIANA: JASNOSZARY,
-    ZawartoscPola.SCIANA2: SZARY,
-    ZawartoscPola.SYGNALIZATOR_CZERWONY: CZERWONY,
-    ZawartoscPola.SYGNALIZATOR_ZOLTY: ZOLTY,
-    ZawartoscPola.SYGNALIZATOR_ZIELONY: ZIELONY
-}

etykieta.py

@@ -0,0 +1,5 @@
+nazwa_paczki =""
+producent =""
+numer_paczki=int
+cecha_paczki =""
+data_wysylki= ""

krata.py

@@ -0,0 +1,73 @@
+import pygame
+
+from enumy import *
+from stale import *
+
+
+class PoleKraty:
+    def __init__(self, Krata, wiersz, kolumna):
+        self.krata = Krata
+        self.bok = self.krata.bokPola
+        self._wiersz = wiersz
+        self._kolumna = kolumna
+        self.okreslGore()
+        self.okreslStart()
+
+    def okreslGore(self):
+        self.gora = (self.bok + self.krata.odstepMiedzyPolami) * self.wiersz + self.krata.odstepMiedzyPolami
+
+    def okreslStart(self):
+        self.start = (self.bok + self.krata.odstepMiedzyPolami) * self.kolumna + self.krata.odstepMiedzyPolami
+
+    def getWiersz(self):
+        return self._wiersz
+
+    def setWiersz(self, x):
+        self._wiersz = x
+        self.okreslGore()
+
+    def getKolumna(self):
+        return self._kolumna
+
+    def setKolumna(self, x):
+        self._kolumna = x
+        self.okreslStart()
+
+    wiersz = property(getWiersz, setWiersz)
+    kolumna = property(getKolumna, setKolumna)
+
+
+class Krata:
+    def __init__(self, okno):
+        self.okno = okno
+        self.liczbaPolPoziomo = LICZBA_POL_W_POZIOMIE
+        self.liczbaPolPionowo = LICZBA_POL_W_PIONIE
+        self.bokPola = BOK_POLA
+        self.odstepMiedzyPolami = ODSTEP_MIEDZY_POLAMI
+        self.krata = self.utworzPustaKrate()
+        self.agent = None
+
+    def utworzPustaKrate(self):
+        self.krata = []
+        for rzad in range(self.liczbaPolPionowo):
+            self.krata.append([])
+            for kolumna in range(self.liczbaPolPoziomo):
+                self.krata[rzad].append(ZawartoscPola.PUSTE)
+
+    def wyswietlKrate(self):
+        self.narysujKrate()
+        self.narysujAgenta()
+        pygame.display.update()
+
+    def narysujKrate(self):
+        self.okno.fill(SZARY1)
+        for rzad 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
+                pygame.draw.rect(self.okno, BIALY, [start, gora, self.bokPola, self.bokPola])
+
+    def narysujAgenta(self):
+        if self.agent is not None:
+            self.okno.blit(self.agent.tekstura, (self.agent.hitbox.x, self.agent.hitbox.y))
+            self.agent.ruszSie()

main.py

@@ -1,369 +1,35 @@
 import os
-import random
 
-import pygame
+from agent import *
+import etykieta
 
-from enumy_i_slowniki import *
-
-#
-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
+Okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
+pygame.display.set_caption("Okno1")
+Krata = Krata(Okno)
 
 
-def wyswietl_okno():
-    pygame.time.Clock().tick(FPS)
+#
+def dodaj_agenta():
+    pole_lewe_gorne = PoleKraty(Krata, random.randint(0, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH),
+                                random.randint(0, LICZBA_POL_W_POZIOMIE - BOK_AGENTA1_W_POLACH))
+    pom = 'test1_ikona.png'
+    ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', pom)),
+                                   (BOK_AGENTA1, BOK_AGENTA1))
+    Agent(Krata, pole_lewe_gorne, ikona)
+
+
+def main():
+    dodaj_agenta()
+    klatkaz = pygame.time.Clock()
+    warunek_dzialania = True
+    while warunek_dzialania:
+        klatkaz.tick(FPS)
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
-            # print("Użytkownik spróbował zamknąć okno.")
+                warunek_dzialania = False
+                break
+        Krata.wyswietlKrate()
     pygame.quit()
-    narysuj_krate()
-    narysuj_pojazdy()
-    pygame.display.update()
 
 
-def narysuj_krate():
-    okno.fill(SZARY)
-    for wiersz in range(LICZBA_POL_W_PIONIE):
-        for kolumna in range(LICZBA_POL_W_POZIOMIE):
-            start = (ODSTEP_MIEDZY_POLAMI + BOK_POLA) * kolumna + ODSTEP_MIEDZY_POLAMI
-            gora = (ODSTEP_MIEDZY_POLAMI + BOK_POLA) * wiersz + ODSTEP_MIEDZY_POLAMI
-            kolor_pola = ZawartoscPolaNaKolorPola[krata[wiersz][kolumna]]
-            pygame.draw.rect(okno, kolor_pola, [start, gora, BOK_POLA, BOK_POLA])
-
-
-def narysuj_pojazdy():
-    ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'auto.png')), (BOK_AGENTA, BOK_AGENTA))
-    for x in droga_A:
-        if x[0]:
-            okno.blit(ikona, ((BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[2] + ODSTEP_MIEDZY_POLAMI,
-                              (BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[1] + ODSTEP_MIEDZY_POLAMI))
-    ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'auto2.png')), (BOK_AGENTA, BOK_AGENTA))
-    for x in droga_B:
-        if x[0]:
-            okno.blit(ikona, ((BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[2] + ODSTEP_MIEDZY_POLAMI,
-                              (BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[1] + ODSTEP_MIEDZY_POLAMI))
-
-
-def rusz_pojazdy_na_drodze(droga, pole_postojowe, swiatlo):
-    nowa_droga = [[False, x[1], x[2]] for x in droga]
-    for i in range(len(droga) - 1, 0, -1):
-        x = droga[i]
-        if x[0]:
-            if x[1] == pole_postojowe[0] and x[2] == pole_postojowe[1] and swiatlo != Swiatlo.ZIELONE:
-                nowa_droga[i][0] = True
-            else:
-                if not droga[i - 1][0]:
-                    nowa_droga[i][0] = False
-                    nowa_droga[i - 1][0] = True
-                else:
-                    nowa_droga[i][0] = True
-    return nowa_droga
-
-
-def ustaw_czerwone(sygnalizator):
-    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SYGNALIZATOR_CZERWONY
-    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SCIANA2
-    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
-
-
-def ustaw_czerwone_z_zoltym(sygnalizator):
-    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SYGNALIZATOR_CZERWONY
-    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SYGNALIZATOR_ZOLTY
-    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
-
-
-def ustaw_zolte(sygnalizator):
-    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SCIANA2
-    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SYGNALIZATOR_ZOLTY
-    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
-
-
-def ustaw_zielone(sygnalizator):
-    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SCIANA2
-    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SCIANA2
-    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SYGNALIZATOR_ZIELONY
-
-
-def Czerwone_Czerwone_do_Zielone_Czerwone():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"
-
-
-def Czerwone_Czerwone_do_Czerwone_Zielone():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"
-
-
-def CzerwoneZZoltym_Czerwone():
-    return swiatlo_A == Swiatlo.CZERWONE_Z_ZOLTYM and swiatlo_B == Swiatlo.CZERWONE
-
-
-def Zielone_Czerwone_1():
-    return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"
-
-
-def Zielone_Czerwone_2():
-    return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"
-
-
-def Zolte_Czerwone():
-    return swiatlo_A == Swiatlo.ZOLTE and swiatlo_B == Swiatlo.CZERWONE
-
-
-def Czerwone_CzerwoneZZoltym():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE_Z_ZOLTYM
-
-
-def Czerwone_Zielone():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.ZIELONE
-
-
-def Czerwone_Zolte():
-    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.ZOLTE
-
-
-def O_O():
-    return (not droga_A[indeks_petli_A][0]) and (not droga_B[indeks_petli_B][0])
-
-
-def A_O():
-    return (droga_A[indeks_petli_A][0]) and (not droga_B[indeks_petli_B][0])
-
-
-def O_B():
-    return (not droga_A[indeks_petli_A][0]) and (droga_B[indeks_petli_B][0])
-
-
-def A_B():
-    return (droga_A[indeks_petli_A][0]) and (droga_B[indeks_petli_B][0])
-
-
-def ustaw_Czerwone_Czerwone_do_Czerwone_Zielone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-    global poprzednio
-    poprzednio = "A"
-
-
-def ustaw_Czerwone_Czerwone_do_Zielone_Czerwone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-    global poprzednio
-    poprzednio = "B"
-
-
-def ustaw_CzerwoneZZoltym_Czerwone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE_Z_ZOLTYM
-    ustaw_czerwone_z_zoltym(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-
-
-def ustaw_Zielone_Czerwone_1():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.ZIELONE
-    ustaw_zielone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-    global poprzednio
-    poprzednio = "B"
-
-
-def ustaw_Zielone_Czerwone_2():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.ZIELONE
-    ustaw_zielone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-    global poprzednio
-    poprzednio = "A"
-
-
-def ustaw_Zolte_Czerwone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.ZOLTE
-    ustaw_zolte(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_B)
-
-
-def ustaw_Czerwone_CzerwoneZZoltym():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.CZERWONE_Z_ZOLTYM
-    ustaw_czerwone_z_zoltym(sygnalizator_B)
-
-
-def ustaw_Czerwone_Zielone():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.ZIELONE
-    ustaw_zielone(sygnalizator_B)
-
-
-def ustaw_Czerwone_Zolte():
-    global swiatlo_A
-    swiatlo_A = Swiatlo.CZERWONE
-    ustaw_czerwone(sygnalizator_A)
-    global swiatlo_B
-    swiatlo_B = Swiatlo.ZOLTE
-    ustaw_zolte(sygnalizator_B)
-
-
-droga_A[14][0] = True
-droga_A[12][0] = True
-droga_A[10][0] = True
-droga_A[9][0] = True
-droga_B[len(droga_B) - 1][0] = True
-droga_B[len(droga_B) - 2][0] = True
-droga_B[len(droga_B) - 6][0] = True
-droga_B[5][0] = True
-
-czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-ustaw_Czerwone_Czerwone_do_Zielone_Czerwone()
-poprzednio = "B"
-
-while True:
-    # print(droga_A[indeks_petli_A][0],droga_B[indeks_petli_B][0])
-    if O_O():
-        print("O - O")
-    elif A_O():
-        print("A - O")
-    elif A_B():
-        print("A - B")
-    elif O_B():
-        print("O - B")
-    czas_od_ostatniej_zmiany_swiatel = pygame.time.get_ticks() - czas_ostatniej_zmiany_swiatel
-    if Czerwone_Czerwone_do_Zielone_Czerwone():
-        print("Czerwone - Czerwone do Zielone - Czerwone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if O_O() or A_O() or A_B():
-                ustaw_CzerwoneZZoltym_Czerwone()
-            elif O_B():
-                ustaw_Czerwone_CzerwoneZZoltym()
-    elif CzerwoneZZoltym_Czerwone():
-        print("Czerwone z Zoltym - Czerwone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            ustaw_Zielone_Czerwone_1()
-    elif Zielone_Czerwone_1():
-        print("Zielone - Czerwone 1")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if O_O() or A_O() or A_B():
-                ustaw_Zielone_Czerwone_2()
-            elif O_B():
-                ustaw_Zolte_Czerwone()
-    elif Zielone_Czerwone_2():
-        print("Zielone - Czerwone 2")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if O_O() or A_O():
-                pass
-            elif O_B() or A_B():
-                ustaw_Zolte_Czerwone()
-    elif Zolte_Czerwone():
-        print("Zolte - Czerwone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            ustaw_Czerwone_Czerwone_do_Czerwone_Zielone()
-    elif Czerwone_CzerwoneZZoltym():
-        print("Czerwone  - Czerwone z Zoltym")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            ustaw_Czerwone_Zielone()
-    elif Czerwone_Zielone():
-        print("Czerwone - Zielone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if O_B():
-                pass
-            elif O_O() or A_O() or A_B():
-                ustaw_Czerwone_Zolte()
-    elif Czerwone_Zolte():
-        print("Czerwone - Zolte")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            ustaw_Czerwone_Czerwone_do_Zielone_Czerwone()
-    elif Czerwone_Czerwone_do_Czerwone_Zielone():
-        print("Czerwone - Czerwone do Czerwone - Zielone")
-        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
-            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
-            if A_O():
-                ustaw_CzerwoneZZoltym_Czerwone()
-            elif O_O() or O_B() or A_B():
-                ustaw_Czerwone_CzerwoneZZoltym()
-    #
-    wyswietl_okno()
-    droga_A = rusz_pojazdy_na_drodze(droga_A, pole_postojowe_A, swiatlo_A)
-    droga_B = rusz_pojazdy_na_drodze(droga_B, pole_postojowe_B, swiatlo_B)
-    #
-    los = random.random()
-    liczba_samochodow = len([x for x in droga_A if x[0]])
-    maks_samochodow = 7
-    szansa = (maks_samochodow - liczba_samochodow) / maks_samochodow -0.7
-    if los < szansa:
-        droga_A[len(droga_A) - 1][0] = True
-    #
-    liczba_samochodow = len([x for x in droga_B if x[0]])
-    maks_samochodow = 6
-    szansa = (maks_samochodow - liczba_samochodow) / maks_samochodow - 0.4
-    if los < szansa:
-        droga_B[len(droga_B) - 1][0] = True
+main()

stale.py

@@ -1,23 +1,20 @@
-FPS = 2
-#
-LICZBA_POL_W_POZIOMIE = 30
-LICZBA_POL_W_PIONIE = 15
-BOK_POLA = 45
-ODSTEP_MIEDZY_POLAMI = 1
+FPS = 10
+
+# SZEROKOSC_OKNA = 1500
+# WYSOKOSC_OKNA = 750
+
+LICZBA_POL_W_POZIOMIE = 60
+LICZBA_POL_W_PIONIE = 20
+BOK_POLA = 20
+ODSTEP_MIEDZY_POLAMI =2
 SZEROKOSC_OKNA = LICZBA_POL_W_POZIOMIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
 WYSOKOSC_OKNA = LICZBA_POL_W_PIONIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
-#
-BOK_AGENTA_W_POLACH = 1
-BOK_AGENTA = BOK_AGENTA_W_POLACH * (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
+KROK_AGENTA1 = 2
+
 BIALY = (255, 255, 255)
-JASNOSZARY = (200, 200, 200)
-SZARY = (150, 150, 150)
-CZARNY = (0, 0, 0)
-#
-CZERWONY = (255, 0, 0)
-ZOLTY = (255, 255, 0)
-ZIELONY = (0, 255, 0)
-#
-CZAS_ZMIANY_NA_SYGNALIZATORZE = 1500
-CZAS_CYKLU = 6000
+JASNOSZARY1 = (200, 200, 200)
+SZARY1 = (150, 150, 150)
+ZIELONY1 = (26, 122, 26)