Pygame

Portál:	Virtuálna Univerzita Mateja Bela
Kurz:	Tvorba hier a používateľského zážitku
Kniha:	Pygame

Vytlačil(a):	Hosťovský používateľ
Dátum:	utorok, 27 októbra 2026, 13:29

Obsah

1. Úvod a inštalácia
2. Vytvorenie obrazovky a pohyb
3. Pygame hra

1. Úvod a inštalácia

Pygame je herný framework, ktorý umožňuje vytvárať hry v jazyku Python. Poskytuje sadu tried a funkcií, pomocou ktorých je možné na obrazovku vykresľovať rastry, prehrávať zvuky, zachytávať vstupy a pod. Pygame nepridáva žiadne pokročilé konštrukcie, celá logika hry závisí na vývojároch. Pre Python existuje množstvo frameworkov (grafické aplikácie a pod. Tkinter, Turtle...). Väčšina z nich majú spoločnú vlastnosť, že sú pomalé, keď sa ich vizuálna podoba mení. Ďalšou výhodou Pygame je schopnosť používať hardvérovú akceleráciu.

Zoznam už vytvorený hier:

https://www.pygame.org/tags/all

Zdrojové kódy hier:

Tic Tac Toe https://www.pygame.org/project/4303
Flappy Bird https://www.pygame.org/project/4303

Inštalácia Pygame

1. Python - musíme mať nainštalovaný Python (napr. vo verzii 3.10 a vyššie)

Stiahnuť Python môžeme napr. zo stránky: https://www.python.org/downloads/

Pri inštalácií je vhodné zaškrtnúť možnosť "Add Python 3.10 to PATH" !!!

2. Otvoriť príkazový riadok CMD (vo vyhľadávaní dať CMD) a napísať príkaz

pip install pygame

2. Vytvorenie obrazovky a pohyb

Ako prvú vec, čo musíme urobiť je pridať knižnicu pygame a inicializovať ho volaním funkcie init().

import pygame
pygame.init()

Na vytvorenie okna si vytvoríme premennú, v ktorej vytvoríme okno pomocou volania funkcie pygame.display.set_mode(). Ak chceme maximalizovať okno. tak ako parameter dáme hodnoty 0. Ak chceme fullscreen, tak pridáme ďalší parameter pygame.FULLSCREEN (upozornenie pri vytváraní projektu, ak nemáme nastavené kedy sa hra ukončí, nebudeme vedieť vypnúť okno hry)

okno = pygame.display.set_mode((500,500))
#okno = pygame.display.set_mode((0,0), pygame.FULLSCREEN)

V tomto kroku je vytvorená obrazovka s čiernym pozadím.
       

Ak chceme nastaviť vlastný popis hry, tak môžeme pridať príkaz set_caption()

pygame.display.set_caption("Prvá hra")

Vykreslenie tvarov

na vykreslenie tvarov môžeme používať podmodul pygame.draw. Najčastejšie môžeme pridávať:

kruh: pygame.draw.circle(povrch, farba, (x, y), polomer) - (x, y) ak chceme stred
obdĺžnik: pygame.draw.rect(povrch, farba, obdĺžnik), kde obdĺžnik je objekt triedy Rect . Vytvoríme ho ako pygame.Rect(x, y, šírka, výška). x a y udáva pozíciu ľavého horného rohu.
polygon: pygame.draw.polygon(povrch, farba, body), kde body je zoznam vo formáte (x, y)
čiara: pygame.draw.line(povrch, farva, start_pozicie, koniec_pozicie)

Farba sa udáva v RGB hodnotách (0-255), pričom môžeme pridať ešte priehľadnosť (červená, modrá, zelená, [priehľadnosť]).

Pridaním kruhu do nášho kódu sa však nič nevykreslí (resp. tak rýchlo, že to nepostrehneme):

import pygame
pygame.init()
pygame.draw.circle(screen, (0, 0, 255), (400, 300), 150)

Herný cyklus

V predchádzajúcom príklade sme vytvorili jeden krok, ktorý sa vykonal raz a hneď skončil. Ak chceme, aby bol zobrazený celý čas, musíme ho dať do cyklu while True. Na konci cyklu je vhodné pridať pygame.display.flip(), ktorý zaktualizuje obrazovku. Alternatívou je pridať prekreslenie obrazovky pygame.display.update().

pygame.display.flip() - aktualizuje obsah celej obrazovky
pygame.display.update() - umožňuje aktualizovať časť obrazovky, nie celú plochu. Ak neuvedieme žiadny argument aktualizuje celú obrazovku. Preferovaný spôsob (je rýchlejší vo väčšine prípadov).
pygame.display.update(update_rect) #aktualizovalo by iba obsah funkcie update_rect

while True:
pygame.draw.circle(screen, (0, 0, 255), (400, 300), 150)
pygame.display.flip() #pygame.display.update()

Udalosti

Zoznam všetkých udalostí získame pomocou volania funkcie pygame.event.get()

pygame.QUIT - volá sa, keď sa niekto pokúsi ukončiť okno hry
pygame.MOUSEBUTTONDOWN - pri stlačení tlačídla myši
pygame.MOUSEBUTTONUP - pri uvolnení tlačídla myši
pygame.KEYDOWN - pri stlačení nejakého tlačídla
pygage.KEYUP - pri uvolnění nejakého tlačídla

