370 lines
12 KiB
Python
370 lines
12 KiB
Python
import os
|
|
import random
|
|
|
|
import pygame
|
|
|
|
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
|
|
|
|
|
|
def wyswietl_okno():
|
|
pygame.time.Clock().tick(FPS)
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
# print("Użytkownik spróbował zamknąć okno.")
|
|
pygame.quit()
|
|
narysuj_krate()
|
|
narysuj_pojazdy()
|
|
pygame.display.update()
|
|
|
|
|
|
def 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
|