python_gamejam_examples/pygame/04_pong_dva_hraci.py

import pygame
import sys

# pygame.init() spustí vnitřní motory knihovny Pygame. Bez toho nejde ani otevřít okno.
pygame.init()

# --- NASTAVENÍ OKNA ---
SIRKA = 800
VYSKA = 600
# Okno upevníme na tyto rozměry
okno = pygame.display.set_mode((SIRKA, VYSKA))
pygame.display.set_caption("Pong - Plná Hra pro dva hráče")

# --- BARVY ---
BILA = (255, 255, 255)
CERNA = (0, 0, 0)
ZELENA = (0, 255, 0)

# Herní hodiny omezují, aby náš počítač nehrál 1000x za vteřinu, čímž by hra byla nehratelná.
hodiny = pygame.time.Clock()

# Tvorba písem (pro vykreslování textu potřebujeme vždy nastavit velikost a typ písma)
font_velky = pygame.font.SysFont("Arial", 50)
font_maly = pygame.font.SysFont("Arial", 30)

# --- STAVOVÝ AUTOMAT (State Machine) ---
# Trik profesionálů: Hra je vždy v nějakém "Stavu" (Menu, Hra, Konec). 
# Podle tohoto čísla pak naše hlavní smyčka pozná, jaké má platit rozvržení obrazovky a pravidla.
STAV_MENU = 0
STAV_HRA = 1
STAV_KONEC = 2
stav = STAV_MENU # Začínáme logicky v hlavním menu

# --- PROMĚNNÉ HRÁČŮ (Pálky) A MÍČKU ---
palka_sirka = 15
palka_vyska = 100
rychlost_palky = 7
micek_velikost = 15

# Funkce, která vrátí všechny proměnné na začátek. Použije se po gólu nebo při startu nové hry.
def reset_hry():
    # Klíčové slovo 'global' musíme použít vždycky, když uvnitř Funkce chceme MĚNIT proměnnou,
    # která byla vytvořena venku (na nejvyšší úrovni skriptu).
    global hrac1_y, hrac2_y, skore1, skore2, micek_x, micek_y, micek_rychlost_x, micek_rychlost_y
    
    # Hráče zarovnáme na střed Y osy (Výška okna / 2 - polovina velikosti hráče)
    hrac1_y = VYSKA // 2 - palka_vyska // 2
    hrac2_y = VYSKA // 2 - palka_vyska // 2
    skore1 = 0
    skore2 = 0
    
    # Míček přesně doprostřed obou os X a Y
    micek_x = SIRKA // 2 - micek_velikost // 2
    micek_y = VYSKA // 2 - micek_velikost // 2
    
    # Míček poletí rychlostí 5 bodů za snímek šikmo dolů doprava
    micek_rychlost_x = 5
    micek_rychlost_y = 5

# Okamžitě to zavoláme, abychom proměnným výše vložili výchozí čísla hned při spuštění programu
reset_hry() 