Problém môže byť, keď chceme ukončiť hru stlačením tlačidla ESC, nakoľko hra beží v cykle while True. Vhodnejšie je vytvoriť premennú ešte pred vytvorením herného cykla a následne pri stlačení ESC zmeníme hodnotu premennej True na False.

pygame.init()
okno = True

while spustena:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            spustena = False
        elif event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE:
           spustena = False

    okno = pygame.display.set_mode((800, 600))
    pygame.draw.circle(screen, (0, 0, 255), (400, 300), 150)
    pygame.display.flip()

Pohyb obdĺžnika

Na pohyb môžeme používať funkciu pygame.key.get_pressed(), v ktorej je uchovaná hodnota, čo používateľ stlačil

hrac_x = 400
hrac_y = 300
while spustena:
        # ...
        pygame.draw.circle(screen, (0, 0, 255), (hrac_x, hrac_y), 150)
        pressed = pygame.key.get_pressed()
        if pressed[pygame.K_w]:  # Hore
            hrac_y -= 5
        if pressed[pygame.K_s]:  # Dole
            hrac_y += 5
        if pressed[pygame.K_a]:  # Doľava
            hrac_x -= 5
        if pressed[pygame.K_d]:  # Doprava
            hrac_x += 5

Obmedzenie FPS

hodiny = pygame.time.Clock()  # vytvoríme nové pygame hodiny
while True:
    # ...
    hodiny.tick(30)  # umiestníme na koniec cyklu

Celý kód (pohyb obdĺžnika + FPS):

pygame.init()
spustena = True
hodiny = pygame.time.Clock()
hrac_x = 400
hrac_y = 300

while spustena:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
           spustena = False
        elif event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE:
           spustena = False

    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_w]:  
        hrac_y -= 5
    if pressed[pygame.K_s]: 
        hrac_y += 5
    if pressed[pygame.K_a]:  
        hrac_x -= 5
    if pressed[pygame.K_d]: 
        hrac_x += 5

    okno = pygame.display.set_mode((800, 600))
    pygame.draw.circle(okno, (0, 0, 255), (hrac_x, hrac_y), 150)
    pygame.draw.rect(okno, (0, 255, 0), pygame.Rect(10, 10, 100, 200))
    pygame.display.flip()
    hodiny.tick(30)

Písmo

Zoznam všetkých dostupných systémových písiem: pygame.font.get_fonts().

Systémové písmo

font = pygame.font.SysFont(font_name, size)

Vlastné písmo - pribalíme k programu, namiesto path vkladáme cestu k .ttf

font = pygame.font.Font(path, size)

Vykreslenie písma - písmo zobrazíme pomocou funkcie render(), txt - String, True je antialiasing (zaoblí rohy písma)

text = font.render(txt, True, color)

Ukážka:

font = pygame.font.Font('myfont.ttf', 30) 
text = font.render("Červený text", True, (255, 0, 0))
screen.blit(text, (10, 10))

Zachovanie veľkosti pre rôzne obrazovky

font = pygame.font.Font('myfont.ttf', 30) 
# povrch obrazovky bude mať rozlíšenie 1920x1080
okno = pygame.Surface((1920, 1080))
# displej bude mať ľubovoľné rozlíšenie (napr. fullscreen)
display = pygame.display.set_mode((0, 0))
# klasicky kreslíme všetko na obrazovku
pygame.draw.rect(okno, (255, 255, 255), pygame.Rect((10, 10), (100, 100)))
# na konci prevedieme celé okno na veľkosť displeja
pygame.transform.scale(okno, display.get_size(), display)
# zobrazíme zmeny na monitore
pygame.display.flip()

Zistenie kolízií obdĺžnikov

rect.collidepoint((x, y)) - vracia True, ak sa bod (x, y) nachádza vo vnútri obdĺžnika
rect.colliderect(rect2) - vracia True, ak majú dva obdĺžniky prienik
rect.collidelist(lst) - vracia True, ak aspoň jeden z obdĺžnikov ke vo vnútri zoznamu má prienik s hlavným
rect.collidelistall(lst) - vracia True, ak všetky obdĺžniky vo vnútri zoznamu majú prienik s hlavným

font = pygame.font.Font('myfont.ttf', 30) 
# povrch obrazovky bude mať rozlíšenie 1920x1080
okno = pygame.Surface((1920, 1080))
# displej bude mať ľubovoľné rozlíšenie (napr. fullscreen)
display = pygame.display.set_mode((0, 0))
# klasicky kreslíme všetko na obrazovku
pygame.draw.rect(okno, (255, 255, 255), pygame.Rect((10, 10), (100, 100)))
# na konci prevedieme celé okno na veľkosť displeja
pygame.transform.scale(okno, display.get_size(), display)
# zobrazíme zmeny na monitore
pygame.display.flip()

Pozadie obrazovky

pozadie = pygame.Color(100,149,237) 
# povrch obrazovky bude mať farbu cornflower modrá

okno = pygame.Surface((1920,1080))

while spustena:
    okno.fill(pozadie)

Načítanie obrázkov

Rozlíšenie obrazovky

pygame.image.load('obrazok.png')
okno.blit(premennaObrazok, (poziciaX,poziciaY))

