htretrhj

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.9 (jakiesvirtualneenv)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
 </module>

.idea/misc.xml

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

agent.py

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

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

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

krata.py

@@ -1,73 +0,0 @@
-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,35 +1,369 @@
 import os
+import random
 
-from agent import *
-import etykieta
-
-Okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
-pygame.display.set_caption("Okno1")
-Krata = Krata(Okno)
+import pygame
 
+from enumy_i_slowniki import *
 
 #
-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)
+okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
+#
+droga_A = [[False, w, 7] for w in range(LICZBA_POL_W_PIONIE)]
+swiatlo_A = Swiatlo.CZERWONE
+pole_postojowe_A = (9, 7)
+sygnalizator_A = ((10, 9), (11, 9), (12, 9))
+indeks_petli_A = None
+for i in range(len(droga_A)):
+    x = droga_A[i]
+    if x[1] == pole_postojowe_A[0] and x[2] == pole_postojowe_A[1]:
+        indeks_petli_A = i
+#
+droga_B = [[False, w, 7] for w in range(0, 7)] + [[False, 7, k] for k in range(7, LICZBA_POL_W_POZIOMIE)]
+swiatlo_B = Swiatlo.ZIELONE
+pole_postojowe_B = (7, 8)
+sygnalizator_B = ((3, 10), (4, 10), (5, 10))
+indeks_petli_B = None
+for i in range(len(droga_B)):
+    x = droga_B[i]
+    if x[1] == pole_postojowe_B[0] and x[2] == pole_postojowe_B[1]:
+        indeks_petli_B = i
+#
+krata = [[_ for _ in range(LICZBA_POL_W_POZIOMIE)] for _ in range(LICZBA_POL_W_PIONIE)]
+#
+for w in range(LICZBA_POL_W_PIONIE):
+    for k in range(LICZBA_POL_W_POZIOMIE):
+        krata[w][k] = ZawartoscPola.SCIANA2
+#
+for w in range(LICZBA_POL_W_PIONIE):
+    krata[w][5] = ZawartoscPola.SCIANA
+    krata[w][6] = ZawartoscPola.PUSTE
+    krata[w][7] = ZawartoscPola.PUSTE
+    krata[w][8] = ZawartoscPola.SCIANA
+#
+krata[7][8] = ZawartoscPola.PUSTE
+krata[8][8] = ZawartoscPola.PUSTE
+#
+for w in [7, 8]:
+    for k in range(8, LICZBA_POL_W_POZIOMIE):
+        krata[w][k] = ZawartoscPola.PUSTE
+#
+for k in range(8, LICZBA_POL_W_POZIOMIE):
+    krata[6][k] = ZawartoscPola.SCIANA
+for k in range(8, LICZBA_POL_W_POZIOMIE):
+    krata[9][k] = ZawartoscPola.SCIANA
 
 
-def 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:
-                warunek_dzialania = False
-                break
-        Krata.wyswietlKrate()
-    pygame.quit()
+def wyswietl_okno():
+    pygame.time.Clock().tick(FPS)
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            # print("Użytkownik spróbował zamknąć okno.")
+            pygame.quit()
+    narysuj_krate()
+    narysuj_pojazdy()
+    pygame.display.update()
 
 
-main()
+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

stale.py

@@ -1,20 +1,23 @@
-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
+FPS = 2
+#
+LICZBA_POL_W_POZIOMIE = 30
+LICZBA_POL_W_PIONIE = 15
+BOK_POLA = 45
+ODSTEP_MIEDZY_POLAMI = 1
 SZEROKOSC_OKNA = LICZBA_POL_W_POZIOMIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
 WYSOKOSC_OKNA = LICZBA_POL_W_PIONIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
-
-BOK_AGENTA1_W_POLACH = 1
-BOK_AGENTA1 = BOK_AGENTA1_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
-KROK_AGENTA1 = 2
-
+#
+BOK_AGENTA_W_POLACH = 1
+BOK_AGENTA = BOK_AGENTA_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
+#
 BIALY = (255, 255, 255)
-JASNOSZARY1 = (200, 200, 200)
-SZARY1 = (150, 150, 150)
-ZIELONY1 = (26, 122, 26)
+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