Can't Stop final

import pygame
import random
#szerokość i wysokość ekranu
SZEROKOSC_EKRANU = 1280
WYSOKOSC_EKRANU = 960

pygame.init()
ekran = pygame.display.set_mode([SZEROKOSC_EKRANU, WYSOKOSC_EKRANU])
zegar = pygame.time.Clock()
obraz_tla = pygame.image.load('images/mountain.png')
czcionka = pygame.font.SysFont('Comic Sans MS', 35) #nazwa i rozmiar czcionki
obrazki_kosci = []
#wyniki kości
kosci = [1,1,1,1]
#kombinacje na kościach
kombinacje = []
mozliwe_ruchy = []
wybrane_kolumny = []
zablokowane_kolumny = []
for i in range(4):
    obrazki_kosci.append(pygame.image.load('images/kosc-1.png'))

teksty = ["Naciśnij Spacje"]
liczba_pol = [3,5,7,9,11,13,11,9,7,5,3]
skok_x = 70
skok_y = 50
start_x = 240
start_y = 900
aktywny_gracz = 0
czekanie_na_wybor_kolumny = False
czekanie_na_kontynuacje = False

def budowa_planszy():
    #współrzędne pierwszego pola
    x = start_x
    y = start_y
    #numer kolumny
    num = 2
    #Operacje wykonywane dla każdej kolumny
    for kolumna in liczba_pol:
        #modyfikacja współrzędnych
        #przesuwamy x w prawo po każdej zbudowanej kolumnie
        x += skok_x
        #Wracamy na dół kolumny aby zacząć budować nową
        y = start_y
        #budowa jednej kolumny
        for i in range(kolumna):
            #Przesuwamy współrzędną y w górę
            y -= skok_y
            #rysowanie koła które będzie czarną obwódką
            pygame.draw.circle(ekran, (0, 0, 0), (x,y), 22)
            #rysowanie środka pola - kolor dowolny
            #ważne aby dać inne kolory graczom potem
            pygame.draw.circle(ekran, (255, 230, 0), (x,y), 20)
        #przekształcamy liczbę na tekst
        numer_kolumny = czcionka.render(str(num), True,(0,0,0))
        #Wyświetlamy to nad kolumną
        #cofamy x odrobinę aby wyśrodkować napis
        ekran.blit(numer_kolumny, (x-10,y-70))
        #Przechodzimy do kolejnej kolumny
        num += 1

def pokaz_teksty():
    #współrzędne tekstu
    x_tekstu = 800
    y_tekstu = 40
    #przesunięcie tekstu między linijkami
    skok_tekstu = 50
    for tekst in teksty:
        #stworzenie linijki.
        #Kolor potem zmienimy na kolor aktywnego gracza
        linijka = czcionka.render(tekst, True,kolory_pionkow[aktywny_gracz])
        ekran.blit(linijka, (x_tekstu,y_tekstu))
        y_tekstu += skok_tekstu

def rzut_kosci():
    for i in range(4):
        #losowanie dla jednej kostki
        kosci[i] = random.randint(1,6)
        #załadowanie obrazka o nazwie zależnej od wyniku losowania
        obrazki_kosci[i] = pygame.image.load(f'images/kosc-{kosci[i]}.png')