obrazok = pygame.image.load('logoUMB.png')
okno = pygame.Surface((1920,1080))
while spustena:
   ...
   okno.blit(obrazok,(0,0))

3. Pygame hra

3.1. Vytvorenie štvorca a jeho pohyb

font = pygame.font.Font('myfont.ttf', 30) 
import pygame
pygame.init()

okno = pygame.display.set_mode((500, 500))
pygame.display.set_caption("Prvá hra")

Pre nastavenie pohybu postáv si vytvoríme premenné

font = pygame.font.Font('myfont.ttf', 30) 
x = 50
y = 50
sirka = 40
vyska = 60
posun = 5

Pridáme hernú slučku

font = pygame.font.Font('myfont.ttf', 30) 
spustena = True

while spustena:
    pygame.time.delay(100) # oneskorenie v millisekundách (oneskorenie 0,1 sekundy)

    for event in pygame.event.get():  
        if event.type == pygame.QUIT: # kliknutie na ikonku v pravom hornom rohu
            spustena = False  # ukončí hernú slučku

pygame.quit()  # ak je ukončená herná slučka, nasleduje ďalší príkaz za hernou slučkou

Do hernej slučky pridáme vytvorenie štvorca s parametrami x,y, sirka, vyska, ktoré sme vytvorili na začiatku súboru

font = pygame.font.Font('myfont.ttf', 30) 
while spustena:
    #....

    pygame.draw.rect(okno, (255,0,0), (x, y, sirka, vyska))  
    pygame.display.update() # aktualizujeme obrazovku

Pridáme udalosti pre pohyb štvorca

font = pygame.font.Font('myfont.ttf', 30) 
while spustena:
    #....

    klávesy = pygame.key.get_pressed()
    
    if klávesy[pygame.K_LEFT]:
        x -= posun

    if klávesy[pygame.K_RIGHT]:
        x += posun

    if klávesy[pygame.K_UP]:
        y -= posun

    if klávesy[pygame.K_DOWN]:
        y += posun
    #vykreslenie štvorca, aktualizovanie okna....

Upravíme kód pridaním okno.fill((0,0,0)) - vyplní čiernou obrazovkou

font = pygame.font.Font('myfont.ttf', 30) 
while spustena:
    #....

    if klávesy[pygame.K_DOWN]:
        y += posun
    okno.fill((0,0,0))
    #vykreslenie štvorca, aktualizovanie okna....

Celý kód:

font = pygame.font.Font('myfont.ttf', 30) 
import pygame
pygame.init()

okno = pygame.display.set_mode((500,500))
pygame.display.set_caption("Prvá hra")

x = 50
y = 50
sirka = 40
vyska = 60
posun = 5

spustena = True

while spustena:
    pygame.time.delay(100)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            spustena = False

    klávesy = pygame.key.get_pressed()
    
    if klávesy[pygame.K_LEFT]:
        x -= posun

    if klávesy[pygame.K_RIGHT]:
        x += posun

    if klávesy[pygame.K_UP]:
        y -= posun

    if klávesy[pygame.K_DOWN]:
        y += posun
    
    okno.fill((0,0,0))  
    pygame.draw.rect(okno, (255,0,0), (x, y, width, height))   
    pygame.display.update() 
    
pygame.quit()

3.2. Skákanie

Udalosť na ohraničenie pohybu ku krajom obrazovky

while spustena:
    #...
    
    if klávesy[pygame.K_LEFT] and x > posun:
        x -= posun

    if klávesy[pygame.K_RIGHT] and x < 500 - posun - sirka:
        x += posun

    if klávesy[pygame.K_UP] and y > posun:
        y -= posun

    if klávesy[pygame.K_DOWN] and y < 500 - height - vyska:
        y += posun
   
   #...

Skákanie vytvoríme nové premenné, ktoré budú uchovávať stav, či sme vo výskoku a o koľko vyskočíme. Premenné vytvoríme mimo hernej slučky. V hernej slucke upravime podmienky s pohybom

while spustena:
  #...x,y,sirka, vyska, posun
    
  jeVoVyskoku = False
  skokPocet = 10
   
  while spustena: 
      #...
      if klavesy[pygame.K_LEFT] and x > posun: 
        x -= posun

      if klavesy[pygame.K_RIGHT] and x < 500 - posun - sirka:  
        x += posun
        
      if not(jeVoVyskoku): 
        if klavesy[pygame.K_UP] and y > posun: 
            y -= posun

        if klavesy[pygame.K_DOWN] and y < 500 - vyska - posun:
            y += posun

        if klavesy[pygame.K_SPACE]:
            jeVoVyskoku = True
    else:
        # co sa stane ked skaceme

Do časti else pridáme, čo sa stane, keď skáčeme

else:
 	if skokPocet >= -10:
   	y -= (skokPocet * abs(skokPocet)) * 0.5
   	skokPocet -= 1
	else: 
    skokPocet = 10
    jeVoVyskoku = False

Celý kód:

import pygame
pygame.init()

okno = pygame.display.set_mode((500,500))
pygame.display.set_caption("Prvá hra")

x = 50
y = 50
sirka = 40
vyska = 60
posun = 5

jeVoVyskoku = False
skokPocet = 10

spustena = True

