V šestém článku věnovaném programovacím jazykům a taktéž knihovnám, které mohou být vhodné pro výuku programování i základů počítačové grafiky, se seznámíme s principy použití knihovny Pygame. V některých ohledech se Pygame podobá již dříve popsané knihovně LÖVE, ovšem s tím rozdílem, že knihovna Pygame je založena na použití dnes velmi populárního programovacího jazyka Python a nikoli jazyka Lua.
Obsah
1. Programovací jazyk Python jakožto jedna z vhodných pomůcek pro výuku programování
3. Principy, na nichž je knihovna Pygame postavena
4. Kostra aplikace používající knihovnu Pygame
5. Dva způsoby omezení vytížení procesoru při zpracování událostí
6. Double buffering a funkce pygame.display.flip() a pygame.display.update()
7. Vykreslování základních geometrických tvarů
8. Změna barev vybraných pixelů
9. Repositář se zdrojovými kódy dnešních demonstračních příkladů
10. Funkce použité v dnešních demonstračních příkladech
1. Programovací jazyk Python jakožto jedna z vhodných pomůcek pro výuku programování
V předchozích částech seriálu o programovacích jazycích a taktéž o knihovnách, které mohou být vhodné pro výuku programování i pro seznámení se se základy počítačové grafiky, jsme si již popsali několik systémů navržených právě pro oblast výuky popř. pro tvorbu jednodušších (převážně dvourozměrných) her a různých grafických dem. Připomeňme si, že v prvním článku jsme si popsali systém Scratch, dále pak projekt nazvaný Snap!, který vychází ze Scratche, a navíc ještě jednoduše použitelné vývojové prostředí Basic-256 založené na moderní podobě programovacího jazyka BASIC.
Obrázek 1: Systém Scratch popsaný v prvním článku. Programy se ve Scratchi tvoří přetahováním příkazových bloků z oblasti umístěné v levé části okna do střední oblasti, zde nadepsané „Skripty“ (nová verze Scratche používá nepatrně odlišný design grafického uživatelského rozhraní).
I v části druhé byly popsány další interpretry a překladače moderních variant BASICu, především pak projekty sdlBasic a FreeBasic. Ve třetí části i v částech navazujících jsme se zabývali převážně popisem knihovny LÖVE založené na programovacím jazyku Lua. I přesto, že je programovací jazyk Lua při tvorbě počítačových her úspěšně používán přes dvacet let, a má tedy v této oblasti velmi dlouhou tradici, objevují se i nové knihovny a enginy, které v oblasti tvorby her využívají jiné vyšší (řekněme poněkud nepřesně skriptovací) programovací jazyky.
Obrázek 2: Zobrazení průběhu funkce v Basicu-256.
Za zmínku zcela jistě stojí projekt Pygame, což je knihovna určená pro programovací jazyk Python, která (ve většině implementací) interně volá funkce nativní knihovny SDL a několika dalších podpůrných knihoven. Myšlenka, na níž je knihovna Pygame postavena, je v mnoha ohledech podobná myšlence již v předchozích článcích popsaného systému LÖVE – implementace nízkoúrovňových operací je vytvořena odborníky, kteří znají jak nízkoúrovňové programovací jazyky C a C++, tak i nízkoúrovňové knihovny typu SDL či OpenGL. Pokud budou tyto operace implementovány dostatečně rychle, je již možné zbytek hry či nějakého grafického dema naprogramovat ve vysokoúrovňovém jazyku Python. A ukazuje se, že je tato myšlenka – a obecně systém rozdělení aplikace mezi dva programovací jazyky s rozdílnou úrovní abstrakce – poměrně úspěšná, neboť v Pygame již vzniklo mnoho kvalitních her a současně je tato knihovna dostatečně jednoduchá, aby ji bylo možné použít i ve výuce.
Obrázek 3: Integrované vývojové prostředí sdlBasicu popsaného v druhém článku.
2. Knihovna Pygame a Pyglet
Knihovna Pygame je kvůli své relativně těsné vazbě na nativní knihovnu SDL (ta však ve skutečnosti není povinná a setkáme se i s alternativními implementacemi) určena především pro tvorbu dvourozměrných her, tj. například různých strategií, plošinovek (platform game), stříleček, RPG (role playing game) apod. Předností je taktéž možnost spustit hru postavenou na Pygame na mnoha platformách, zejména na Linuxu, MacOS, Windows, všech třech systémech *BSD a podmnožina funkcí Pygame funguje i na Androidu (instalační soubory lze nalézt na adrese http://pygame.org/download.shtml, v mnoha distribucích Linuxu však Pygame nalezneme přímo v hlavním repositáři). Ovšem ve chvíli, kdy již možnosti Pygame nedostačují a je zapotřebí vytvořit plnohodnotnou trojrozměrnou hru, je možné namísto knihovny Pygame použít další – v tomto případě vhodnější – knihovny určené taktéž pro programovací jazyk Python.
Obrázek 4: Logo knihovny Pygame.
Základní knihovnou je v tomto případě PyOpenGL, ovšem pro mnoho uživatelů je výhodnější použít Pyglet. Mezi základní vlastnosti knihovny Pyglet patří vazba na OpenGL a tedy i nepřímo na grafické akcelerátory. Kromě vazby na OpenGL však v knihovně Pyglet mohou programátoři najít i další zajímavé moduly, například moduly pro práci s hudbou a se zvuky (ALSA, OpenAL, DirectSound), podporu pro různé formáty uložení hudby (zejména OGG/Vorbis), podporu pro načítání a zobrazování animací uložených v DivX, AVI, MPEG, H.263 atd. Na druhou stranu však může použití OpenGL přinášet různé problémy, a to jak kvůli špatným ovladačům, tak i z toho důvodu, že na některých platformách je vykreslován prováděno softwarově a tedy velmi pomalu (příkladem může být například populární Raspberry PI, kde grafický čip podporuje jen OpenGL ES, což mimochodem způsobuje velmi pomalý chod knihovny LÖVE).
Obrázek 5: Logo knihovny Pyglet.
3. Principy, na nichž je knihovna Pygame postavena
Knihovna Pygame je, podobně jako tomu bylo i v již popsané knihovně LÖVE, rozdělena do několika modulů. Většina těchto modulů je vypsána v následující tabulce:
| # | Jméno modulu | Stručný popis |
|---|---|---|
| 1 | pygame.cdrom | ovládání mechaniky CD-ROM a podobných zařízení |
| 2 | pygame.cursors | umožňuje nahrávání kurzorů |
| 3 | pygame.display | jeden z nejdůležitějších modulů, řídí zobrazování |
| 4 | pygame.draw | další důležitý modul, zajišťuje vykreslování |
| 5 | pygame.event | práce s frontou událostí, součást všech aplikací |
| 6 | pygame.font | práce s TrueType fonty, jejich využití při vykreslování |
| 7 | pygame.image | načítání a ukládání obrázků v různých formátech |
| 8 | pygame.joystick | čtení stavů joysticku a podobných zařízení |
| 9 | pygame.key | čtení stavu klávesnice |
| 10 | pygame.mouse | čtení stavu myši a podobných zařízení |
| 11 | pygame.movie | přehrávání videa (MPEG atd.) |
| 12 | pygame.sndarray | manipulace se zvukovými vzorky |
| 13 | pygame.surfarray | manipulace s rastrovými obrázky |
| 14 | pygame.time | funkce související s časem, řízení framerate atd. |
| 15 | pygame.transform | transformace obrázků (rotace, změna měřítka, převracení) |
Z tohoto seznamu mj. plyne, že v reálných aplikacích (hrách, demech) se ve skutečnosti využije jen několik modulů. Konkrétně v dnešních demonstračních příkladech se využijí pouze moduly pygame.display, pygame.event, pygame.time a pygame.draw.
Většina her vytvořených v knihovně Pygame obsahuje nějakou formu programové smyčky, v níž se neustále opakují následující operace:
- Načtení informací ze vstupního zařízení (klávesnice, myši, joysticku).
- Změna stavu hry na základě probíhajícího času a přečtených informací ze vstupních zařízení. Může se například jednat o posun hráče, změnu jeho zbývajících životů, změnu skóre atd.
- Vykreslení celé scény (2D, 3D) na základě aktuálního stavu hry. Vykreslovací rutina se může v případě potřeby změnit na základě toho, v jakém stavu se aplikace nachází (zobrazení hlavního menu, vlastní hra, zobrazení seznamu nejlepších hráčů apod.)
- Prohození předního a zadního bufferu (pokud je implementován double buffering) či vykreslení bitmapy vytvořené mimo framebufffer.
Ve skutečnosti je zpracování nepatrně složitější, protože události (stav klávesnice, joysticku atd.) se asynchronně ukládají do takzvané fronty událostí, ze které se musí zaznamenané události postupně načítat a nějakým způsobem zpracovávat.
Obrázek 6: Programová smyčka, která tvoří jádro prakticky každé hry vytvořené s využitím knihovny Pygame.
4. Kostra aplikace používající knihovnu Pygame
Podívejme se nyní na kostru aplikace, která využívá některé základní možnosti nabízené knihovnou Pygame. V této kostře se volají funkce ze dvou modulů: pygame.display a pygame.event. První z těchto modulů je použit pro otevření nového okna, do něhož se bude provádět vykreslování, a taktéž pro nastavení titulku tohoto okna. Následuje nekonečná programová smyčka, v níž se opakovaně čte celý obsah fronty událostí a reaguje se v ní na událost typu QUIT (konstanta z pygame.locals), která značí, že se má celá aplikace ukončit. Povšimněte si taktéž použití funkce pygame.init() na začátku aplikace a funkce pygame.quit() při jejím ukončování:
- Inicializace aplikace pomocí funkce pygame.init()
- Nastavení grafického režimu či otevření okna s využitím pygame.display.set_mode()
- Nastavení titulku okna s využitím funkce pygame.display.set_caption()
- Načtení všech událostí z fronty událostí přes pygame.event.get()
- Ukončení aplikace po příchodu události QUIT zavoláním funkce pygame.quit() a sys.exit()
Výše uvedenou kostru lze v Pythonu implementovat následujícím způsobem:
#!/usr/bin/python
# vim: set fileencoding=utf-8
# Demonstrační příklady využívající knihovnu Pygame
import pygame, sys
# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *
# Velikost okna aplikace
WIDTH = 320
HEIGHT = 240
# Inicializace knihovny Pygame
pygame.init()
# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])
# Nastavení titulku okna
pygame.display.set_caption('Pygame test #1')
# Hlavní herní smyčka
while True:
# Načtení a zpracování všech událostí z fronty
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
# finito
Obrázek 7: Screenshot prvního demonstračního příkladu (nic se explicitně nevykresluje, takže je okno podle očekávání prázdné - černé).
5. Dva způsoby omezení vytížení procesoru při zpracování událostí
Po spuštění prvního demonstračního příkladu popsaného v předchozí kapitole jste si možná všimli, že vytížení procesoru (či jednoho procesorového jádra) je poměrně vysoké; většinou se dokonce přibližuje ke 100%. Je tomu tak z toho důvodu, že v nekonečné smyčce příkladu se neustále načítají události z fronty událostí s využitím funkce pygame.event.get(). Problém je, že tato funkce je takzvaně „neblokující“, což znamená, že v případě, že ve frontě událostí není zaznamenána žádná událost, vrátí pygame.event.get() prázdnou sekvenci a programová smyčka se tak bude neustále opakovat a zbytečně zatěžovat mikroprocesor.
Jednou z možností, jak snížit zatížení procesoru, je použití funkce pygame.time.wait(), která přeruší běh aplikace na zadaný počet milisekund. Tato funkce sice není příliš přesná (navíc se nijak neměří, jak dlouho například trvalo překreslení celé scény), nicméně pro některé účely může být její použití dostačující. Podívejme se na příklad použití této funkce:
#!/usr/bin/python
# vim: set fileencoding=utf-8
# Demonstrační příklady využívající knihovnu Pygame
import pygame, sys
# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *
# Velikost okna aplikace
WIDTH = 320
HEIGHT = 240
# Inicializace knihovny Pygame
pygame.init()
# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])
# Nastavení titulku okna
pygame.display.set_caption('Pygame test #2')
# Hlavní herní smyčka
while True:
# Načtení a zpracování všech událostí z fronty
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
# Počkáme přibližně 50ms
pygame.time.wait(50)
# finito
Obrázek 8: Screenshot druhého demonstračního příkladu.
Alternativně je možné namísto poměrně nepřesné funkce pygame.time.wait() použít přístup naznačený ve třetím demonstračním příkladu. Zde se nejprve vytvoří objekt typu pygame.time.Clock a následně se v hlavní herní smyčce volá metoda pygame.time.Clock.tick(), které se předá předpokládaný počet snímků, které mají být (v pravidelném intervalu) vykresleny na obrazovku. Objekt pygame.time.Clock si pamatuje čas posledního zavolání funkce tick(), takže dokáže upravit čas čekání (pozastavení aplikace) na takovou dobu, aby se zadaný počet snímků za sekundu skutečně zobrazil (samozřejmě s výjimkou případů, kdy je počítač natolik pomalý, že nedokáže smyčku opakovat tolikrát, kolikrát je vyžadováno):
#!/usr/bin/python
# vim: set fileencoding=utf-8
# Demonstrační příklady využívající knihovnu Pygame
import pygame, sys
# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *
# Velikost okna aplikace
WIDTH = 320
HEIGHT = 240
# Inicializace knihovny Pygame
pygame.init()
clock = pygame.time.Clock()
# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])
# Nastavení titulku okna
pygame.display.set_caption('Pygame test #3')
# Hlavní herní smyčka
while True:
# Načtení a zpracování všech událostí z fronty
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
clock.tick(20)
# finito
Obrázek 9: Screenshot třetího demonstračního příkladu.
6. Double buffering a funkce pygame.display.flip() a pygame.display.update()
Aby při vykreslování herní scény nedocházelo k nepříjemnému poblikávání, využívá knihovna Pygame takzvaný double buffering (pokud je pro zadaný grafický režim podporován) popř. vykreslení scény do takzvaného offscreen bufferu (neviditelného bufferu umístěného buď v operační paměti či v ideálním případě ve video paměti).
Připomeňme si, že názvem double buffering se označuje známý a v počítačové grafice již velmi dlouho využívaný postup, při němž se vykreslování grafického uživatelského rozhraní aplikace popř. prostředí hry neprovádí přímo na obrazovku, ale do pomocné bitmapy označované termínem zadní buffer (back buffer). Obrazovka, resp. přesněji řečeno bitmapa zobrazená na obrazovce a tedy viditelná uživateli, je při použití double bufferingu označována termínem přední buffer (front buffer). Vykreslování je do neviditelného zadního bufferu prováděno z toho důvodu, aby uživatel neviděl nepříjemné poblikávání obrazu při mazání/kreslení pozadí a taktéž při postupném přikreslování všech dalších grafických prvků, které mají být na obrazovce viditelné.
Po dokončení vykreslení všech grafických objektů do zadního bufferu je však nutné tento buffer učinit viditelným. To lze provést dvěma způsoby. V případě, že je zadní buffer uložen v paměti grafické karty, je většinou možné jednoduše prohodit role předního a zadního bufferu, a to velmi jednoduchou operací nevyžadující žádné přenosy dat. Tento způsob se nazývá page flipping a je samozřejmě podporován i v Pygame, ovšem v mnoha případech pouze při použití exkluzivního celoobrazovkového režimu (prohození obsahu obou bufferů se typicky provádí ve chvíli takzvaného vertikálního zatemnění – vertical blank (VBLANK)).
Druhý způsob spočívá v blokovém přenosu obsahu celého zadního bufferu do bufferu předního, a to operací typu BitBlt (BLIT). Opět záleží na možnostech konkrétního grafického subsystému i na způsobu uložení zadního bufferu, zda je tato operace provedena přímo na grafickém akcelerátoru (což je samozřejmě rychlejší řešení) či zda je nutné přenášet obsah zadního bufferu do bufferu předního přes systémovou sběrnici. V případě použití knihovny Pygame není nutné se zabývat tím, jaká konkrétní metoda se použije (to se řeší při inicializaci grafického režimu), ale postačuje v programové smyčce pouze zavolat funkci pygame.display.flip() popř. pygame.display.update(). Použití druhé funkce může být výhodnější v případě, kdy programátor přesně ví, které části herní scény se mají překreslit. Informace o těchto oblastech se pak mohou (ale nemusí) použít pro urychlení vykreslení ze zadního do předního bufferu.
7. Vykreslování základních geometrických tvarů
V dnešním čtvrtém demonstračním příkladu si ukážeme, jak se do zadního bufferu vykreslují vybrané základní geometrické tvary a jak se používají funkce pygame.display.flip() popř. pygame.display.update(). Knihovna Pygame nabízí programátorům funkce pro vykreslování úseček, kružnic, kruhů, elips, obdélníků či mnohoúhelníků. U každého geometrického tvaru je nutné specifikovat jeho umístění na ploše obrazovky (souřadnice začínají v levém horním rohu) a taktéž rozměry a barvu vykreslování. Pro jednoduchost jsou konstanty představující jednotlivé barvy uloženy do několika konstant. Následuje vykreslování přímo do zadního bufferu (reprezentovaného proměnnou display). V příkladu je ukázáno jak použití různých barev, tak i stylů vykreslování:
#!/usr/bin/python
# vim: set fileencoding=utf-8
# Demonstrační příklady využívající knihovnu Pygame
import pygame, sys
# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *
# Velikost okna aplikace
WIDTH = 320
HEIGHT = 240
# Inicializace knihovny Pygame
pygame.init()
clock = pygame.time.Clock()
# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])
# Nastavení titulku okna
pygame.display.set_caption('Pygame test #4')
# Konstanty s n-ticemi představujícími základní barvy
BLACK = ( 0, 0, 0)
BLUE = ( 0, 0, 255)
CYAN = ( 0, 255, 255)
GREEN = ( 0, 255, 0)
YELLOW = (255, 255, 0)
RED = (255, 0, 0)
MAGENTA = (255, 0, 255)
WHITE = (255, 255, 255)
# Vyplnění plochy okna černou barvou
display.fill(BLACK)
# Vykreslení čar různou barvou
# cíl barva první vrchol druhý vrchol
pygame.draw.line(display, BLUE, (10, 10), (160, 10))
pygame.draw.line(display, CYAN, (10, 20), (160, 20))
pygame.draw.line(display, GREEN, (10, 30), (160, 30))
pygame.draw.line(display, YELLOW, (10, 40), (160, 40))
pygame.draw.line(display, RED, (10, 50), (160, 50))
pygame.draw.line(display, MAGENTA, (10, 60), (160, 60))
# Vykreslení čar různou šířkou
for i in xrange(1,10):
pygame.draw.line(display, WHITE, (10 + i*15, 80), (10 + i*15, 210), i)
# Základní geometrické tvary: kruh, vyplněný čtverec, elipsa a čtverec
# cíl barva střed poloměr
pygame.draw.circle (display, CYAN, (280, 40), 20, 0)
# cíl barva vrchol rozměry
pygame.draw.rect (display, RED, (280-20, 80, 40, 40))
# cíl barva střed poloměry poloos
pygame.draw.ellipse(display, YELLOW, (280-30, 140, 60, 40))
# cíl barva vrchol rozměry
pygame.draw.rect (display, MAGENTA, (280-20, 190, 40, 40), 1)
# Hlavní herní smyčka
while True:
# Načtení a zpracování všech událostí z fronty
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
pygame.display.update()
clock.tick(20)
# finito
Obrázek 10: Screenshot čtvrtého demonstračního příkladu.
8. Změna barev vybraných pixelů
V dnešním posledním demonstračním příkladu si ukážeme, jakým způsobem je možné měnit barvy jednotlivých pixelů zadního bufferu. Je nutné poznamenat, že se jedná o poměrně zdlouhavou operaci, takže v mnoha hrách se setkáme spíše s použitím spritů a nikoli se snahou o změnu jednotlivých pixelů. Nicméně v některých případech může být tato funkce užitečná. Při přístupu k pixelům se používá funkce/konstruktor pygame.PixelArray() vracející pole pixelů pro zadanou plochu (surface). V našem případě budeme přistupovat přímo k zadnímu bufferu (což je taktéž surface). Poté je již možné měnit hodnotu jednotlivých pixelů uložených v poli (o pole se jedná z pohledu uživatele, interně může být situace složitější). Na závěr je nutné objekt s polem explicitně odstranit pomocí del, protože jinak by zůstal zadní buffer uzamčen pro všechny další operace (ostatně zcela stejným způsobem pracuje i knihovna SDL apod.):
#!/usr/bin/python
# vim: set fileencoding=utf-8
# Demonstrační příklady využívající knihovnu Pygame
import pygame, sys
# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *
# Velikost okna aplikace
WIDTH = 256
HEIGHT = 256
# Inicializace knihovny Pygame
pygame.init()
clock = pygame.time.Clock()
# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])
# Nastavení titulku okna
pygame.display.set_caption('Pygame test #5')
# Konstanty s n-ticemi představujícími základní barvy
BLACK = ( 0, 0, 0)
BLUE = ( 0, 0, 255)
CYAN = ( 0, 255, 255)
GREEN = ( 0, 255, 0)
YELLOW = (255, 255, 0)
RED = (255, 0, 0)
MAGENTA = (255, 0, 255)
WHITE = (255, 255, 255)
# Vyplnění plochy okna černou barvou
display.fill(BLACK)
# Získání dvourozměrného pole s hodnotami pixelů
pixelArray = pygame.PixelArray(display)
# Změna barev některých pixelů
for y in xrange(HEIGHT):
for x in xrange(WIDTH):
pixelArray[x][y] = (x, y, (x+y) % 256)
# Pixely byly změněny, pole je možné odstranit z paměti
# a současně tak uvolnit surface pro další operace
del pixelArray
# Hlavní herní smyčka
while True:
# Načtení a zpracování všech událostí z fronty
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
pygame.display.update()
clock.tick(20)
# finito
Obrázek 11: Screenshot pátého demonstračního příkladu.
9. Repositář se zdrojovými kódy dnešních demonstračních příkladů
Všech pět demonstračních příkladů, s nimiž jsme se v dnešním článku seznámili, bylo uloženo do Git repositáře umístěného na GitHubu (https://github.com/tisnik/presentations):
| # | Příklad | Zdrojový kód |
|---|---|---|
| 1 | pygame1.py | https://github.com/tisnik/presentations/blob/master/pygame/pygame1.py |
| 2 | pygame2.py | https://github.com/tisnik/presentations/blob/master/pygame/pygame2.py |
| 3 | pygame3.py | https://github.com/tisnik/presentations/blob/master/pygame/pygame3.py |
| 4 | pygame4.py | https://github.com/tisnik/presentations/blob/master/pygame/pygame4.py |
| 5 | pygame5.py | https://github.com/tisnik/presentations/blob/master/pygame/pygame5.py |
10. Funkce použité v dnešních demonstračních příkladech
- pygame.init()
http://www.pygame.org/docs/ref/pygame.html#pygame.init - pygame.quit()
http://www.pygame.org/docs/ref/pygame.html#pygame.quit - pygame.display.set_mode()
http://www.pygame.org/docs/ref/display.html#pygame.display.set_mode - pygame.display.set_caption()
http://www.pygame.org/docs/ref/display.html#pygame.display.set_caption - pygame.display.update()
http://www.pygame.org/docs/ref/display.html#pygame.display.update - pygame.PixelArray()
http://www.pygame.org/docs/ref/pixelarray.html - pygame.event.get()
http://www.pygame.org/docs/ref/event.html#pygame.event.get - pygame.time.wait()
http://www.pygame.org/docs/ref/time.html#pygame.time.wait - pygame.time.Clock.tick()
http://www.pygame.org/docs/ref/time.html#pygame.time.Clock.tick - pygame.draw.line()
http://www.pygame.org/docs/ref/draw.html#pygame.draw.line - pygame.draw.circle()
http://www.pygame.org/docs/ref/draw.html#pygame.draw.circle - pygame.draw.rect()
http://www.pygame.org/docs/ref/draw.html#pygame.draw.rect - pygame.draw.ellipse()
http://www.pygame.org/docs/ref/draw.html#pygame.draw.ellipse
11. Odkazy na Internetu
- Pygame.org
http://pygame.org/hifi.html - Pygame - instalační soubory pro různé operační systémy
http://pygame.org/download.shtml - Pygame: documentation
http://www.pygame.org/docs/ - Pygame Wiki: Getting Started
http://www.pygame.org/wiki/GettingStarted - Pygame Tutorials: Tutorials Basic
http://pygametutorials.wikidot.com/tutorials-basic - Python.org (dokumentace k jazyku, odkazy na instalační soubory atd.)
https://www.python.org/ - How to Draw with Pygame on Your Raspberry Pi
http://www.dummies.com/how-to/content/how-to-draw-with-pygame-on-your-raspberry-pi.html - Pyglet
https://pypi.python.org/pypi/pyglet/1.2.4 - Pyglet documentation
http://pythonhosted.org/pyglet/ - PyOpenGL
https://pypi.python.org/pypi/PyOpenGL/ - Domovská stránka systému LÖVE
http://love2d.org/ - Dokumentace k systému LÖVE
http://love2d.org/wiki/love - Domovská stránka programovacího jazyka Lua
http://www.lua.org/ - Seriál o programovacím jazyku Lua (root.cz):
http://www.root.cz/serialy/programovaci-jazyk-lua/ - Domovská stránka systému LÖVE
http://love2d.org/ - Domovská stránka programovacího jazyka Lua
http://www.lua.org/ - Web o Lieru, Gusanos, GeneRally, Atari atd.
http://karelik.wz.cz/ - Web o Lieru, Gusanos
http://karelik.wz.cz/gusanos.php - GUSANOS
http://gusanos.sourceforge.net/ - GUSANOS Download
http://sourceforge.net/projects/gusanos/ - Lua
http://www.linuxexpres.cz/praxe/lua - Lua
http://cs.wikipedia.org/wiki/Lua - Lua (programming language)
http://en.wikipedia.org/wiki/Lua_(programming_language) - The Lua Programming Language
http://www.tiobe.com/index.php/paperinfo/tpci/Lua.html - Lua Programming Gems
http://www.lua.org/gems/ - LuaForge
http://luaforge.net/ - Forge project tree
http://luaforge.net/softwaremap/trove_list.php - SdlBasic home page
http://www.sdlbasic.altervista.org/main/ - SdlBasic examples
http://nitrofurano.linuxkafe.com/sdlbasic/ - SdlBasic na Wikipedii
http://en.wikipedia.org/wiki/SdlBasic - Simple DirectMedia Layer
http://en.wikipedia.org/wiki/Simple_DirectMedia_Layer - SDLBASIC – The high-level interpreter for all?
http://openbytes.wordpress.com/2008/11/08/sdlbasic-the-high-level-interpreter-for-all/ - FreeBasic home page
http://www.freebasic.net/ - FreeBASIC (Wikipedia EN)
https://en.wikipedia.org/wiki/FreeBASIC - FreeBASIC Wiki
http://www.freebasic.net/wiki/wikka.php?wakka=FBWiki - FreeBASIC Manual
http://www.freebasic.net/wiki/wikka.php?wakka=DocToc - FreeBASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/FreeBASIC - The Griffon Legend
http://syn9.thingie.net/?table=griffonlegend - Seriál Letní škola programovacího jazyka Logo
http://www.root.cz/serialy/letni-skola-programovaciho-jazyka-logo/ - Scratch: oficiální stránka projektu
http://scratch.mit.edu/ - Scratch: galerie projektů vytvořených ve Scratchi
http://scratch.mit.edu/galleries/browse/newest - Scratch: nápověda
file:///usr/share/scratch/Help/en/index.html - Scratch: obrazovky nápovědy
file:///usr/share/scratch/Help/en/allscreens.html - Scratch (Wikipedie CZ)
http://cs.wikipedia.org/wiki/Scratch - Scratch (programming language)
http://en.wikipedia.org/wiki/Scratch_(programming_language) - Scratch Modification
http://wiki.scratch.mit.edu/wiki/Scratch_Modification - Scratch Lowers Resistance to Programming
http://www.wired.com/gadgetlab/2009/03/scratch-lowers/ - Snap!
http://snap.berkeley.edu/ - Prostředí Snap!
http://snap.berkeley.edu/snapsource/snap.html - Alternatives to Scratch
http://wiki.scratch.mit.edu/wiki/Alternatives_to_Scratch - Basic-256 home page
http://www.basic256.org/index_en - Basic-256 Language Documentation
http://doc.basic256.org/doku.php - Basic-256 Art Gallery
http://www.basic256.org/artgallery - Basic-256 Tutorial
http://www.basic256.org/tutorials - Why BASIC?
http://www.basic256.org/whybasic - A book to teach ANYBODY how to program a computer (using BASIC)
http://www.basicbook.org/ - BASIC Computer Games (published 1978) - Hammurabi
http://atariarchives.org/basicgames/showpage.php?page=78 - Hamurabi - zdrojový kód v BASICu
http://www.dunnington.u-net.com/public/basicgames/HMRABI
10. 12. 2015 at 10:03
Stránka https://inventwithpython.com/ Ala Sweigarta obsahuje jeho volně šířitelné knihy včetně dělání her v Pythonu.
10. 12. 2015 at 10:49
Mě to hází SSL handshake failed, zajímavé, asi problém v Midori a jeho podroře SSL,
10. 12. 2015 at 10:50
Aha tak http je v pohodě, kdyby někomu nešel předchozí link, tak fallback jede: http://inventwithpython.com/
A ty knížky vypadají dost dobře, díky!
10. 12. 2015 at 21:00
Díky za odkaz, ty knížky skutečně vypadají dobře. Škoda, že je nikdo (zatím) nepřeložil, pro výuku třeba do kroužků by se to hodilo.