Stworzenie kraty i wygaszacza ekranu na niej.

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

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

main.py

@@ -1,369 +1,90 @@
+import math
 import os
 import random
 
 import pygame
 
-from enumy_i_slowniki import *
+FPS = 1
 
-#
-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
+SZEROKOSC_OKNA = 1280
+WYSOKOSC_OKNA = 960
+
+LICZBA_POL_W_POZIOMIE = 8
+LICZBA_POL_W_PIONIE = 6
+
+Krata = []
+for rzad in range(LICZBA_POL_W_PIONIE):
+    Krata.append([])
+    for kolumna in range(LICZBA_POL_W_POZIOMIE):
+        Krata[rzad].append(random.randint(0, 9))
+
+bok_pola = min(int(SZEROKOSC_OKNA / LICZBA_POL_W_POZIOMIE), int(WYSOKOSC_OKNA / LICZBA_POL_W_PIONIE))
+odstep_miedzy_polami = max(1, math.floor(0.0625 * bok_pola))
+bok_pola -= odstep_miedzy_polami
+
+BIALY = (255, 255, 255)
+JASNOSZARY1 = (180, 180, 180)
+
+OKNO = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
+pygame.display.set_caption("Okno1")
+
+TEST1_IKONA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'test1_ikona.png')), (500, 500))
+TRAKTOR_IKONA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'traktor_ikona.png')), (100, 100))
+wozek_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'wozek.png')),
+                                     (bok_pola - odstep_miedzy_polami, bok_pola - odstep_miedzy_polami))
+wozek_ze_skrzynka_ikona = pygame.image.load(os.path.join('Ikony', 'wozek_ze_skrzynka.png'))
 
 
 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()
+    OKNO.fill(JASNOSZARY1)
+
+    for rzad in range(LICZBA_POL_W_PIONIE):
+        for kolumna in range(LICZBA_POL_W_POZIOMIE):
+            pygame.draw.rect(OKNO, BIALY, [(odstep_miedzy_polami + bok_pola) * kolumna + odstep_miedzy_polami,
+                                           (odstep_miedzy_polami + bok_pola) * rzad + odstep_miedzy_polami,
+                                           bok_pola, bok_pola])
     pygame.display.update()
 
 
-def narysuj_krate():
-    okno.fill(SZARY)
-    for wiersz in range(LICZBA_POL_W_PIONIE):
+def wyswietl_wozek():
+    for rzad 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
+            pom = Krata[rzad][kolumna]
+            if pom == 0:
+                pom = wozek_ikona
+            elif pom == 1:
+                pom = wozek_ze_skrzynka_ikona
+            elif pom == 2:
+                pom = TRAKTOR_IKONA
             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
+                pom = None
+            if pom != None:
+                pom = pygame.transform.scale(pom, (bok_pola - odstep_miedzy_polami, bok_pola - odstep_miedzy_polami))
+                OKNO.blit(pom, (((
+                                             odstep_miedzy_polami + bok_pola) * kolumna + odstep_miedzy_polami) + bok_pola / 2 - pom.get_width() / 2,
+                                ((
+                                             odstep_miedzy_polami + bok_pola) * rzad + odstep_miedzy_polami) + bok_pola / 2 - pom.get_height() / 2))
+    pygame.display.update()
 
 
-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
+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
 
-
-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
+    wyswietl_wozek()
+
+    pom = Krata[LICZBA_POL_W_PIONIE - 1][LICZBA_POL_W_POZIOMIE - 1]
+    for rzad in range(LICZBA_POL_W_PIONIE - 1, -1, -1):
+        for kolumna in range(LICZBA_POL_W_POZIOMIE - 1, 0, -1):
+            Krata[rzad][kolumna] = Krata[rzad][(kolumna - 1)]
+        Krata[rzad][0] = Krata[rzad - 1][LICZBA_POL_W_POZIOMIE - 1]
+    Krata[0][0] = pom
+    print(Krata)
+
+pygame.quit()

stale.py

@@ -1,23 +0,0 @@
-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_AGENTA_W_POLACH = 1
-BOK_AGENTA = BOK_AGENTA_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
-#
-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