bezime = True
# Hlavní cyklus hry, který točí snímek za snímkem donekonečna, dokud aplikaci neukončíme.
while bezime:
    
    # 1. ZPRACOVÁNÍ UDÁLOSTÍ
    # Procházíme např. stisky tlačítek myši, křížek pro zavření okna, jedno-stisky kláves
    for udalost in pygame.event.get():
        if udalost.type == pygame.QUIT:
            bezime = False # Ukončíme while-cyklus
        
        # Zjišťujeme, zda se NESTISKNULA klávesa. Tohle se provede jen JEDNOU, i když ji uživatel drží!
        if udalost.type == pygame.KEYDOWN:
            if stav == STAV_MENU and udalost.key == pygame.K_SPACE:
                # Jsme v menu, hráč stiskl MEZERNÍK. Přepneme hru do režimu STAV_HRA!
                stav = STAV_HRA 
            elif stav == STAV_KONEC and udalost.key == pygame.K_SPACE:
                # Jsme na obrazovce s vítězem, hráč chce hrát znovu.
                reset_hry()     
                stav = STAV_HRA

    # Oproti tomu toto zjistí AKTUÁLNĚ DRŽENÉ klávesy v tomto zlomku vteřiny
    klavesy = pygame.key.get_pressed()

    # 2. HERNÍ LOGIKA (HÝBÁNÍ SE)
    # Tohle se provede JEN a POUZE, pokud zrovna hrajeme zápas!
    if stav == STAV_HRA:
        # Ovládání Hráče 1 vlevo (Klávesy W a S pro pohyb nahoru/dolů)
        if klavesy[pygame.K_w] and hrac1_y > 0:
            hrac1_y -= rychlost_palky
        # Dolů nemůže víc, než je výška okna zmenšená o jeho vlastní výšku pálky
        if klavesy[pygame.K_s] and hrac1_y < VYSKA - palka_vyska:
            hrac1_y += rychlost_palky

        # Ovládání Hráče 2 vpravo (Šipky Nahoru a Dolů)
        if klavesy[pygame.K_UP] and hrac2_y > 0:
            hrac2_y -= rychlost_palky
        if klavesy[pygame.K_DOWN] and hrac2_y < VYSKA - palka_vyska:
            hrac2_y += rychlost_palky

        # Míček se za každou smyčku kousek posune. Tím vzniká dojem pohybu.
        micek_x += micek_rychlost_x
        micek_y += micek_rychlost_y

        # --- Fyzika: Odraz míčku od stropu a podlahy ---
        # Trik: Vynásobením rychlosti číslem -1 se obrátí znaménko. 
        # Z kladné rychlosti (+5 padá dolů) se stane záporná (-5 letí nahoru). Odrazil se!
        if micek_y <= 0 or micek_y >= VYSKA - micek_velikost:
            micek_rychlost_y *= -1

        # --- Fyzika: Odraz od pálek hráčů ---
        # Abychom to jednoduše spočítali, vyrobíme si takzvané virtuální Obdélníky (Rect)
        rect_micek = pygame.Rect(micek_x, micek_y, micek_velikost, micek_velikost)
        
        # Pálku Hráče 1 vykreslujeme fixně 30 pixelů od levého okraje
        rect_hrac1 = pygame.Rect(30, hrac1_y, palka_sirka, palka_vyska)
        # Pálku Hráče 2 fixně na pravé straně. (SIRKA - 30 od kraje - velikost pálky)
        rect_hrac2 = pygame.Rect(SIRKA - 30 - palka_sirka, hrac2_y, palka_sirka, palka_vyska)

        # Metoda 'colliderect' doslova zkoumá, jestli se tyto obdélníky v daný moment nepřekrývají
        if rect_micek.colliderect(rect_hrac1) or rect_micek.colliderect(rect_hrac2):
            # Odrazil se od pálky! Obrátíme jeho směr po ose X a ještě ho mírně zrychlíme (* -1.1)
            micek_rychlost_x *= -1.1 

        # --- Vyhodnocení Gólu ---
        if micek_x < 0:
            # Přeletěl za levý okraj (Hráč 1 ho nezachytil). Bod pro Hráče 2!
            skore2 += 1 
            micek_x, micek_y = SIRKA // 2, VYSKA // 2 # Teleportace míčku na prostředek
            micek_rychlost_x = 5 # Reset rychlosti a ať letí k hráči co dostal gól (doprava)
        elif micek_x > SIRKA:
            # Přeletěl vpravo
            skore1 += 1 
            micek_x, micek_y = SIRKA // 2, VYSKA // 2
            micek_rychlost_x = -5 # Směr letu doleva

        # --- Konec Zápasu ---
        # Zápas končí, jakmile někdo dosáhne 5 bodů
        if skore1 >= 5 or skore2 >= 5:
            stav = STAV_KONEC

    # 3. KRESLENÍ GRAFIKY
    # Vždy smažeme starou stopu vyplněním okna čistě černou barvou
    okno.fill(CERNA)
    
    # Co na obrazovce bude záleží zcela na tom, ve kterém STAVU náš Stavový Automat právě je!
    if stav == STAV_MENU:
        # Vykreslení Menu. .render převede nápis z textu do "razítka"
        nadpis = font_velky.render("PONG", True, BILA)
        navod = font_maly.render("Stiskni MEZERNÍK pro start", True, ZELENA)
        
        # Tyto razítka .blitnem (otiskneme) na plátno. Výpočet (SIRKA//2 - nadpis.get_width()//2) zarovná nápis čistě doprostřed obrazovky.
        okno.blit(nadpis, (SIRKA//2 - nadpis.get_width()//2, 200))
        okno.blit(navod, (SIRKA//2 - navod.get_width()//2, 300))

    elif stav == STAV_HRA:
        # Jsme ve hře. Vykreslíme půlící čáru (síť v Pongu). 'aaline' je hladká čára.
        pygame.draw.aaline(okno, BILA, (SIRKA // 2, 0), (SIRKA // 2, VYSKA))
        
        # Nakreslíme pálky na místa, která předtím logika vypočítala
        pygame.draw.rect(okno, BILA, rect_hrac1)
        pygame.draw.rect(okno, BILA, rect_hrac2)
        
        # Míček vykreslíme jako 'ellipsu' napasovanou na ten neviditelný 'rect_micek' obdélník. Vznikne tak kruh.
        pygame.draw.ellipse(okno, BILA, rect_micek) 
        
        # Kreslení obou skóre úplně nahoru
        text_skore = font_velky.render(f"{skore1}   {skore2}", True, BILA)
        okno.blit(text_skore, (SIRKA // 2 - text_skore.get_width() // 2, 20))

    elif stav == STAV_KONEC:
        # Zjištění, kdo vyhrál pomocí tzv. ternárního if (vítězem je "Hráč 1" POKUD má skore1>=5, JINAK je to "Hráč 2")
        vitez = "Hráč 1" if skore1 >= 5 else "Hráč 2"
        
        # Razítka s nápisy
        text_vitez = font_velky.render(f"{vitez} vyhrál!", True, ZELENA)
        text_restart = font_maly.render("Stiskni MEZERNÍK pro novou hru", True, BILA)
        
        # Obtisknutí doprostřed okna
        okno.blit(text_vitez, (SIRKA//2 - text_vitez.get_width()//2, 200))
        okno.blit(text_restart, (SIRKA//2 - text_restart.get_width()//2, 300))

    # Obraz je složený nanečisto v paměti. .flip() ho teprve natvrdo pošle na monitor!
    pygame.display.flip()
    
    # Pauza na udržení stabilních 60 FPS
    hodiny.tick(60)

# Konec programu
pygame.quit()
sys.exit()