def sprawdz_mozliwe_ruchy():
    kombinacje.clear()
    #Wyznaczenie wszystkich kombinacji
    kombinacje.append([kosci[0]+kosci[1], kosci[2]+kosci[3]])
    kombinacje.append([kosci[0]+kosci[2], kosci[1]+kosci[3]])
    kombinacje.append([kosci[0]+kosci[3], kosci[1]+kosci[2]])
    mozliwe_ruchy.clear()
    liczba_opcji = 0
    for i in range(len(kombinacje)):
        # tworzymy nową pustą listę na możliwe ruchy z tej kombinacji kości,
        # jeśli ruch nie będzie możliwy z tej kombinacji to
        # pustą listę później usuniemy
        mozliwe_ruchy.append([])
        #3 pionki postawione
        if len(wybrane_kolumny) == 3:
            #Sprawdzamy czy pierwsza suma kości znajduje się
            # w liście wybranych kolumn
            if kombinacje[i][0] in wybrane_kolumny:
                mozliwe_ruchy[liczba_opcji].append(kombinacje[i][0])
            #analogicznie z drugą wartością
            if kombinacje[i][1] in wybrane_kolumny:
                mozliwe_ruchy[liczba_opcji].append(kombinacje[i][1])
        #2 pionki postawione
        elif len(wybrane_kolumny) == 2:
            # Sprawdzenie czy pierwszy wynik jest już wybrany
            if kombinacje[i][0] in wybrane_kolumny:
                mozliwe_ruchy[liczba_opcji].append(kombinacje[i][0])
                #Jeśli pierwsza opcja jest w liście wybranych to druga jeśli
                # nie jest zablokowana to możemy się poruszyć również w tej kolumnie
                if not kombinacje[i][1] in zablokowane_kolumny:
                    mozliwe_ruchy[liczba_opcji].append(kombinacje[i][1])
            #analogiczne sprawdzenie drugiego wyniku
            elif kombinacje[i][1] in wybrane_kolumny:
                mozliwe_ruchy[liczba_opcji].append(kombinacje[i][1])
                if not kombinacje[i][0] in zablokowane_kolumny:
                    mozliwe_ruchy[liczba_opcji].append(kombinacje[i][0])
            #Jeśli obie wartości nie znajdują się w liście wybranych
            #to sprawdzam czy pierwsza jest nie zablokowana
            elif not kombinacje[i][0] in zablokowane_kolumny:
                mozliwe_ruchy[liczba_opcji].append(kombinacje[i][1])
                #Jeśli obie nie są zablokowane to musze je dodać oddzielnie
                # jest to przypadek gdy mamy dwa pionki na planszy
                # A dodać możemy tylko jeden, więc musimy wybrać który
                #Dlatego zwiększamy liczbę opcji i dodajemy kolejną opcję jako nową listę
                if not kombinacje[i][1] in zablokowane_kolumny:
                    liczba_opcji += 1
                    mozliwe_ruchy.append([kombinacje[i][1]])
            #Sprawdzenie czy choć druga opcja jest dostępna
            elif not kombinacje[i][1] in zablokowane_kolumny:
                mozliwe_ruchy[liczba_opcji].append(kombinacje[i][1])
        #jeden lub zero użytych pionków
        else:
            if not kombinacje[i][0] in zablokowane_kolumny:
                mozliwe_ruchy[liczba_opcji].append(kombinacje[i][0])
            if not kombinacje[i][1] in zablokowane_kolumny:
                mozliwe_ruchy[liczba_opcji].append(kombinacje[i][1])
        liczba_opcji += 1
    #Usunięcie pustych elementów
    while [] in mozliwe_ruchy:
        mozliwe_ruchy.remove([])
    #wyświetlenie tekstów
    teksty.clear()
    for i in range(len(mozliwe_ruchy)):
        teksty.append(f'{i+1}. Ruch w kolumnach {mozliwe_ruchy[i]}')

pozycje_pionkow_graczy = [[],[],[]]
for i in range(len(pozycje_pionkow_graczy)):
    for j in range(11):
        pozycje_pionkow_graczy[i].append(0)
czarne_pionki = []
def czysc_czarne():
    czarne_pionki.clear()
    for j in range(11):
        czarne_pionki.append(0)
czysc_czarne()

def ruch(opcja):
    kolumny = mozliwe_ruchy[opcja]
    for kolumna in kolumny:
        # Jeśli pionek w danej kolumnie w danej turze nie był użyty
        # to pobieramy wartość startową z listy pionków danego gracza
        # odejmujemy dwa bo numeracja kolumn zaczyna się od 2 a w programowaniu od 0
        if czarne_pionki[kolumna-2] == 0:
            czarne_pionki[kolumna-2] = pozycje_pionkow_graczy[aktywny_gracz][kolumna-2]
        # poruszamy pionkiem w konkretnej kolumnie o jedno pole do przodu
        czarne_pionki[kolumna-2] += 1
        # Jeśli kolumna nie była użyta w tej turze to doklejamy ją do kolumn wybranych
        if not kolumna in wybrane_kolumny:
            wybrane_kolumny.append(kolumna)
        #blokada nie pozwalająca jechać ponad kolumnę
        if czarne_pionki[kolumna-2] >= liczba_pol[kolumna-2]:
            czarne_pionki[kolumna-2] = liczba_pol[kolumna-2]

# podajemy kolejno kolory dla każdego gracza
# ostatni kolor to kolor czarny pionków tury
kolory_pionkow = [(255,0,0),(0,255,0),(0,0,255),(0,0,0)]
def postaw_pionki():
    #dla każdego gracza
    for numer_gracza in range(len(pozycje_pionkow_graczy)):
        #dla każdego pionka danego gracza
        for i in range(len(pozycje_pionkow_graczy[numer_gracza])):
            #z listy wyciągamy numer pola, na którym się najduję
            pozycja_pionka = pozycje_pionkow_graczy[numer_gracza][i]
            #jeśli jest różne od zera, czyli wszedł pionek już na planszę
            if pozycja_pionka != 0:
                #obliczamy współrzędne danego pionka
                # (numer_gracza * 5) - pozwala nam przesunąć
                # delikatnie w prawo każdy kolejny pionek, aby nie
                # zasłaniały się wzajemnie gdy zajmują to samo pole
                x = start_x + skok_x * (i + 1) + (numer_gracza * 5)
                y = start_y - (skok_y * pozycja_pionka)
                # rysujemy pionek o kolorze gracza
                pygame.draw.circle(ekran, kolory_pionkow[numer_gracza], (x,y), 10)
    #wykonujemy analogiczne czynności dla czarnych pionków
    for i in range(len(czarne_pionki)):
        pozycja_pionka = czarne_pionki[i]
        if pozycja_pionka != 0:
            x = start_x + skok_x * (i + 1) + (numer_gracza * 5)
            y = start_y - (skok_y * pozycja_pionka)
            #kolory[-1] oznaczają ostatni element listy
            pygame.draw.circle(ekran, kolory_pionkow[-1], (x,y), 10)