while spustena:
    pygame.time.delay(100)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            spustena = False

    klávesy = pygame.key.get_pressed()
    
    if klávesy[pygame.K_LEFT] and x > posun: :
        x -= posun

    if klávesy[pygame.K_RIGHT]  and x < 500 - posun - sirka: :
        x += posun
		
    if not(jeVoVyskoku): 
    		if klávesy[pygame.K_UP] and y > posun:
       		 y -= posun

    		if klávesy[pygame.K_DOWN] and y < 500 - vyska - posun:
       		 y += posun
    
        if klávesy[pygame.K_SPACE]:
            jeVoVyskoku = True
    else:
        if skokPocet >= -10:
            y -= (skokPocet * abs(skokPocet)) * 0.5
            skokPocet -= 1
        else: 
            skokPocet = 10
            jeVoVyskoku = False        
   
    okno.fill((0,0,0))  
    pygame.draw.rect(okno, (255,0,0), (x, y, width, height))   
    pygame.display.update() 
    
pygame.quit()

3.3. Postavy

https://lms.umb.sk/pluginfile.php/360989/mod_book/chapter/7518/Obr%C3%A1zky%20a%20hudba.rar

Pridáme premenné, ktoré budú uchovávať informáciu, či je postava otočená naľavo alebo napravo, alebo či stojí.


otocenaVlavo = False
otocenaVpravo = False
pocetKrokov = 0

Načítame obrázky pomocou funkcie pygame.image.load(path)


kracaDoprava = [pygame.image.load('doprava1.png'), pygame.image.load('doprava2.png'), pygame.image.load('doprava3.png'), pygame.image.load('doprava4.png'), pygame.image.load('doprava5.png'), pygame.image.load('doprava6.png'), pygame.image.load('doprava7.png'), pygame.image.load('doprava8.png'), pygame.image.load('doprava9.png')]

kracaDolava = [pygame.image.load('dolava1.png'), pygame.image.load('dolava2.png'), pygame.image.load('dolava3.png'), pygame.image.load('dolava4.png'), pygame.image.load('dolava5.png'), pygame.image.load('dolava6.png'), pygame.image.load('dolava7.png'), pygame.image.load('dolava8.png'), pygame.image.load('dolava9.png')]

pozadieObr = pygame.image.load('pozadie.jpg')

postavaStoji = pygame.image.load('postavaStoji.png')

Prekresľovanie obrázkov je vhodné vykonávať v samostatnej funkcii:


def prekresliHerneOkno():
    global pocetKrokov
    okno.blit(pozadieObr, (0,0))  # na pozicii 0,0
    pygame.display.update() 
   
while spustena:
    #....
    prekresliHerneOkno()        

pygame.quit()

V hernej slučke pridáme obrázky pre chôdzu naľavo a naprave

def prekresliHerneOkno():
    global pocetKrokov
    
    okno.blit(pozadieObr, (0,0))  # na pozicii 0,0
    pygame.display.update() 

while spustena:
    #....
    if keys[pygame.K_LEFT] and x > posun: 
        x -= posun
        otocenaVlavo = True
        otocenaVpravo = False           

    elif keys[pygame.K_RIGHT] and x < 500 - posun - sirka:  
        x += posun
        otocenaVlavo = False
        otocenaVpravo = True
              
    else: # ak sa postava nepohybuje, tak resetujeme pocitadlo krokov a nastavime otocenieVlavo a otocenieVpravo na hodnotu False
        otocenaVlavo = False
        otocenaVpravo = False
        pocetKrokov = 0
               
    if not(jeVoVyskoku):
        if keys[pygame.K_SPACE]:
            jeVoVyskoku = True              
            otocenaVpravo = False 
            otocenaVlavo = False                    
            pocetKrokov = 0
    else:
        if skokPocet >= -10:
            y -= (skokPocet * abs(skokPocet)) * 0.5
            skokPocet -= 1
        else: 
            skokPocet = 10
            jeVoVyskoku = False

    prekresliHerneOkno() 

pygame.quit()

Vykresľovanie postavy:

def prekresliHerneOkno():
    # Máme 9x obrázok, chceme každý obrázok aby sa zobrazil 3 frame
    #  27 / 3 = 9
    # 3x sa zobrazí každá animácia
    global pocetKrokov
      
    okno.blit(pozadieObrazok, (0,0))  

#ak je v ďalšom kroku počet krokov väčší ako 27, tak kroky vynuluje
    if pocetKrokov + 1 >= 27:
        pocetKrokov = 0
    
