View difference between Paste ID: XkXJBi2Z and 0QsGZaYL

 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()