def stop_tury():
    #Sprawdzenie każdego czarnego pionka
    for i in range(len(czarne_pionki)):
        #Jeśli zdobyliśmy nim jakieś pola to aktualizujemy pozycje pionków gracza
        if czarne_pionki[i] != 0:
            pozycje_pionkow_graczy[aktywny_gracz][i] = czarne_pionki[i]
    #czyścimy wszystko przed turą kolejnego gracza
    czysc_czarne()
    teksty.clear()
    wybrane_kolumny.clear()

    ilosc_wygranych = 0
    for i in range(len(pozycje_pionkow_graczy[aktywny_gracz])):
        #Sprawdzamy czy aktywny gracz odsiągnął gdzieś szczyt kolumny
        if pozycje_pionkow_graczy[aktywny_gracz][i] >= liczba_pol[i]:
            #jeśli tak to dodajemy taką kolumnę do zablokowanych
            zablokowane_kolumny.append(i+2)
            #oraz naliczamy wygraną
            ilosc_wygranych += 1
    #jeśli naliczymy przynajmniej 3 wygrane kończymy grę
    if ilosc_wygranych >= 3:
        teksty.append("Wygrywasz")
        teksty.append("naciśnij Esc, aby zakończyć")
    # w przeciwnym wypadku zmieniamy gracza
    else:
        teksty.append("Tura następnego gracza")



program_dziala = True
while program_dziala:
    for zdarzenie in pygame.event.get():
        if zdarzenie.type == pygame.KEYDOWN:
            if zdarzenie.key == pygame.K_ESCAPE:
                program_dziala = False
            if zdarzenie.key == pygame.K_SPACE and not czekanie_na_wybor_kolumny and not czekanie_na_kontynuacje:
                rzut_kosci()
                sprawdz_mozliwe_ruchy()
                if len(mozliwe_ruchy) == 0:
                    teksty.append("Brak możliwości ruchu")
                    teksty.append("Twoja tura kończy się")
                    wybrane_kolumny.clear()
                    aktywny_gracz += 1
                    if aktywny_gracz == 3:
                        aktywny_gracz = 0
                    czekanie_na_wybor_kolumny = False
                    czysc_czarne()
                else:
                    czekanie_na_wybor_kolumny = True
            #Zdarzenie może się uruchomić jedynie, gdy czekamy na wybór kolumny
            # i ilość opcji wynosi przynajmniej jeden
            if zdarzenie.key == pygame.K_1 and czekanie_na_wybor_kolumny and len(teksty) >= 1:
                # Używamy opcji zero bo stosujemy numerację listy
                ruch(0)
                # Kończymy czekanie na wybór kolumn bo została wybrana
                czekanie_na_wybor_kolumny = False
                czekanie_na_kontynuacje = True
            if zdarzenie.key == pygame.K_2 and czekanie_na_wybor_kolumny and len(teksty) >= 2:
                ruch(1)
                czekanie_na_wybor_kolumny = False
                czekanie_na_kontynuacje = True
            if zdarzenie.key == pygame.K_3 and czekanie_na_wybor_kolumny and len(teksty) >= 3:
                ruch(2)
                czekanie_na_wybor_kolumny = False
                czekanie_na_kontynuacje = True
            if zdarzenie.key == pygame.K_4 and czekanie_na_wybor_kolumny and len(teksty) >= 4:
                ruch(3)
                czekanie_na_wybor_kolumny = False
                czekanie_na_kontynuacje = True
            if zdarzenie.key == pygame.K_5 and czekanie_na_wybor_kolumny and len(teksty) >= 5:
                ruch(4)
                czekanie_na_wybor_kolumny = False
                czekanie_na_kontynuacje = True
            if zdarzenie.key == pygame.K_6 and czekanie_na_wybor_kolumny and len(teksty) >= 6:
                ruch(5)
                czekanie_na_wybor_kolumny = False
                czekanie_na_kontynuacje = True
            if zdarzenie.key == pygame.K_d and czekanie_na_kontynuacje:
                czekanie_na_kontynuacje = False
                teksty = ["Naciśnij spacje"]
            if zdarzenie.key == pygame.K_s and czekanie_na_kontynuacje:
                stop_tury()
                aktywny_gracz += 1
                if aktywny_gracz == 3:
                    aktywny_gracz = 0
                czekanie_na_kontynuacje = False
        elif zdarzenie.type == pygame.QUIT:
            program_dziala = False

    if czekanie_na_kontynuacje:
        teksty = ["s. Stop", "d. Dalej"]
    #wyświetl tło
    ekran.blit(obraz_tla, (0,0))
    #Kosci
    ekran.blit(obrazki_kosci[0], (16,16))
    ekran.blit(obrazki_kosci[1], (116,16))
    ekran.blit(obrazki_kosci[2], (16,116))
    ekran.blit(obrazki_kosci[3], (116,116))
    #Plansza
    budowa_planszy()
    #TekstyWybór
    pokaz_teksty()
    #Pionki
    postaw_pionki()
    #odśwież ekran
    pygame.display.flip()
    zegar.tick(60) #liczba klatek na sekunde

pygame.quit()