#ak je postava otočená vľavo    
    if otocenaVlavo:
        okno.blit(kracaDolava[pocetKrokov//3], (x,y))  # Máme 9 obrázkov, vydelíme 3, aby každý obrázok sa zobrazil práve 3x
        pocetKrokov += 1                          
    elif otocenaVpravo:
        win.blit(kracaDoprava[pocetKrokov//3], (x,y))
        pocetKrokov += 1
    else:
        okno.blit(postavaStoji, (x, y))  # ak postava stojí, tak nastavíme obrázok
          
    pygame.display.update()

Poslednú vec, čo musíme nastaviť je "framerate" (snímky za sekundu). Vytvoríme premennú, do ktorej uložíme objekt Clock(). V hernej slučke zavoláme funkciu tick(), ktorá sa zavolá raz za jeden frame. Počíta koľko milisekúnd prešlo od posledného volania.

#....
pygame.display.set_mode((500, 480))
#....
clock = pygame.time.Clock()
#....

while spustena:
    clock.tick(27)     
    #....

Celý kód:

import pygame
pygame.init()

okno = pygame.display.set_mode((500,480))
pygame.display.set_caption("Prvá hra")

kracaDoprava = [pygame.image.load('doprava1.png'), pygame.image.load('doprava2.png'), pygame.image.load('doprava3.png'), pygame.image.load('doprava4.png'), pygame.image.load('doprava5.png'), pygame.image.load('doprava6.png'), pygame.image.load('doprava7.png'), pygame.image.load('doprava8.png'), pygame.image.load('doprava9.png')]

kracaDolava = [pygame.image.load('dolava1.png'), pygame.image.load('dolava2.png'), pygame.image.load('dolava3.png'), pygame.image.load('dolava4.png'), pygame.image.load('dolava5.png'), pygame.image.load('dolava6.png'), pygame.image.load('dolava7.png'), pygame.image.load('dolava8.png'), pygame.image.load('dolava9.png')]

pozadieObr = pygame.image.load('pozadie.jpg')

postavaStoji = pygame.image.load('postavaStoji.png')

x = 50
y = 400
sirka = 40
vyska = 60
posun = 5

clock = pygame.time.Clock()

jeVoVyskoku = False
skokPocet = 10

otocenaVlavo = False
otocenaVpravo = False
pocetKrokov = 0

def prekresliHerneOkno():
    global pocetKrokov
    
    okno.blit(pozadieObr, (0,0))  
    if pocetKrokov + 1 >= 27:
        pocetKrokov = 0
        
    if otocenaVlavo:  
        okno.blit(kracaDolava[pocetKrokov//3], (x,y))
        pocetKrokov += 1                          
    elif otocenaVpravo:
        okno.blit(kracaDoprava[pocetKrokov//3], (x,y))
        pocetKrokov += 1
    else:
        okno.blit(postavaStoji, (x, y))
        pocetKrokov = 0
        
    pygame.display.update() 
    


spustena = True

while spustena:
    clock.tick(27)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            spustena = False

    klavesy = pygame.key.get_pressed()
    
    if klavesy[pygame.K_LEFT] and x > posun: 
        x -= posun
        otocenaVlavo = True
        otocenaVpravo = False

    elif klavesy[pygame.K_RIGHT] and x < 500 - posun - sirka:  
        x += posun
        otocenaVlavo = False
        otocenaVpravo = True
        
    else: 
        otocenaVlavo = False
        otocenaVpravo = False
        pocetKrokov = 0
        
    if not(jeVoVyskoku):
        if klavesy[pygame.K_SPACE]:
            jeVoVyskoku = True
            otocenaVlavo = False
            otocenaVpravo = False
            pocetKrokov = 0
    else:
        if skokPocet >= -10:
            y -= (skokPocet * abs(skokPocet)) * 0.5
            skokPocet -= 1
        else: 
            skokPocet = 10
            jeVoVyskoku = False

    prekresliHerneOkno() 
    
    
pygame.quit()

3.4. OOP

import pygame
pygame.init()

okno = pygame.display.set_mode((500,480))

pygame.display.set_caption("Prvá hra")

kracaDoprava = [pygame.image.load('doprava1.png'), pygame.image.load('doprava2.png'), pygame.image.load('doprava3.png'), pygame.image.load('doprava4.png'), pygame.image.load('doprava5.png'), pygame.image.load('doprava6.png'), pygame.image.load('doprava7.png'), pygame.image.load('doprava8.png'), pygame.image.load('doprava9.png')]

kracaDolava = [pygame.image.load('dolava1.png'), pygame.image.load('dolava2.png'), pygame.image.load('dolava3.png'), pygame.image.load('dolava4.png'), pygame.image.load('dolava5.png'), pygame.image.load('dolava6.png'), pygame.image.load('dolava7.png'), pygame.image.load('dolava8.png'), pygame.image.load('dolava9.png')]

pozadieObr = pygame.image.load('pozadie.jpg')

postavaStoji = pygame.image.load('postavaStoji.png')

clock = pygame.time.Clock()

class hrac(object):

  def __init__(self,x,y,sirka,vyska):
        self.x = x
        self.y = y
        self.sirka = sirka
        self.vyska = vyska
        self.posun = 5
        self.jeVoVyskoku = False
        self.otocenaVlavo = False
        self.otocenaVpravo = False
        self.pocetKrokov = 0
        self.skokPocet = 10

    def vykresliPostavu(self, okno):
        if self.pocetKrokov + 1 >= 27:
            self.pocetKrokov = 0

        if self.otocenaVlavo:
            okno.blit(kracaDolava[self.pocetKrokov//3], (self.x,self.y))
            self.pocetKrokov += 1
        elif self.otocenaVpravo:
            okno.blit(kracaDoprava[self.pocetKrokov//3], (self.x,self.y))
            self.pocetKrokov +=1
        else:
            okno.blit(postavaStoji, (self.x,self.y))
            
def prekresliHerneOkno():
    okno.blit(pozadieObr, (0,0))  
    hrac1.vykresliPostavu(okno)
    pygame.display.update() 
    
hrac1 = hrac(200, 410, 64,64)
spustena = True

while spustena:
    clock.tick(27)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            spustena = False

    klavesy = pygame.key.get_pressed()
    
    if klavesy[pygame.K_LEFT] and hrac1.x > hrac1.posun: 
        hrac1.x -= hrac1.posun
        hrac1.otocenaVlavo = True
        hrac1.otocenaVpravo = False

    elif klavesy[pygame.K_RIGHT] and hrac1.x < 500 - hrac1.posun - hrac1.sirka:  
        hrac1.x += hrac1.posun
        hrac1.otocenaVlavo = False
        hrac1.otocenaVpravo = True
        
    else: 
        hrac1.otocenaVlavo = False
        hrac1.otocenaVpravo = False
        hrac1.pocetKrokov = 0
        
    if not(hrac1.jeVoVyskoku):
        if klavesy[pygame.K_SPACE]:
            hrac1.jeVoVyskoku = True
            hrac1.otocenaVlavo = False
            hrac1.otocenaVpravo = False
            hrac1.pocetKrokov = 0
    else:
        if hrac1.skokPocet >= -10:
            hrac1.y -= (hrac1.skokPocet * abs(hrac1.skokPocet)) * 0.5
            hrac1.skokPocet -= 1
        else: 
            hrac1.skokPocet = 10
            hrac1.jeVoVyskoku = False

    prekresliHerneOkno() 
    
    
pygame.quit()

3.5. Náboje

Pridáme triedu pre náboje:

class naboje(object):
    def __init__(self,x,y,polomer,farba,smer):
        self.x = x
        self.y = y
        self.polomer = polomer
        self.farba = farba
        self.smer = smer
        self.posun = 8 * smer

    def vykresliNaboj(self,okno):
        pygame.draw.circle(okno, self.farba, (self.x,self.y), self.polomer)

Upravíme triedu hraca (náš hráč musí byť otočený vždy buď doľava/doprava):

class hrac(object):
 	def __init__(self,x,y,sirka,vyska):
        self.x = x
        self.y = y
        self.sirka = sirka
        self.vyska = vyska
        self.posun = 5
        self.jeVoVyskoku = False
        self.otocenaVlavo = False
        self.otocenaVpravo = False
        self.pocetKrokov = 0
        self.skokPocet = 10
        self.stoji=True

    def vykresliPostavu(self, okno):
        if self.pocetKrokov + 1 >= 27:
            self.pocetKrokov = 0
	if not(self.stoji):
            if self.otocenaVlavo:
            	okno.blit(kracaDolava[self.pocetKrokov//3], (self.x,self.y))
            	self.pocetKrokov += 1
            elif self.otocenaVpravo:
            	okno.blit(kracaDoprava[self.pocetKrokov//3], (self.x,self.y))
            	self.pocetKrokov +=1
        else:
            if self.otocenaVpravo:
            	okno.blit(kracaDoprava[0], (self.x,self.y))
            else:
            	okno.blit(kracaDolava[0], (self.x,self.y))

Upravíme hernú slučku

import pygame

while spustena:
    clock.tick(27)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            spustena = False

    klavesy = pygame.key.get_pressed()
    
    if klavesy[pygame.K_LEFT] and hrac1.x > hrac1.posun: 
        hrac1.x -= hrac1.posun
        hrac1.otocenaVlavo = True
        hrac1.otocenaVpravo = False
        hrac1.stoji=False

    elif klavesy[pygame.K_RIGHT] and hrac1.x < 500 - hrac1.posun - >hrac1.sirka:  
        hrac1.x += hrac1.posun
        hrac1.otocenaVlavo = False
        hrac1.otocenaVpravo = True 
        hrac1.stoji=False
        
    else: 
        hrac1.otocenaVlavo = False
        hrac1.otocenaVpravo = False
        hrac1.stoji=True
        hrac1.pocetKrokov = 0
        
    if not(hrac1.jeVoVyskoku):
        if klavesy[pygame.K_SPACE]:
            hrac1.jeVoVyskoku = True
            hrac1.otocenaVlavo = False
            hrac1.otocenaVpravo = False
            hrac1.pocetKrokov = 0
    else:
        if hrac1.skokPocet >= -10:
            hrac1.y -= (hrac1.skokPocet * abs(hrac1.skokPocet)) * 0.5
            hrac1.skokPocet -= 1
        else: 
            hrac1.skokPocet = 10
            hrac1.jeVoVyskoku = False

    prekresliHerneOkno() 
    
    
pygame.quit()

Nastavíme náboje

import pygame
...
postavaStoji = pygame.image.load('postavaStoji.png')

clock = pygame.time.Clock()
nabojePole = []

while spustena:
    clock.tick(27)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            spustena = False
            
    for naboj in nabojePole:
        if naboj.x < 500 and naboj.x > 0:
           naboj.x += naboj.posun  # naboj sa "pohne"
        else:
           nabojePole.pop(nabojePole.index(naboj))  # odstranime naboj
		
    
    klavesy = pygame.key.get_pressed()
    
    ...
        
    if klavesy[pygame.K_a]:
        if hrac1.otocenaVlavo:
           smer = -1
        else:
           smer = 1

        if len(nabojePole) < 5:  # max 5 nabojov naraz na obrazovke
           nabojePole.append(náboje(round(hrac1.x+hrac1.sirka//2), round(hrac1.y + hrac1.vyska//2), 6, (0,0,0), smer)) # vytvori naboj uprostred hraca

....

Prekreslíme herné okno

import pygame
def prekresliHerneOkno():
    okno.blit(pozadieObr, (0,0))
    hrac1.vykresliPostavu(okno)
    
    for naboj in nabojePole:
        naboj.vykresliNaboj(okno)
    
    pygame.display.update()

Celý kód

import pygame
pygame.init()

window = pygame.display.set_mode((500,500))
pygame.display.set_caption("Prvá hra - enemyAttack")
#ci ma spustit hernu slucku
runnig= True

#glob premenna s pozadim
backgroundImage = pygame.image.load('pozadie.jpg')
#pole s obrazkami kracania dolava
playerWalkingLeft = [pygame.image.load('dolava1.png'),
                     pygame.image.load('dolava2.png'),
                     pygame.image.load('dolava3.png'),
                     pygame.image.load('dolava4.png'),
                     pygame.image.load('dolava5.png'),
                     pygame.image.load('dolava6.png'),
                     pygame.image.load('dolava7.png'),
                     pygame.image.load('dolava8.png'),
                     pygame.image.load('dolava9.png')]
#pole s obrazkami kracania doprava
playerWalkingRight = [pygame.image.load('doprava1.png'),
                      pygame.image.load('doprava2.png'),
                      pygame.image.load('doprava3.png'),
                      pygame.image.load('doprava4.png'),
                      pygame.image.load('doprava5.png'),
                      pygame.image.load('doprava6.png'),
                      pygame.image.load('doprava7.png'),
                      pygame.image.load('doprava8.png'),
                      pygame.image.load('doprava9.png')]

#pygame.image.load() nacitame obrazok
playerImageStand = pygame.image.load('postavaStoji.png')

#obmzedzenie FPS
timer = pygame.time.Clock()

class player(object):
    #init musi byt vzdy pri class
    def __init__(self,x,y,widht, height):
        self.x = x
        self.y = y
        self.width = widht
        self.height = height
        self.step = 5 #pohyb dolava/doprava
        self.stepCount = 0 #na pole s obrazkami
        self.turnLeft = False #kde je otoceny
        self.turnRight = False
        self.isJumping = False #ci je vo vyskoku
        self.jumpCount = 10 #do akej vysky vyskok
        self.isStanding = True #pomoc premenna ci stoji/je v pohybe

    #na vykreslenie postavy
    def drawPlayer(self, window):
        #mame 9 obrazkov, kazdy obrazok sa zobrazi 3x
        if self.stepCount + 1 > 27:
           self.stepCount = 0
        if not(self.isStanding):
            if self.turnLeft:
            #mame 9 obrazkov, pocet krokov 27, musime vydelit 3
                window.blit(playerWalkingLeft[self.stepCount//3], (self.x, self.y))
                self.stepCount += 1
            elif self.turnRight:
                window.blit(playerWalkingRight[self.stepCount//3], (self.x, self.y))
                self.stepCount += 1
        else:
            #nastavime obrazok kraca dolava/doprava s index 0
            if self.turnRight:
                window.blit(playerWalkingRight[0],(self.x,self.y))
            else:
                window.blit(playerWalkingLeft[0],(self.x,self.y))



class bullets(object):
    def __init__(self,x,y,radius,color,direction):
        self.x = x
        self.y = y
        self.radius = radius
        self.color = color
        self.step = 8 * direction

    def drawBullet(self,window):
        pygame.draw.circle(window,self.color,
                           (self.x,self.y), self.radius)



def redrawGameWindow():
    window.blit(backgroundImage, (0,0))

    #pridame hracovi vzhlad - nasu funkciu vytvorenu
    player1.drawPlayer(window)

    for bullet in bulletArray:
        bullet.drawBullet(window)
    #vzdy posledne
    pygame.display.update()

#vytvorime  hraca so suradnicami, velkostou
player1 = player(100,415,64,64)
bulletArray = []
#herna slucka
while runnig:
    #pre vsetky udalosti
    for event in pygame.event.get():
        #ked stlacime X na okne
        if event.type == pygame.QUIT:
            runnig = False

    for bullet in bulletArray:
        if bullet.x < 500 and bullet.x > 0:
            bullet.x  += bullet.step #naboj sa "pohne"
        else:
            #odstranime naboj
            bulletArray.pop(bulletArray.index(bullet))
    #pole:pygame.key.get_pressed() - ulozene tlacidla na klavesnici
    pressed = pygame.key.get_pressed()
    #po stlaceni W pojde nahor alternativa ...[pygame.K_UP]
    #iba ked hrac nie je vo vyskoku
    if not(player1.isJumping):
        # po stlaceni medzernika vyskoci
        if pressed[pygame.K_SPACE]:
            #docasne nastavime hodnotu vyskoku na True
            player1.isJumping = True
            #ked je vo vyskoku zrus otocenie hraca
            player1.turnLeft = False
            player1.turnRight = False

    else:
        if player1.jumpCount >= -10:
            player1.y -= (player1.jumpCount * abs(player1.jumpCount)*0.5)
            player1.jumpCount -=1
        else:
            #zresetujeme jumpCount a zaroven hrac uz nie je vo vyskoku
            player1.jumpCount = 10       
            player1.isJumping=False
        # po stlaceni W pojde nahor
    if pressed[pygame.K_a] and player1.x > player1.step:
        player1.x -= player1.step
        #ulozime stav, kde je otoceny hrac
        player1.turnLeft = True
        player1.turnRight = False
        player1.isStanding=False
        # po stlaceni W pojde nahor
    elif pressed[pygame.K_d] and player1.x < 500 - player1.step - player1.width:
        player1.x += player1.step
        # ulozime stav, kde je otoceny hrac
        player1.turnRight = True
        player1.turnLeft = False
        player1.isStanding=False
        # nas hrac
    else:
        #vyresetujeme pocet krokov
        player1.stepCount = 0
        player1.isStanding = True
    #strielame napr. Q
    if pressed[pygame.K_q]:
        #uchovame smer ktorym strielame
        if player1.turnLeft:
            direction = -1
        else:
            direction = 1
        #obmezdzime pocet naboj na obrazovke na 5
        if len(bulletArray) < 5:
            #bullets maju 5 parametrov (x,y,radius,color,direction)
            #pozicia x a y bude v strede hraca, preto //2
            bulletArray.append(bullets(round(player1.x+player1.width//2),
                                       round(player1.y+player1.height//2),
                                       6,
                                       (0,0,0),
                                       direction))
    pygame.draw.rect(window, (255, 0, 0), (player1.x, player1.y, player1.width, player1.height))

    #musi byt posledne, aby sa aktualizovala obrazovka
    timer.tick(30)
    #zavolame pomocnu funkciu na prekreslenie herneho okna
    redrawGameWindow()

3.6. Nepriateľ

Vytvoríme triedu nepriateľ

class nepriatel(object):
    kracaDolava= 
       [pygame.image.load('nepriatelDolava1.png'), 
        pygame.image.load('nepriatelDolava2.png'), 
        pygame.image.load('nepriatelDolava3.png'), 
        pygame.image.load('nepriatelDolava4.png'), 
        pygame.image.load('nepriatelDolava5.png'), 
        pygame.image.load('nepriatelDolava6.png'), 
        pygame.image.load('nepriatelDolava7.png'), 
        pygame.image.load('nepriatelDolava8.png'), 
        pygame.image.load('nepriatelDolava9.png'), 
        pygame.image.load('nepriatelDolava10.png'), 
        pygame.image.load('nepriatelDolava11.png')]
    kracaDoprava= 
        [pygame.image.load('nepriatelDoprava1.png'), 
         pygame.image.load('nepriatelDoprava2.png'), 
         pygame.image.load('nepriatelDoprava3.png'), 
         pygame.image.load('nepriatelDoprava4.png'), 
         pygame.image.load('nepriatelDoprava5.png'), 
         pygame.image.load('nepriatelDoprava6.png'), 
         pygame.image.load('nepriatelDoprava7.png'), 
         pygame.image.load('nepriatelDoprava8.png'), 
         pygame.image.load('nepriatelDoprava9.png'), 
         pygame.image.load('nepriatelDoprava10.png'), 
         pygame.image.load('nepriatelDoprava11.png')] 
    
    def __init__(self, x, y, sirka, vyska, koniec):
        self.x = x
        self.y = y
        self.sirka = sirka
        self.vyska = vyska
        self.cesta = [x, koniec]  # kde zacina a kde konci cestu.
        self.pocetKrokov = 0
        self.posun = 3
        
    def vykresliNepriatela(self, okno):
         self.pohybNepriatela()
         if self.pocetKrokov + 1 >= 33: # 11 obrazkov, kazdy obrazok 3x na obrazovke. 
              # kazdy obrazok ukazeme 3x.... 3 x 11 = 33.
              self.pocetKrokov = 0
         if self.posun> 0: # ak sa pohybuje doprava, zobrazime obr doprava
              okno.blit(self.kracaDoprava[self.pocetKrokov//3], (self.x,self.y))
              self.pocetKrokov+= 1
         else:  
              okno.blit(self.kracaDolava[self.pocetKrokov//3], (self.x,self.y))
              self.pocetKrokov += 1 #pridame metodu na pohyb

     def pohybNepriatela(self):
             if self.posun> 0:  # ak sa pohybujeme doprava
               if self.x < self.cesta[1] + self.posun: # pokial sa nedotkneme konca cesty
                 self.x += self.posun
               else: # zmeni smer
                 self.posun = self.posun * -1
                 self.x += self.posun
                 self.pocetKrokov = 0
            else: # ak sa pohybujeme dolava
               if self.x > self.cesta[0] - self.posun: # ak sa nedotkneme laveho konca
                 self.x += self.posun
               else:  # zmeni smer
                 self.posun = self.posun * -1
                 self.x += self.posun
                 self.pocetKrokov = 0

Vytvoríme inštanciu nepriateľa

    ....
    nepriatel1= nepriatel(100, 410, 64, 64, 300)
    ...

    def prekresliHerneOkno():
        okno.blit(pozadieObr, (0,0))
        hrac1.vykresliPostavu(okno) 
        nepriatel1.vykresliNepriatela(okno) 
        for naboj in nabojePole:
          naboj.vykresliNaboj(okno)   
        pygame.display.update()

Celý kód:

...