Už umíš vykreslit „fotku“ hada. Hadí videohra ale nebude jen statický obrázek. Had se bude hýbat!
Tak, ale teď už k samotné hře!
Tvůj program teď, doufám, vypadá nějak takhle:
from pathlib import Path
import pyglet
TILE_SIZE = 64
TILES_DIRECTORY = Path('snake-tiles')
snake = [(1, 2), (2, 2), (3, 2), (3, 3), (3, 4), (3, 5), (4, 5)]
food = [(2, 0), (5, 1), (1, 4)]
red_image = pyglet.image.load('apple.png')
snake_tiles = {}
for path in TILES_DIRECTORY.glob('*.png'):
snake_tiles[path.stem] = pyglet.image.load(path)
window = pyglet.window.Window()
@window.event
def on_draw():
window.clear()
pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
pyglet.gl.glBlendFunc(pyglet.gl.GL_SRC_ALPHA, pyglet.gl.GL_ONE_MINUS_SRC_ALPHA)
for x, y in snake:
source = 'tail' # (Tady případně je nějaké
dest = 'head' # složitější vybírání políčka)
snake_tiles[source + '-' + dest].blit(
x * TILE_SIZE, y * TILE_SIZE, width=TILE_SIZE, height=TILE_SIZE)
for x, y in food:
red_image.blit(
x * TILE_SIZE, y * TILE_SIZE, width=TILE_SIZE, height=TILE_SIZE)
pyglet.app.run()
Zkus těsně nad řádek pyglet.app.run doplnit funkci,
která se bude volat každou šestinu vteřiny,
a přidá hadovi políčko navíc:
def move(dt):
x, y = snake[-1]
new_head = x+1, y
snake.append(new_head)
pyglet.clock.schedule_interval(move, 1/6)Funguje?
Tak do téhle funkce ještě přidej del snake[0], aby had nerostl donekonečna.
Víš co tenhle příkaz dělá? Jestli ne, koukni znovu na poznámky k seznamům!
A had se hýbe… Jen ho ještě nejde ovládat.
Než uděláme interaktivního hada, zkusíme trošku uklidit. Program se nám rozrůstá, a za chvíli bude složité se v něm vyznat. Můžeme tomu trochu pomoct tím, že ho rozdělíme do dvou souborů: jeden pro logiku hry a druhý na vykreslování (a později ovládání) přes Pyglet.
Udělej si nový soubor pojmenovaný had.py.
V něm budeme mít třídu, která spravuje (a obsahuje) celý stav hry.
Všechno, co je potřeba o hře vědět – v našem případně zatím souřadnice hada a jídla – bude tato třída obsahovat jako atributy.
Třída bude obsahovat dvě metody – funkce, které se dají zavolat na objekty
této třídy.
Speciální metoda __init__ (která se automaticky volá při vytvoření objektu
této třídy) bude tyto atributy nastavovat.
Metoda move, kterou budeme volat při každém „tahu“ hry, je pak bude
měnit.
Pro funkčnost, kterou zatím náš had umí, bude had.py vypadat takto:
class State:
def __init__(self):
self.food = [(2, 0), (5, 1), (1, 4)]
self.snake = [(0, 0), (1, 0)] # (kratší než v kódu na vykreslování)
def move(self):
old_x, old_y = self.snake[-1]
new_x = old_x + 1
new_y = old_y
new_head = new_x, new_y
self.snake.append(new_head)
del self.snake[0]
Pužij prosím pro třídu jméno State a i atributy pojmenuj podle
materiálů – snake, food, a později i další, které budeme přidávat.
Bude se ti to hodit.
Všimni si, že metody berou argument self.
To označuje konkrétní objekt, stav hry se kterým metoda pracuje nebo
který mění.
Ke všem atributúm přistupují pomocí tečky –
self.jméno_atributu.
Tak, máme třídu se stavem.
No jo, ale jak ji teď použít?
Je v jiném souboru než naše hra (ui.py).
Pythonní soubory (ty s příponou .py) jsou zároveň moduly, které se dají
importovat.
Na začátku ui.py tak můžeš napsat:
from had import State
… a třída se stavem bude k dispozici!
Pak potřebuješ ještě několik změn:
Nastavování seznamů snake a food zruš; místo nich nastav jedinou
proměnnou state na nový stav:
state = State()
Místo snake a food ve funkci on_draw použij state.snake
a state.food – atributy našeho stavu.
Všimni si že tady nepoužíváme self – tohle jméno je pro metody v rámci
třídy. Jinde musíme pojmenovat konkrétní objekt, se kterým pracujeme.
Funkci move přepiš tak, aby jen volala metodu state.move:
def move(dt):
state.move()
Všimni si že ani tady nepoužíváme self.
Ten se doplní automaticky – jde o objekt, jehož metodu voláme.
Povedlo se? Funguje to jako předtím? Pro kontrolu můžeš svůj program porovnat s mým (ale nejde o jediné správné řešení):
Nyní k onomu slíbenému ovládání. Respektive nejdřív k změnám směru.
Had ze hry se plazí stále stejným směrem, dokud hráč nezmáckne klávesu. Had z naší ukázky se plazí doprava; dokážeš zařídit, aby se místo toho plazil nahoru?
A co dolů?
Aby si had „pamatoval“ kam se zrovna plazí, je potřeba mít směr součástí stavu
hry.
Uložme ho tedy do atrubutu jménem snake_direction.
Co tam ale přesně uložit? Jak reprezentovat směr v Pythonu – pomocít čísel, n-tic a tak?
Asi nejpříhodnější řešení je uložit si o kolik políček se had posune, a to zvlášť v x-ovém a zvlášť v y-ovém směru. Čili jako dvojici:
(1, 0) = doprava (o jedno políčko v kladném x-ovém směru)(-1, 0) = doleva (o jedno políčko v záporném x-ovém směru)(0, 1) = nahoru (+y)(0, -1) = dolů (-y)Nový atribut přidej do metody __init__ ve stavu:
self.snake_direction = 0, 1
A v metodě move změň nastavování new_x a new_y podle nového atributu:
dir_x, dir_y = self.snake_direction
new_x = old_x + dir_x
new_y = old_y + dir_y
Směr hada teď můžeš měnit změnou snake_direction v __init__.
Funguje to? (Jestli ne, oprav to – a jestli to nejde, zavolej někoho na pomoc!)
Nyní zbývá jen atribut snake_direction měnit, když uživatel něco stiskne na
klávesnici.
To už je doména Pygletu.
Opusť na chvíli abstraktní stav v had.py a koukni na hru v ui.py.
Sem je potřeba přidat funkci, která reaguje na stisk klávesy.
Aby Pyglet tuhle funkci našel a uměl zavolat, musí se jmenovat on_key_press,
musí mít dekorátor @window.event, a musí brát dva argumenty:
číslo klávesy, která byla zmáčknutá, a informace o modifikátorech
(Shift, Ctrl, a tak podobně):
@window.event
def on_key_press(symbol, mod):
...
Druhý argument nepoužijeme.
Podle prvního ale nastav aktuální směr hada.
Čísla kláves jsou definována v modulu pyglet.window.key jako konstanty se
jmény LEFT, ENTER, Q či AMPERSAND .
My použijeme šipky:
@window.event
def on_key_press(symbol, mod):
if symbol == pyglet.window.key.LEFT:
state.snake_direction = -1, 0
if symbol == pyglet.window.key.RIGHT:
state.snake_direction = 1, 0
if symbol == pyglet.window.key.DOWN:
state.snake_direction = 0, -1
if symbol == pyglet.window.key.UP:
state.snake_direction = 0, 1
Tuhle funkci je potřeba dát někam za nastavení window (aby byl k dispozici
window.event) a před pyglet.app.run() (protože nastavovat ovládání až
potom, co hra proběhne, je zbytečné).
Nejlepší je ji dát vedle jiné funkce s dekorátorem @window.event,
aby byly pěkně pohromadě.
Funguje to? Můžeš ovládat směr hada? To je skvělé! Určitě ale při zkoušení narazíš na pár věcí, které je potřeba dodělat:
Pojďme je vyřešit, jednu po druhé.
„Hadí“ hry jako ta naše mají dvě varianty: buď je kolem hřiště „zeď“ a hráč při nárazu do okraje prohraje, nebo je hřiště „nekonečné“ – had okrajem proleze a objeví se na druhé straně.
My nakonec naprogramujeme druhou variantu, která je zajímavější. Začneme ale s tou první, která je jednodušší.
Vrať se k souboru se stavem – had.py.
Budeme pracovat na chování, na logice hry; ne na vykreslování a ovládání.
Abys zjistil/a, jestli had „vylezl“ z levého okraje okna ven,
je potřeba zkontrolovat, jestli x-ová souřadnice hlavy
je menší než 0.
To je dobré udělat hned poté, co nové souřadnice hlavy získáš – konkrétně
hned před řádkem new_head = new_x, new_y v metodě move.
A co při takovém nárazu udělat?
Nejjednodušší bude hru ukončit.
Na to má Python funkci exit(), která funguje podobně jako když v programu
nastane chyba.
Jen místo chybového výpisu ukáže daný text.
Ukončení programu není příliš příjemný způsob, jak říct hráčovi že prohrál. Za chvíli ale tuhle část předěláme, tak prozatím tenhle jednoduchý způsob postačí.
def move(self):
old_x, old_y = self.snake[-1]
dir_x, dir_y = self.snake_direction
new_x = old_x + dir_x
new_y = old_y + dir_y
# Nový kód – kontrola vylezení z hrací plochy
if new_x < 0:
exit('GAME OVER')
new_head = new_x, new_y
self.snake.append(new_head)
del self.snake[0]
Věřím, že zvládneš udělat stejnou kontrolu pro vylezení ze spodního okraje.
Jak ale ošetřit ty zbylé okraje – pravý a horní? Na to je potřeba znát velikost okýnka. A tu zná Pyglet; třída se stavem k okýnku nemá přístup!
Na velikosti herní plochy závisí chování hry.
Tahle informace tedy bude tedy muset být součást stavu.
Pro začátek nějakou velikost – třeba 10×10 – nastav v __init__:
self.width = 10
self.height = 10
A pak zařiď, aby po nárazu na neviditelnou stěnu kolem hřiště velkého 10×10 políček hra skončila. Vyzkoušej všechny varianty – severní, jižní, východní i západní zeď. (Had je virtuální, nemusíš se bát že mu z toho vyroste boule.)
A pak nastav opravdovou velikost herní plochy. Jak?
V souboru se hrou (ui.py), hned po tom co vytvoříš stav (state)
a okýnko (window) velikost nastav.
Použij celočíselné dělení (se zbytkem), aby velikost byla v celých číslech:
state.width = window.width // TILE_SIZE
state.height = window.height // TILE_SIZE
Teď místo konce hry při naražení necháme hada „projít“ a objevit se na druhé straně.
Nemělo by to být tak složité udělat – stačí místo exit() vždy správně
nastavit příslušnou hodnotu.
Je ale potřeba si dát pozor kde použít new_x a kde new_y, kde width a kde
height, a kde přičíst nebo odečíst jedničku, aby při číslování od nuly
všechno sedělo.
Zkus to!
Jestli už vykresluješ hada místo housenky, možná teď narazíš na problém s vybíráním správných dílků – okraj herní plochy hada vizuálně rozdělí na dva menší. Zatím to ignoruj, ale ve volné chvilce se pokus problém opravit. Doporučuji se vrátit k „abstraktní“ funkci, která jen vypisuje souřadnice a směry:
1 2 tail right
2 2 left right
3 2 left top
3 3 bottom top
3 4 bottom top
3 5 bottom right
4 5 left headJdeš-li podle návodu, tuhle funkci máš uloženou v souboru smery.py
Oprav nejdřív tu, a řešení „transplantuj“ do hry.
Jde to jednodušeji? Jde! Matematikové vymysleli operaci, která se jmenuje zbytek po dělení. Ta dělá přesně to, co potřebujeme – zbytek po dělení nové souřadnice velikostí hřiště dá souřadnici, která leží v hřišti. Když byla předchozí souřadnice o jedna větší než maximum, zbytek po dělení bude nula; když byla -1, dostaneme maximum.
Celý kód pro kontrolu a ošetření vylézání z hrací plochy tak jde nahradit tímhle:
new_x = new_x % self.width
new_y = new_y % self.height
Podobné matematické „zkratky“ umí programátorům často usnadnit život – ale přijít na ně nebývá jednoduché. Ale nevěš hlavu: neláká-li tě studovat informatiku na škole, věz, že to jde i bez „zkratek“. Jen občas trochu krkoloměji.
Ale jestli tě matematika baví, je tu poznámka pro tebe!
To, že existuje přesně operace kterou potřebujeme, není až tak úplně náhoda. Ona matematická jednoduchost je spíš důvod, proč se hrací plocha u spousty starých her chová právě takhle. Odborně se tomu „takhle“ říká toroidální topologie.
Zkušení matematici si teď možná stěžují na nutnost definovat zbytek po
dělení záporných čísel. Proto dodám, že ho Python schválně
definuje
vhodně pro tento účel; a % b má vždy stejné znaménko jako b.
Tak. Had je v pasti, už nemůže vylézt. Co dál?
Teď se musíme o hada postarat: pravidelně ho krmit. Ale ještě předtím je potřeba ho naučit, jak se vůbec jí – na naši potravu ještě není zvyklý. Když to zvládneme, poroste jako z vody!
Konkrétně musíme hlavně zajistit, aby když se had připlazí na políčko
s jídlem, tak jídlo zmizelo.
K tomu se dá použít operátor in, který zjišťuje jestli něco (třeba
souřadnice) je v nějakém seznamu (třeba seznamu souřadnic jídla),
a metoda remove, která ze seznamu odstraní daný prvek (podle hodnoty prvku,
na rozdíl od del, který maže podle pozice).
Nebudu napínat, kód je následující. Rozumíš mu? Víš, kam je ho potřeba dát?
if new_head in self.food:
self.food.remove(new_head)
Vyzkoušej, jestli to funguje. Had by měl jíst jídlo.
Ještě ale zbývá zařídit, aby po každém soustu trochu povyrostl. Ale jak? Kterým směrem má růst?
Tady je dobré se podívat na existující kód a uvědomit si, co dělá.
Náš had se plazí tak, že napřed vepředu povyroste (pomocí append)
a potom se vzadu zmenší (pomocí del self.snake[0]).
Aby tedy po snězení jídla vyrostl, stačí přeskočit ono zmenšování!
Ono přeskočit znamená podmínit, pomocí if.
Logika jezení a zmenšování hada tedy bude:
Neboli přeloženo do Pythonu:
if new_head in self.food:
self.food.remove(new_head)
else:
del self.snake[0]
Pro ty, co se začínají ztrácet, dám k dispozici celou metodu move.
Běda ale těm, kdo opisují kód bez toho aby mu rozuměli!
Když už had umí jíst, je potřeba mu zajistit pravidelný přísun jídla. Nejlépe tak, že se každé snězené jídlo nahradí novým.
Přidej do třídy State následující novou metodu, která umí přidat jídlo:
def add_food(self):
x = 0
y = 0
position = x, y
self.food.append(position)
Pak tuhle metodu zavolej – najdi v programu kód, který se provádí když je potřeba přidat nové jídlo, a přidej tam následující řádek:
self.add_food()
Tahle metoda přidává jídlo na pozici (0, 0), tedy stále do stejného rohu.
Bylo by ale fajn, kdyby se nové jídlo objevilo vždycky jinde,
na náhodném místě.
Na to můžeme použít funkci random.randrange, která vrací náhodná celá čísla.
Vyzkoušej si ji (z jiného souboru, třeba `experiment.py):
import random
print('Na kostce padlo:', random.randrange(6))
Čím se liší random.randrange od klasické hrací kostky?
Uměl/a bys program upravit tak, aby padalo 1 až 6?
Je tahle změna užitečná pro naši hru? Jaký rozsah čísel potřebujeme pro hadí jídlo?
Až na to přijdeš, zkus přidat náhodu do programu: jídlo by se mělo objevit
na úplně náhjodném políčku na herní ploše.
Nezapomeň na import random – to patří na úplný začátek souboru.
Další změny už dělej v metodě add_food.
Až to budeš testovat, asi zjistíš, že úplně náhodné políčko není ideální. Občas se totiž jídlo objeví na políčku s hadem, nebo dokonce na jiném jídle. Je proto dobré tuhle situaci zkontrolovat, a když volba padne na plné políčko, jídlo nepřidávat:
if (position not in self.snake) and (position not in self.food):
self.food.append(position)
Když ale zkusíš tohle, zjistíš, že občas se nové jídlo vůbec nepřidá. To taky není vhodná varianta – had by tak měl hlad. Co s tím?
Překvapivě dobré (i když ne úplně ideální) řešení je zkusit políčko vybrat několikrát. Když padne prázdné políčko, šup tam s jídlem; když padne plné, tak to prostě zkusit znovu.
Je ale potřeba počet pokusů omezit, aby v situaci, kdy je pole úplně plné, počítač nevybíral donekonečna. Řekněme že když se na 100 pokusů nepodaří prázdné políčko vybrat, vzdáme to.
Metoda add_food po všech úpravách bude vypadat takhle:
def add_food(self):
for try_number in range(100):
x = random.randrange(self.width)
y = random.randrange(self.height)
position = x, y
if (position not in self.snake) and (position not in self.food):
self.food.append(position)
# Ukončení funkce ("vyskočí" i z cyklu for)
return
Jestli ti to funguje, ještě zařiď, aby na začátku hry bylo jídlo na náhodných pozicích.
Had teď může narůst do obrovských rozměrů – a hru stále nelze prohrát. Zařídíme tedy, aby hra skončila, když had narazí sám do sebe.
Na rozdíl od 0/1, které jsme použili výše, buďme trochu opatrnější.
Není dobré ukončit celý program; to by se hráčům moc nelíbilo.
Ostatně, zkus si, jak to působí – následující kód dej na správné místo
a zkus, jak se hra hraje, když skončí hned po nárazu:
# Kontrola, jestli had narazil
if new_head in self.snake:
exit('GAME OVER')
Lepší je hru „zapauzovat“ – ukázat hráči situaci, do které nešťastného hada dostal, aby se z ní mohl pro příště poučit.
Aby to bylo možné, dáme do stavu hry další atribut: snake_alive.
Ten bude nastavený na True, dokud bude had žít.
Když had narazí, nastaví se na False, a od té doby se už nebude pohybovat.
Je dobré i graficky ukázat, že hadovi není dobře – hráč pak spíš bude
zpytovat svědomí.
Zkus zapřemýšlet, kam v kódu (a i do kterých souborů) patří následující kousky kódu, které prohru implementují:
# Prvotní nastavení atributu
self.snake_alive = True
# Kontrola, jestli had narazil
if new_head in self.snake:
self.snake_alive = False
# Zabránění pohybu
if not self.snake_alive:
return
# Grafická indikace
if dest == 'head' and not state.snake_alive:
dest = 'dead'
Poslední úprava kódu!
Možná si všimneš – zvlášť jestli jsi už nějakou verzi hada hrál/a, že ovládání tvé nové hry je trošku frustrující. A možná není úplně jednoduché přijít na to, proč.
Můžou za to (hlavně) dva důvody.
První problém: když zmáčkneš dvě šipky rychle za sebou, v dalším „tahu“ hada se projeví jen ta druhá. Z pohledu programu je to chování (snad) jasné – po stisknutí šipky se uloží její směr, a při „tahu“ hada se použije poslední uložený směr. S tímhle chováním je ale složité hada rychle otáčet: hráč se musí „trefovat“ do tahů hada. Lepší by bylo, kdyby se ukládaly všechny stisknuté klávesy, a had by v každém tahu reagoval maximálně jednu – další by si „schoval“ na další tahy.
Takovou „frontu“ stisků kláves lze uchovávat v seznamu.
Přidej si na to do stavu hry seznam (v metodě __init__):
self.queued_directions = []
Tuhle frontu plň v ui.py po každém stisku klávesy, metodou append.
Je potřeba změnit většinu funkce on_key_press:
@window.event
def on_key_press(symbol, mod):
if symbol == pyglet.window.key.LEFT:
new_direction = -1, 0
if symbol == pyglet.window.key.RIGHT:
new_direction = 1, 0
if symbol == pyglet.window.key.DOWN:
new_direction = 0, -1
if symbol == pyglet.window.key.UP:
new_direction = 0, 1
state.queued_directions.append(new_direction)
A zpátky k logice, v had.py v metodě move místo
dir_x, dir_y = self.snake_direction z fronty vyber první nepoužitý prvek
(a nezapomeň ho z fronty smazat, ať se dostane i na další!):
if self.queued_directions:
new_direction = self.queued_directions[0]
del self.queued_directions[0]
self.snake_direction = new_direction
Zkontroluj, že to funguje.
Druhý problém: když se had plazí doleva a hráč zmáčkne šipku doprava, had se otočí a hlavou si narazí do krku. Z pohledu programu to dává smysl: políčko napravo od hlavy je plné, hra tedy končí. Z pohledu hry (a biologie už vůbec!) ale narážení do krku moc smyslu nedává. Lepší by bylo obrácení směru úplně ignorovat.
A jak poznat opačný směr? Když se had plazí doprava – (1, 0) – tak je opačný směr doleva – (-1, 0). Když se plazí dolů – (0, -1) – tak naopak je nahoru – (0, 1). Obecně, k (x, y) je opačný směr (-x, -y).
Zatím ale pracujeme s celými n-ticemi, je potřeba obě na x a y „rozbalit“. Kód tedy bude vypadat takto:
old_x, old_y = self.snake_direction
new_x, new_y = new_direction
if (old_x, old_y) != (-new_x, -new_y):
self.snake_direction = new_direction
Gratuluji, máš funkční a hratelnou hru! Doufám že jsi na sebe hrdý/á!
Dej si něco sladkého, zasloužíš si to.
Tady je moje řešení. To se touhle dobou od toho tvého může dost lišit – to je úplně normální. (A nedívej se sem dokud hada nenaprogramuješ sám/sama, Chybami (a neustálým zkoušením) se člověk učí – a programátor zvlášť. Čtením už vyřešeného se učí hůř.)
Najdeš ještě nějaké další vylepšení, které by se dalo udělat?
Zkus třeba následující rozšíření:
Každých 30 vteřin hry přibude samo od sebe nové jídlo, takže jich pak bude na hrací ploše víc.
Hra se bude postupně zrychlovat.
(Na to je nejlepší předělat funkci move v ui.py, aby sama
naplánovala, kdy se má příště zavolat. Volání schedule_interval tak už
nebude potřeba.)
Hadi budou dva; druhý se ovládá klávesami
W A S D.
(Na to je nejlepší udělat novou třídu, Snake, a všechen stav hada
přesunout ze State do ní. Ve State pak měj seznam hadů.
Téhle změně je potřeba přizpůsobit celý zytek programu.)
{
"data": {
"sessionMaterial": {
"id": "session-material:2018/snake-hradec:workshop:7",
"title": "Had – Logika hry",
"html": "\n \n \n\n <h1>Logika hry</h1>\n<p>Už umíš vykreslit „fotku“ hada.\nHadí videohra ale nebude jen statický obrázek.\nHad se bude hýbat!</p>\n<!--\n# Ukládání revizí\n\nXXX - Nestíhám dopsat, omlouvám se\n-->\n\n<h1>Rozhýbejme hada</h1>\n<p>Tak, ale teď už k samotné hře!</p>\n<p>Tvůj program teď, doufám, vypadá nějak takhle:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">from</span> <span class=\"nn\">pathlib</span> <span class=\"kn\">import</span> <span class=\"n\">Path</span>\n\n<span class=\"kn\">import</span> <span class=\"nn\">pyglet</span>\n\n<span class=\"n\">TILE_SIZE</span> <span class=\"o\">=</span> <span class=\"mi\">64</span>\n<span class=\"n\">TILES_DIRECTORY</span> <span class=\"o\">=</span> <span class=\"n\">Path</span><span class=\"p\">(</span><span class=\"s1\">'snake-tiles'</span><span class=\"p\">)</span>\n\n<span class=\"n\">snake</span> <span class=\"o\">=</span> <span class=\"p\">[(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">)]</span>\n<span class=\"n\">food</span> <span class=\"o\">=</span> <span class=\"p\">[(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">)]</span>\n\n<span class=\"n\">red_image</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">image</span><span class=\"o\">.</span><span class=\"n\">load</span><span class=\"p\">(</span><span class=\"s1\">'apple.png'</span><span class=\"p\">)</span>\n<span class=\"n\">snake_tiles</span> <span class=\"o\">=</span> <span class=\"p\">{}</span>\n<span class=\"k\">for</span> <span class=\"n\">path</span> <span class=\"ow\">in</span> <span class=\"n\">TILES_DIRECTORY</span><span class=\"o\">.</span><span class=\"n\">glob</span><span class=\"p\">(</span><span class=\"s1\">'*.png'</span><span class=\"p\">):</span>\n <span class=\"n\">snake_tiles</span><span class=\"p\">[</span><span class=\"n\">path</span><span class=\"o\">.</span><span class=\"n\">stem</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">image</span><span class=\"o\">.</span><span class=\"n\">load</span><span class=\"p\">(</span><span class=\"n\">path</span><span class=\"p\">)</span>\n\n<span class=\"n\">window</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">Window</span><span class=\"p\">()</span>\n\n<span class=\"nd\">@window.event</span>\n<span class=\"k\">def</span> <span class=\"nf\">on_draw</span><span class=\"p\">():</span>\n <span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">clear</span><span class=\"p\">()</span>\n <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">glEnable</span><span class=\"p\">(</span><span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_BLEND</span><span class=\"p\">)</span>\n <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">glBlendFunc</span><span class=\"p\">(</span><span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_SRC_ALPHA</span><span class=\"p\">,</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_ONE_MINUS_SRC_ALPHA</span><span class=\"p\">)</span>\n <span class=\"k\">for</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"ow\">in</span> <span class=\"n\">snake</span><span class=\"p\">:</span>\n <span class=\"n\">source</span> <span class=\"o\">=</span> <span class=\"s1\">'tail'</span> <span class=\"c1\"># (Tady případně je nějaké</span>\n <span class=\"n\">dest</span> <span class=\"o\">=</span> <span class=\"s1\">'head'</span> <span class=\"c1\"># složitější vybírání políčka)</span>\n <span class=\"n\">snake_tiles</span><span class=\"p\">[</span><span class=\"n\">source</span> <span class=\"o\">+</span> <span class=\"s1\">'-'</span> <span class=\"o\">+</span> <span class=\"n\">dest</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">blit</span><span class=\"p\">(</span>\n <span class=\"n\">x</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">width</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">height</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">)</span>\n <span class=\"k\">for</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"ow\">in</span> <span class=\"n\">food</span><span class=\"p\">:</span>\n <span class=\"n\">red_image</span><span class=\"o\">.</span><span class=\"n\">blit</span><span class=\"p\">(</span>\n <span class=\"n\">x</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">width</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">height</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">)</span>\n\n<span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">app</span><span class=\"o\">.</span><span class=\"n\">run</span><span class=\"p\">()</span>\n</pre></div><p>Zkus těsně nad řádek <code>pyglet.app.run</code> doplnit funkci,\nkterá se bude volat každou šestinu vteřiny,\na přidá hadovi políčko navíc:</p>\n<div class=\"highlight\"><pre><code>def move(dt):\n x, y = snake[-1]\n new_head = x+1, y\n snake.append(new_head)\n\npyglet.clock.schedule_interval(move, 1/6)</code></pre></div><p>Funguje?\nTak do téhle funkce ještě přidej <code>del snake[0]</code>, aby had nerostl donekonečna.\nVíš co tenhle příkaz dělá? Jestli ne, koukni znovu na poznámky k seznamům!</p>\n<p>A had se hýbe… Jen ho ještě nejde ovládat.</p>\n<h2>Ven se stavem</h2>\n<p>Než uděláme interaktivního hada, zkusíme trošku uklidit.\nProgram se nám rozrůstá, a za chvíli bude složité se v něm vyznat.\nMůžeme tomu trochu pomoct tím, že ho rozdělíme do dvou souborů:\njeden pro <em>logiku hry</em> a druhý na <em>vykreslování</em> (a později ovládání)\npřes Pyglet.</p>\n<p>Udělej si nový soubor pojmenovaný <code>had.py</code>.\nV něm budeme mít <em>třídu</em>, která spravuje (a obsahuje) celý stav hry.</p>\n<p>Všechno, co je potřeba o hře vědět – v našem případně zatím souřadnice hada\na jídla – bude tato třída obsahovat jako <em>atributy</em>.</p>\n<p>Třída bude obsahovat dvě <em>metody</em> – funkce, které se dají zavolat na objekty\ntéto třídy.\nSpeciální metoda <code>__init__</code> (která se automaticky volá při vytvoření objektu\ntéto třídy) bude tyto atributy nastavovat.\nMetoda <code>move</code>, kterou budeme volat při každém „tahu“ hry, je pak bude\nměnit.</p>\n<p>Pro funkčnost, kterou zatím náš had umí, bude <code>had.py</code> vypadat takto:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">State</span><span class=\"p\">:</span>\n <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span> <span class=\"o\">=</span> <span class=\"p\">[(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">)]</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span> <span class=\"o\">=</span> <span class=\"p\">[(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)]</span> <span class=\"c1\"># (kratší než v kódu na vykreslování)</span>\n\n <span class=\"k\">def</span> <span class=\"nf\">move</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">old_x</span> <span class=\"o\">+</span> <span class=\"mi\">1</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">old_y</span>\n <span class=\"n\">new_head</span> <span class=\"o\">=</span> <span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"n\">new_y</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n <span class=\"k\">del</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div><div class=\"admonition note\"><p>Pužij prosím pro třídu jméno <code>State</code> a i atributy pojmenuj podle\nmateriálů – <code>snake</code>, <code>food</code>, a později i další, které budeme přidávat.\nBude se ti to hodit.</p>\n</div><p>Všimni si, že metody berou argument <code>self</code>.\nTo označuje konkrétní objekt, stav hry se kterým metoda pracuje nebo\nkterý mění.\nKe všem atributúm přistupují pomocí tečky –\n<code>self.<var>jméno_atributu</var></code>.</p>\n<p>Tak, máme třídu se stavem.\nNo jo, ale jak ji teď použít?\nJe v jiném souboru než naše hra (<code>ui.py</code>).</p>\n<p>Pythonní soubory (ty s příponou <code>.py</code>) jsou zároveň <em>moduly</em>, které se dají\nimportovat.\nNa začátku <code>ui.py</code> tak můžeš napsat:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">from</span> <span class=\"nn\">had</span> <span class=\"kn\">import</span> <span class=\"n\">State</span>\n</pre></div><p>… a třída se stavem bude k dispozici!</p>\n<p>Pak potřebuješ ještě několik změn:</p>\n<ul>\n<li><p>Nastavování seznamů <code>snake</code> a <code>food</code> zruš; místo nich nastav jedinou\nproměnnou <code>state</code> na nový stav:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">state</span> <span class=\"o\">=</span> <span class=\"n\">State</span><span class=\"p\">()</span>\n</pre></div></li>\n<li><p>Místo <code>snake</code> a <code>food</code> ve funkci <code>on_draw</code> použij <code>state.snake</code>\na <code>state.food</code> – atributy našeho stavu.</p>\n<p>Všimni si že tady nepoužíváme <code>self</code> – tohle jméno je pro <em>metody</em> v rámci\ntřídy. Jinde musíme pojmenovat konkrétní objekt, se kterým pracujeme.</p>\n</li>\n<li><p>Funkci <code>move</code> přepiš tak, aby jen volala metodu <code>state.move</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">move</span><span class=\"p\">(</span><span class=\"n\">dt</span><span class=\"p\">):</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">move</span><span class=\"p\">()</span>\n</pre></div><p>Všimni si že ani tady nepoužíváme <code>self</code>.\nTen se doplní automaticky – jde o objekt, jehož metodu voláme.</p>\n</li>\n</ul>\n<p>Povedlo se? Funguje to jako předtím?\nPro kontrolu můžeš svůj program porovnat s mým (ale nejde o jediné správné\nřešení):</p>\n<div class=\"solution\" id=\"solution-0\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/0/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <div class=\"highlight\"><pre><span></span><span class=\"kn\">from</span> <span class=\"nn\">pathlib</span> <span class=\"kn\">import</span> <span class=\"n\">Path</span>\n\n<span class=\"kn\">import</span> <span class=\"nn\">pyglet</span>\n\n<span class=\"kn\">from</span> <span class=\"nn\">had</span> <span class=\"kn\">import</span> <span class=\"n\">State</span>\n\n<span class=\"n\">TILE_SIZE</span> <span class=\"o\">=</span> <span class=\"mi\">64</span>\n<span class=\"n\">TILES_DIRECTORY</span> <span class=\"o\">=</span> <span class=\"n\">Path</span><span class=\"p\">(</span><span class=\"s1\">'snake-tiles'</span><span class=\"p\">)</span>\n\n<span class=\"n\">red_image</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">image</span><span class=\"o\">.</span><span class=\"n\">load</span><span class=\"p\">(</span><span class=\"s1\">'apple.png'</span><span class=\"p\">)</span>\n<span class=\"n\">snake_tiles</span> <span class=\"o\">=</span> <span class=\"p\">{}</span>\n<span class=\"k\">for</span> <span class=\"n\">path</span> <span class=\"ow\">in</span> <span class=\"n\">TILES_DIRECTORY</span><span class=\"o\">.</span><span class=\"n\">glob</span><span class=\"p\">(</span><span class=\"s1\">'*.png'</span><span class=\"p\">):</span>\n <span class=\"n\">snake_tiles</span><span class=\"p\">[</span><span class=\"n\">path</span><span class=\"o\">.</span><span class=\"n\">stem</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">image</span><span class=\"o\">.</span><span class=\"n\">load</span><span class=\"p\">(</span><span class=\"n\">path</span><span class=\"p\">)</span>\n\n<span class=\"n\">window</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">Window</span><span class=\"p\">()</span>\n\n<span class=\"n\">state</span> <span class=\"o\">=</span> <span class=\"n\">State</span><span class=\"p\">()</span>\n\n<span class=\"nd\">@window.event</span>\n<span class=\"k\">def</span> <span class=\"nf\">on_draw</span><span class=\"p\">():</span>\n <span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">clear</span><span class=\"p\">()</span>\n <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">glEnable</span><span class=\"p\">(</span><span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_BLEND</span><span class=\"p\">)</span>\n <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">glBlendFunc</span><span class=\"p\">(</span><span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_SRC_ALPHA</span><span class=\"p\">,</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_ONE_MINUS_SRC_ALPHA</span><span class=\"p\">)</span>\n <span class=\"k\">for</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"ow\">in</span> <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">:</span>\n <span class=\"n\">source</span> <span class=\"o\">=</span> <span class=\"s1\">'tail'</span> <span class=\"c1\"># (Tady případně je nějaké</span>\n <span class=\"n\">dest</span> <span class=\"o\">=</span> <span class=\"s1\">'head'</span> <span class=\"c1\"># složitější vybírání políčka)</span>\n <span class=\"n\">snake_tiles</span><span class=\"p\">[</span><span class=\"n\">source</span> <span class=\"o\">+</span> <span class=\"s1\">'-'</span> <span class=\"o\">+</span> <span class=\"n\">dest</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">blit</span><span class=\"p\">(</span>\n <span class=\"n\">x</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">width</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">height</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">)</span>\n <span class=\"k\">for</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"ow\">in</span> <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">:</span>\n <span class=\"n\">red_image</span><span class=\"o\">.</span><span class=\"n\">blit</span><span class=\"p\">(</span>\n <span class=\"n\">x</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">width</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">height</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">)</span>\n\n<span class=\"k\">def</span> <span class=\"nf\">move</span><span class=\"p\">(</span><span class=\"n\">dt</span><span class=\"p\">):</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">move</span><span class=\"p\">()</span>\n\n<span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">clock</span><span class=\"o\">.</span><span class=\"n\">schedule_interval</span><span class=\"p\">(</span><span class=\"n\">move</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"o\">/</span><span class=\"mi\">6</span><span class=\"p\">)</span>\n\n<span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">app</span><span class=\"o\">.</span><span class=\"n\">run</span><span class=\"p\">()</span>\n</pre></div>\n </div>\n</div><h2>Ovládání</h2>\n<p>Nyní k onomu slíbenému ovládání. Respektive nejdřív k změnám směru.</p>\n<p>Had ze hry se plazí stále stejným směrem, dokud hráč nezmáckne klávesu.\nHad z naší ukázky se plazí doprava; dokážeš zařídit, aby se místo toho\nplazil nahoru?</p>\n<div class=\"solution\" id=\"solution-1\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/1/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <p>Ve funkci <code>move</code> je potřeba jinak nastavit proměnné <code>new_x</code> a <code>new_y</code>:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">old_x</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">old_y</span> <span class=\"o\">+</span> <span class=\"mi\">1</span>\n</pre></div>\n </div>\n</div><p>A co dolů?</p>\n<div class=\"solution\" id=\"solution-2\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/2/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <div class=\"highlight\"><pre><span></span> <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">old_x</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">old_y</span> <span class=\"o\">-</span> <span class=\"mi\">1</span>\n</pre></div>\n </div>\n</div><p>Aby si had „pamatoval“ kam se zrovna plazí, je potřeba mít směr součástí stavu\nhry.\nUložme ho tedy do atrubutu jménem <code>snake_direction</code>.</p>\n<p>Co tam ale přesně uložit?\nJak reprezentovat směr v Pythonu – pomocít čísel, <var>n</var>-tic a tak?</p>\n<p>Asi nejpříhodnější řešení je uložit si o kolik políček se had posune,\na to zvlášť v <var>x</var>-ovém a zvlášť v <var>y</var>-ovém směru.\nČili jako dvojici:</p>\n<ul>\n<li><code>(1, 0)</code> = doprava (o jedno políčko v kladném <var>x</var>-ovém směru)</li>\n<li><code>(-1, 0)</code> = doleva (o jedno políčko v záporném <var>x</var>-ovém směru)</li>\n<li><code>(0, 1)</code> = nahoru (+<var>y</var>)</li>\n<li><code>(0, -1)</code> = dolů (-<var>y</var>)</li>\n</ul>\n<p>Nový atribut přidej do metody <code>__init__</code> ve stavu:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span>\n</pre></div><p>A v metodě <code>move</code> změň nastavování <code>new_x</code> a <code>new_y</code> podle nového atributu:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"n\">dir_x</span><span class=\"p\">,</span> <span class=\"n\">dir_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">old_x</span> <span class=\"o\">+</span> <span class=\"n\">dir_x</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">old_y</span> <span class=\"o\">+</span> <span class=\"n\">dir_y</span>\n</pre></div><p>Směr hada teď můžeš měnit změnou <code>snake_direction</code> v <code>__init__</code>.\nFunguje to? (Jestli ne, oprav to – a jestli to nejde, zavolej někoho na pomoc!)</p>\n<p>Nyní zbývá jen atribut <code>snake_direction</code> měnit, když uživatel něco stiskne na\nklávesnici.\nTo už je doména Pygletu.\nOpusť na chvíli abstraktní stav v <code>had.py</code> a koukni na hru v <code>ui.py</code>.\nSem je potřeba přidat funkci, která reaguje na stisk klávesy.</p>\n<p>Aby Pyglet tuhle funkci našel a uměl zavolat, musí se jmenovat <code>on_key_press</code>,\nmusí mít dekorátor <code>@window.event</code>, a musí brát dva argumenty:\nčíslo klávesy, která byla zmáčknutá, a informace o modifikátorech\n(Shift, Ctrl, a tak podobně):</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nd\">@window.event</span>\n<span class=\"k\">def</span> <span class=\"nf\">on_key_press</span><span class=\"p\">(</span><span class=\"n\">symbol</span><span class=\"p\">,</span> <span class=\"n\">mod</span><span class=\"p\">):</span>\n <span class=\"o\">...</span>\n</pre></div><p>Druhý argument nepoužijeme.\nPodle prvního ale nastav aktuální směr hada.\nČísla kláves jsou definována v modulu <code>pyglet.window.key</code> jako konstanty se\njmény <code>LEFT</code>, <code>ENTER</code>, <code>Q</code> či <code>AMPERSAND</code> .\nMy použijeme šipky:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nd\">@window.event</span>\n<span class=\"k\">def</span> <span class=\"nf\">on_key_press</span><span class=\"p\">(</span><span class=\"n\">symbol</span><span class=\"p\">,</span> <span class=\"n\">mod</span><span class=\"p\">):</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">LEFT</span><span class=\"p\">:</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">RIGHT</span><span class=\"p\">:</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">DOWN</span><span class=\"p\">:</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">1</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">UP</span><span class=\"p\">:</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span>\n</pre></div><p>Tuhle funkci je potřeba dát někam za nastavení <code>window</code> (aby byl k dispozici\n<code>window.event</code>) a před <code>pyglet.app.run()</code> (protože nastavovat ovládání až\npotom, co hra proběhne, je zbytečné).\nNejlepší je ji dát vedle jiné funkce s dekorátorem <code>@window.event</code>,\naby byly pěkně pohromadě.</p>\n<p>Funguje to?\nMůžeš ovládat směr hada?\nTo je skvělé!\nUrčitě ale při zkoušení narazíš na pár věcí, které je potřeba dodělat:</p>\n<ul>\n<li>Had by neměl mít možnost vylézt ven z okýnka.</li>\n<li>Had by měl jíst jídlo a růst.</li>\n<li>Hra by měla skončit, když had narazí sám do sebe.</li>\n</ul>\n<p>Pojďme je vyřešit, jednu po druhé.</p>\n<h2>Zatím dobrý, teď ale narazíme</h2>\n<p>„Hadí“ hry jako ta naše mají dvě varianty: buď je kolem hřiště „zeď“\na hráč při nárazu do okraje prohraje, nebo je hřiště „nekonečné“ – had okrajem\nproleze a objeví se na druhé straně.</p>\n<p>My nakonec naprogramujeme druhou variantu, která je zajímavější.\nZačneme ale s tou první, která je jednodušší.</p>\n<p>Vrať se k souboru se stavem – <code>had.py</code>.\nBudeme pracovat na chování, na logice hry; ne na vykreslování a ovládání.</p>\n<p>Abys zjistil/a, jestli had „vylezl“ z levého okraje okna ven,\nje potřeba zkontrolovat, jestli <var>x</var>-ová souřadnice hlavy\nje menší než 0.\nTo je dobré udělat hned poté, co nové souřadnice hlavy získáš – konkrétně\nhned před řádkem <code>new_head = new_x, new_y</code> v metodě <code>move</code>.</p>\n<p>A co při takovém nárazu udělat?\nNejjednodušší bude hru ukončit.\nNa to má Python funkci <code>exit()</code>, která funguje podobně jako když v programu\nnastane chyba.\nJen místo chybového výpisu ukáže daný text.</p>\n<p>Ukončení programu není příliš příjemný způsob, jak říct hráčovi že prohrál.\nZa chvíli ale tuhle část předěláme, tak prozatím tenhle jednoduchý způsob postačí.</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"k\">def</span> <span class=\"nf\">move</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"n\">dir_x</span><span class=\"p\">,</span> <span class=\"n\">dir_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">old_x</span> <span class=\"o\">+</span> <span class=\"n\">dir_x</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">old_y</span> <span class=\"o\">+</span> <span class=\"n\">dir_y</span>\n\n <span class=\"c1\"># Nový kód – kontrola vylezení z hrací plochy</span>\n <span class=\"k\">if</span> <span class=\"n\">new_x</span> <span class=\"o\"><</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n <span class=\"nb\">exit</span><span class=\"p\">(</span><span class=\"s1\">'GAME OVER'</span><span class=\"p\">)</span>\n\n <span class=\"n\">new_head</span> <span class=\"o\">=</span> <span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"n\">new_y</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n <span class=\"k\">del</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div><p>Věřím, že zvládneš udělat stejnou kontrolu pro vylezení ze spodního okraje.</p>\n<p>Jak ale ošetřit ty zbylé okraje – pravý a horní?\nNa to je potřeba znát velikost okýnka.\nA tu zná Pyglet; třída se stavem k okýnku nemá přístup!</p>\n<p>Na velikosti herní plochy závisí chování hry.\nTahle informace tedy bude tedy muset být součást stavu.\nPro začátek nějakou velikost – třeba 10×10 – nastav v <code>__init__</code>:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"mi\">10</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"mi\">10</span>\n</pre></div><p>A pak zařiď, aby po nárazu na neviditelnou stěnu kolem hřiště velkého\n10×10 políček hra skončila.\nVyzkoušej všechny varianty – severní, jižní, východní i západní zeď.\n(Had je virtuální, nemusíš se bát že mu z toho vyroste boule.)</p>\n<div class=\"solution\" id=\"solution-3\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/3/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <div class=\"highlight\"><pre><span></span> <span class=\"k\">def</span> <span class=\"nf\">move</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"n\">dir_x</span><span class=\"p\">,</span> <span class=\"n\">dir_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">old_x</span> <span class=\"o\">+</span> <span class=\"n\">dir_x</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">old_y</span> <span class=\"o\">+</span> <span class=\"n\">dir_y</span>\n\n <span class=\"c1\"># Kontrola vylezení z hrací plochy</span>\n <span class=\"k\">if</span> <span class=\"n\">new_x</span> <span class=\"o\"><</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n <span class=\"nb\">exit</span><span class=\"p\">(</span><span class=\"s1\">'GAME OVER'</span><span class=\"p\">)</span>\n <span class=\"k\">if</span> <span class=\"n\">new_y</span> <span class=\"o\"><</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n <span class=\"nb\">exit</span><span class=\"p\">(</span><span class=\"s1\">'GAME OVER'</span><span class=\"p\">)</span>\n <span class=\"k\">if</span> <span class=\"n\">new_x</span> <span class=\"o\">>=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span><span class=\"p\">:</span>\n <span class=\"nb\">exit</span><span class=\"p\">(</span><span class=\"s1\">'GAME OVER'</span><span class=\"p\">)</span>\n <span class=\"k\">if</span> <span class=\"n\">new_y</span> <span class=\"o\">>=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span><span class=\"p\">:</span>\n <span class=\"nb\">exit</span><span class=\"p\">(</span><span class=\"s1\">'GAME OVER'</span><span class=\"p\">)</span>\n\n <span class=\"n\">new_head</span> <span class=\"o\">=</span> <span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"n\">new_y</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n <span class=\"k\">del</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div>\n </div>\n</div><p>A pak nastav <em>opravdovou</em> velikost herní plochy. Jak?\nV souboru se hrou (<code>ui.py</code>), hned po tom co vytvoříš stav (<code>state</code>)\na okýnko (<code>window</code>) velikost nastav.\nPoužij celočíselné dělení (se zbytkem), aby velikost byla v celých číslech:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">width</span> <span class=\"o\">//</span> <span class=\"n\">TILE_SIZE</span>\n<span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">height</span> <span class=\"o\">//</span> <span class=\"n\">TILE_SIZE</span>\n</pre></div><h2>Nekonečná magická klec</h2>\n<p>Teď místo konce hry při naražení necháme hada „projít“ a objevit se na druhé\nstraně.</p>\n<p>Nemělo by to být tak složité udělat – stačí místo <code>exit()</code> vždy správně\nnastavit příslušnou hodnotu.\nJe ale potřeba si dát pozor kde použít <code>new_x</code> a kde <code>new_y</code>, kde <code>width</code> a kde\n<code>height</code>, a kde přičíst nebo odečíst jedničku, aby při číslování od nuly\nvšechno sedělo.\nZkus to!</p>\n<div class=\"admonition note\"><p>Jestli už vykresluješ hada místo housenky, možná teď narazíš na problém\ns vybíráním správných dílků – okraj herní plochy hada vizuálně rozdělí\nna dva menší.\nZatím to ignoruj, ale ve volné chvilce se pokus problém opravit.\nDoporučuji se vrátit k „abstraktní“ funkci, která jen vypisuje souřadnice\na směry:</p>\n<div class=\"highlight\"><pre><code>1 2 tail right\n2 2 left right\n3 2 left top\n3 3 bottom top\n3 4 bottom top\n3 5 bottom right\n4 5 left head</code></pre></div><p>Jdeš-li podle návodu, tuhle funkci máš uloženou v souboru <code>smery.py</code>\nOprav nejdřív tu, a řešení „transplantuj“ do hry.</p>\n</div><div class=\"solution\" id=\"solution-4\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/4/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <div class=\"highlight\"><pre><span></span> <span class=\"c1\"># Kontrola vylezení z hrací plochy</span>\n <span class=\"k\">if</span> <span class=\"n\">new_x</span> <span class=\"o\"><</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span> <span class=\"o\">-</span> <span class=\"mi\">1</span>\n <span class=\"k\">if</span> <span class=\"n\">new_y</span> <span class=\"o\"><</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span> <span class=\"o\">-</span> <span class=\"mi\">1</span>\n <span class=\"k\">if</span> <span class=\"n\">new_x</span> <span class=\"o\">>=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span><span class=\"p\">:</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n <span class=\"k\">if</span> <span class=\"n\">new_y</span> <span class=\"o\">>=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span><span class=\"p\">:</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n</pre></div>\n </div>\n</div><p>Jde to jednodušeji? Jde!\nMatematikové vymysleli operaci, která se jmenuje <em>zbytek po dělení</em>.\nTa dělá přesně to, co potřebujeme – zbytek po dělení nové souřadnice velikostí\nhřiště dá souřadnici, která leží v hřišti.\nKdyž byla předchozí souřadnice o jedna větší než maximum,\nzbytek po dělení bude nula; když byla -1, dostaneme maximum.</p>\n<p>Celý kód pro kontrolu a ošetření vylézání z hrací plochy tak jde\nnahradit tímhle:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">new_x</span> <span class=\"o\">%</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">new_y</span> <span class=\"o\">%</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span>\n</pre></div><p>Podobné matematické „zkratky“ umí programátorům často usnadnit život – ale\npřijít na ně nebývá jednoduché.\nAle nevěš hlavu: neláká-li tě studovat informatiku na škole, věz, že to jde\ni bez „zkratek“. Jen občas trochu krkoloměji.</p>\n<div class=\"admonition note\"><p>Ale jestli tě matematika baví, je tu poznámka pro tebe!</p>\n<p>To, že existuje přesně operace kterou potřebujeme, není až tak úplně náhoda.\nOna matematická jednoduchost je spíš <em>důvod</em>, proč se hrací plocha\nu spousty starých her chová právě takhle.\nOdborně se tomu „takhle“ říká\n<a href=\"https://en.wikipedia.org/wiki/Torus#Topology\">toroidální topologie</a>.</p>\n<p>Zkušení matematici si teď možná stěžují na nutnost definovat zbytek po\ndělení záporných čísel. Proto dodám, že ho Python schválně\n<a href=\"https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations\">definuje</a>\n<em>vhodně</em> pro tento účel; <code>a % b</code> má vždy stejné znaménko jako <code>b</code>.</p>\n</div><h2>Krmení</h2>\n<p>Tak. Had je v pasti, už nemůže vylézt.\nCo dál?</p>\n<p>Teď se musíme o hada postarat: pravidelně ho krmit.\nAle ještě předtím je potřeba ho naučit, jak se vůbec jí – na naši potravu\nještě není zvyklý.\nKdyž to zvládneme, poroste jako z vody!</p>\n<p>Konkrétně musíme hlavně zajistit, aby když se had připlazí na políčko\ns jídlem, tak jídlo zmizelo.\nK tomu se dá použít operátor <code>in</code>, který zjišťuje jestli něco (třeba\nsouřadnice) je v nějakém seznamu (třeba seznamu souřadnic jídla),\na metoda <code>remove</code>, která ze seznamu odstraní daný prvek (podle hodnoty prvku,\nna rozdíl od <code>del</code>, který maže podle pozice).</p>\n<p>Nebudu napínat, kód je následující.\nRozumíš mu?\nVíš, kam je ho potřeba dát?</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"k\">if</span> <span class=\"n\">new_head</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">:</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">remove</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n</pre></div><div class=\"solution\" id=\"solution-5\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/5/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <p>Do metody <code>move</code>, kamkoli za řádek který nastavuje <code>new_head</code>.</p>\n </div>\n</div><p>Vyzkoušej, jestli to funguje. Had by měl jíst jídlo.</p>\n<p>Ještě ale zbývá zařídit, aby po každém soustu trochu povyrostl.\nAle jak? Kterým směrem má růst?</p>\n<p>Tady je dobré se podívat na existující kód a uvědomit si, co dělá.</p>\n<p>Náš had se plazí tak, že napřed vepředu povyroste (pomocí <code>append</code>)\na potom se vzadu zmenší (pomocí <code>del self.snake[0]</code>).</p>\n<p>Aby tedy po snězení jídla vyrostl, stačí <em>přeskočit</em> ono zmenšování!\nOno <em>přeskočit</em> znamená podmínit, pomocí <code>if</code>.\nLogika jezení a zmenšování hada tedy bude:</p>\n<ul>\n<li>Když had sní jídlo, jídlo zmizí. Had se nezmenší.</li>\n<li>Jinak (tedy když had <em>nesní</em> jídlo) se had zmenší (a tudíž neroste).</li>\n</ul>\n<p>Neboli přeloženo do Pythonu:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"k\">if</span> <span class=\"n\">new_head</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">:</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">remove</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n <span class=\"k\">else</span><span class=\"p\">:</span>\n <span class=\"k\">del</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div><p>Pro ty, co se začínají ztrácet, dám k dispozici celou metodu <code>move</code>.\nBěda ale těm, kdo opisují kód bez toho aby mu rozuměli!</p>\n<div class=\"solution\" id=\"solution-6\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/6/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <div class=\"highlight\"><pre><span></span> <span class=\"k\">def</span> <span class=\"nf\">move</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"n\">dir_x</span><span class=\"p\">,</span> <span class=\"n\">dir_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">old_x</span> <span class=\"o\">+</span> <span class=\"n\">dir_x</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">old_y</span> <span class=\"o\">+</span> <span class=\"n\">dir_y</span>\n\n <span class=\"c1\"># Kontrola vylezení z hrací plochy</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">new_x</span> <span class=\"o\">%</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">new_y</span> <span class=\"o\">%</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span>\n\n <span class=\"n\">new_head</span> <span class=\"o\">=</span> <span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"n\">new_y</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n <span class=\"k\">if</span> <span class=\"n\">new_head</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">:</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">remove</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n <span class=\"k\">else</span><span class=\"p\">:</span>\n <span class=\"k\">del</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div>\n </div>\n</div><h3>Nové jídlo</h3>\n<p>Když už had umí jíst, je potřeba mu zajistit pravidelný přísun jídla.\nNejlépe tak, že se každé snězené jídlo nahradí novým.</p>\n<p>Přidej do třídy <code>State</code> následující novou metodu, která umí přidat jídlo:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"k\">def</span> <span class=\"nf\">add_food</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n <span class=\"n\">y</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n <span class=\"n\">position</span> <span class=\"o\">=</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">position</span><span class=\"p\">)</span>\n</pre></div><p>Pak tuhle metodu zavolej – najdi v programu kód, který se provádí když\nje potřeba přidat nové jídlo, a přidej tam následující řádek:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">add_food</span><span class=\"p\">()</span>\n</pre></div><p>Tahle metoda přidává jídlo na pozici (0, 0), tedy stále do stejného rohu.\nBylo by ale fajn, kdyby se nové jídlo objevilo vždycky jinde,\nna náhodném místě.\nNa to můžeme použít funkci <code>random.randrange</code>, která vrací náhodná celá čísla.\nVyzkoušej si ji (z jiného souboru, třeba <code>`experiment.py</code>):</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">random</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Na kostce padlo:'</span><span class=\"p\">,</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"mi\">6</span><span class=\"p\">))</span>\n</pre></div><p>Čím se liší <code>random.randrange</code> od klasické hrací kostky?\nUměl/a bys program upravit tak, aby padalo 1 až 6?</p>\n<p>Je tahle změna užitečná pro naši hru? Jaký rozsah čísel potřebujeme pro hadí jídlo?</p>\n<p>Až na to přijdeš, zkus přidat náhodu do programu: jídlo by se mělo objevit\nna <em>úplně náhjodném</em> políčku na herní ploše.\nNezapomeň na <code>import random</code> – to patří na úplný začátek souboru.\nDalší změny už dělej v metodě <code>add_food</code>.</p>\n<div class=\"solution\" id=\"solution-7\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/7/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <div class=\"highlight\"><pre><span></span> <span class=\"k\">def</span> <span class=\"nf\">add_food</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span><span class=\"p\">)</span>\n <span class=\"n\">y</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span><span class=\"p\">)</span>\n <span class=\"n\">position</span> <span class=\"o\">=</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">position</span><span class=\"p\">)</span>\n</pre></div>\n </div>\n</div><p>Až to budeš testovat, asi zjistíš, že <em>úplně náhodné</em> políčko není ideální.\nObčas se totiž jídlo objeví na políčku s hadem, nebo dokonce na jiném jídle.\nJe proto dobré tuhle situaci zkontrolovat, a když volba padne na plné políčko,\njídlo nepřidávat:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"k\">if</span> <span class=\"p\">(</span><span class=\"n\">position</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">)</span> <span class=\"ow\">and</span> <span class=\"p\">(</span><span class=\"n\">position</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">):</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">position</span><span class=\"p\">)</span>\n</pre></div><p>Když ale zkusíš <em>tohle</em>, zjistíš, že občas se nové jídlo vůbec nepřidá.\nTo taky není vhodná varianta – had by tak měl hlad.\nCo s tím?</p>\n<p>Překvapivě dobré (i když ne <em>úplně</em> ideální) řešení je zkusit políčko vybrat\nněkolikrát.\nKdyž padne prázdné políčko, šup tam s jídlem; když padne plné, tak to\nprostě zkusit znovu.</p>\n<p>Je ale potřeba počet pokusů omezit, aby v situaci, kdy je pole <em>úplně</em> plné,\npočítač nevybíral donekonečna.\nŘekněme že když se na 100 pokusů nepodaří prázdné políčko vybrat,\nvzdáme to.</p>\n<p>Metoda <code>add_food</code> po všech úpravách bude vypadat takhle:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"k\">def</span> <span class=\"nf\">add_food</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"k\">for</span> <span class=\"n\">try_number</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">100</span><span class=\"p\">):</span>\n <span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span><span class=\"p\">)</span>\n <span class=\"n\">y</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span><span class=\"p\">)</span>\n <span class=\"n\">position</span> <span class=\"o\">=</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span>\n <span class=\"k\">if</span> <span class=\"p\">(</span><span class=\"n\">position</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">)</span> <span class=\"ow\">and</span> <span class=\"p\">(</span><span class=\"n\">position</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">):</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">position</span><span class=\"p\">)</span>\n <span class=\"c1\"># Ukončení funkce ("vyskočí" i z cyklu for)</span>\n <span class=\"k\">return</span>\n</pre></div><p>Jestli ti to funguje, ještě zařiď, aby na začátku hry bylo jídlo na náhodných\npozicích.</p>\n<div class=\"solution\" id=\"solution-8\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/8/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <p>V metodě <code>__init__</code> se dá místo nastavení <code>self.food</code> na seznam s pozicemi\njídla napsat:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">add_food</span><span class=\"p\">()</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">add_food</span><span class=\"p\">()</span>\n</pre></div><p>Pak budou na začátku hry na hada čekat dvě náhodné jídla.</p>\n </div>\n</div><h2>Konec</h2>\n<p>Had teď může narůst do obrovských rozměrů – a hru stále nelze prohrát.\nZařídíme tedy, aby hra skončila, když had narazí sám do sebe.</p>\n<p>Na rozdíl od <code>0/1</code>, které jsme použili výše, buďme trochu opatrnější.\nNení dobré ukončit celý program; to by se hráčům moc nelíbilo.\nOstatně, zkus si, jak to působí – následující kód dej na správné místo\na zkus, jak se hra hraje, když skončí hned po nárazu:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"c1\"># Kontrola, jestli had narazil</span>\n <span class=\"k\">if</span> <span class=\"n\">new_head</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">:</span>\n <span class=\"nb\">exit</span><span class=\"p\">(</span><span class=\"s1\">'GAME OVER'</span><span class=\"p\">)</span>\n</pre></div><div class=\"solution\" id=\"solution-9\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/9/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <p>Kód patří do metody <code>move</code>, hned za nastavení proměnné <code>new_head</code>.</p>\n </div>\n</div><p>Lepší je hru „zapauzovat“ – ukázat hráči situaci, do které nešťastného hada\ndostal, aby se z ní mohl pro příště poučit.</p>\n<p>Aby to bylo možné, dáme do stavu hry další atribut: <code>snake_alive</code>.\nTen bude nastavený na <code>True</code>, dokud bude had žít.\nKdyž had narazí, nastaví se na <code>False</code>, a od té doby se už nebude pohybovat.\nJe dobré i graficky ukázat, že hadovi není dobře – hráč pak spíš bude\nzpytovat svědomí.</p>\n<p>Zkus zapřemýšlet, kam v kódu (a i do kterých souborů) patří následující\nkousky kódu, které prohru implementují:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"c1\"># Prvotní nastavení atributu</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_alive</span> <span class=\"o\">=</span> <span class=\"bp\">True</span>\n</pre></div><div class=\"highlight\"><pre><span></span> <span class=\"c1\"># Kontrola, jestli had narazil</span>\n <span class=\"k\">if</span> <span class=\"n\">new_head</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">:</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_alive</span> <span class=\"o\">=</span> <span class=\"bp\">False</span>\n</pre></div><div class=\"highlight\"><pre><span></span> <span class=\"c1\"># Zabránění pohybu</span>\n <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_alive</span><span class=\"p\">:</span>\n <span class=\"k\">return</span>\n</pre></div><div class=\"highlight\"><pre><span></span> <span class=\"c1\"># Grafická indikace</span>\n <span class=\"k\">if</span> <span class=\"n\">dest</span> <span class=\"o\">==</span> <span class=\"s1\">'head'</span> <span class=\"ow\">and</span> <span class=\"ow\">not</span> <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">snake_alive</span><span class=\"p\">:</span>\n <span class=\"n\">dest</span> <span class=\"o\">=</span> <span class=\"s1\">'dead'</span>\n</pre></div><div class=\"solution\" id=\"solution-10\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/10/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <ul>\n<li>„Prvotní nastavení atributu“ do metody <code>__init__</code>.</li>\n<li>„Kontrola, jestli had narazil“ do <code>move</code> místo původní kontroly,\nkdy se hra ukončila pomocí <code>exit()</code>.</li>\n<li>„Zabránění pohybu“ na úplný začátek metody <code>move</code> (příkaz <code>return</code>\nokamžitě ukončí provádění metody).</li>\n<li>„Grafická indikace“ do <code>ui.py</code>, za sekci pro vybírání obrázku pro kousek\nhada.</li>\n</ul>\n </div>\n</div><h2>Vylepšení ovládání</h2>\n<p>Poslední úprava kódu!</p>\n<p>Možná si všimneš – zvlášť jestli jsi už nějakou verzi hada hrál/a,\nže ovládání tvé nové hry je trošku frustrující.\nA možná není úplně jednoduché přijít na to, proč.</p>\n<p>Můžou za to (hlavně) dva důvody.</p>\n<p>První problém: když zmáčkneš dvě šipky rychle za sebou, v dalším „tahu“\nhada se projeví jen ta druhá.\nZ pohledu programu je to chování (snad) jasné – po stisknutí šipky se uloží\njejí směr, a při „tahu“ hada se použije poslední uložený směr.\nS tímhle chováním je ale složité hada rychle otáčet: hráč se musí „trefovat“\ndo tahů hada.\nLepší by bylo, kdyby se ukládaly <em>všechny</em> stisknuté klávesy, a had by\nv každém tahu reagoval maximálně jednu – další by si „schoval“ na další tahy.</p>\n<p>Takovou „frontu“ stisků kláves lze uchovávat v seznamu.\nPřidej si na to do stavu hry seznam (v metodě <code>__init__</code>):</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n</pre></div><p>Tuhle frontu plň v <code>ui.py</code> po každém stisku klávesy, metodou <code>append</code>.\nJe potřeba změnit většinu funkce <code>on_key_press</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nd\">@window.event</span>\n<span class=\"k\">def</span> <span class=\"nf\">on_key_press</span><span class=\"p\">(</span><span class=\"n\">symbol</span><span class=\"p\">,</span> <span class=\"n\">mod</span><span class=\"p\">):</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">LEFT</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">RIGHT</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">DOWN</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">1</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">UP</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">new_direction</span><span class=\"p\">)</span>\n</pre></div><p>A zpátky k logice, v <code>had.py</code> v metodě <code>move</code> místo\n<code>dir_x, dir_y = self.snake_direction</code> z fronty vyber první nepoužitý prvek\n(a nezapomeň ho z fronty smazat, ať se dostane i na další!):</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"k\">del</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"n\">new_direction</span>\n</pre></div><p>Zkontroluj, že to funguje.</p>\n<p>Druhý problém: když se had plazí doleva a hráč zmáčkne šipku doprava,\nhad se otočí a hlavou si narazí do krku.\nZ pohledu programu to dává smysl: políčko napravo od hlavy je plné,\nhra tedy končí.\nZ pohledu hry (a biologie už vůbec!) ale narážení do krku moc smyslu nedává.\nLepší by bylo obrácení směru úplně ignorovat.</p>\n<p>A jak poznat opačný směr?\nKdyž se had plazí doprava – (1, 0) – tak je opačný směr doleva – (-1, 0).\nKdyž se plazí dolů – (0, -1) – tak naopak je nahoru – (0, 1).\nObecně, k (<var>x</var>, <var>y</var>) je opačný směr\n(-<var>x</var>, -<var>y</var>).</p>\n<p>Zatím ale pracujeme s celými <var>n</var>-ticemi, je potřeba obě\nna <var>x</var> a <var>y</var> „rozbalit“.\nKód tedy bude vypadat takto:</p>\n<div class=\"highlight\"><pre><span></span> <span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span>\n <span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">new_direction</span>\n <span class=\"k\">if</span> <span class=\"p\">(</span><span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span><span class=\"p\">)</span> <span class=\"o\">!=</span> <span class=\"p\">(</span><span class=\"o\">-</span><span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"n\">new_y</span><span class=\"p\">):</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"n\">new_direction</span>\n</pre></div><h2>A to je vše?</h2>\n<p>Gratuluji, máš funkční a hratelnou hru!\nDoufám že jsi na sebe hrdý/á!</p>\n<p>Dej si něco sladkého, zasloužíš si to.</p>\n<hr>\n<p>Tady je moje řešení.\nTo se touhle dobou od toho tvého může dost lišit – to je úplně normální.\n(A nedívej se sem dokud hada nenaprogramuješ sám/sama,\nChybami (a neustálým zkoušením) se člověk učí – a programátor zvlášť.\nČtením už vyřešeného se učí hůř.)</p>\n<div class=\"solution\" id=\"solution-11\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/snake-hradec/snake/logic/index/solutions/11/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <p><code>had.py</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">random</span>\n\n<span class=\"k\">class</span> <span class=\"nc\">State</span><span class=\"p\">:</span>\n <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">add_food</span><span class=\"p\">()</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">add_food</span><span class=\"p\">()</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span> <span class=\"o\">=</span> <span class=\"p\">[(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">),</span> <span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)]</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"mi\">10</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"mi\">10</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_alive</span> <span class=\"o\">=</span> <span class=\"bp\">True</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n\n <span class=\"k\">def</span> <span class=\"nf\">move</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"k\">del</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span>\n <span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">new_direction</span>\n <span class=\"k\">if</span> <span class=\"p\">(</span><span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span><span class=\"p\">)</span> <span class=\"o\">!=</span> <span class=\"p\">(</span><span class=\"o\">-</span><span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"n\">new_y</span><span class=\"p\">):</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span> <span class=\"o\">=</span> <span class=\"n\">new_direction</span>\n\n <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_alive</span><span class=\"p\">:</span>\n <span class=\"k\">return</span>\n\n <span class=\"n\">old_x</span><span class=\"p\">,</span> <span class=\"n\">old_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"n\">dir_x</span><span class=\"p\">,</span> <span class=\"n\">dir_y</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_direction</span>\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">old_x</span> <span class=\"o\">+</span> <span class=\"n\">dir_x</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">old_y</span> <span class=\"o\">+</span> <span class=\"n\">dir_y</span>\n\n <span class=\"n\">new_x</span> <span class=\"o\">=</span> <span class=\"n\">new_x</span> <span class=\"o\">%</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span>\n <span class=\"n\">new_y</span> <span class=\"o\">=</span> <span class=\"n\">new_y</span> <span class=\"o\">%</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span>\n\n <span class=\"n\">new_head</span> <span class=\"o\">=</span> <span class=\"n\">new_x</span><span class=\"p\">,</span> <span class=\"n\">new_y</span>\n <span class=\"k\">if</span> <span class=\"n\">new_head</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">:</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake_alive</span> <span class=\"o\">=</span> <span class=\"bp\">False</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n\n <span class=\"k\">if</span> <span class=\"n\">new_head</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">:</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">remove</span><span class=\"p\">(</span><span class=\"n\">new_head</span><span class=\"p\">)</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">add_food</span><span class=\"p\">()</span>\n <span class=\"k\">else</span><span class=\"p\">:</span>\n <span class=\"k\">del</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n\n <span class=\"k\">def</span> <span class=\"nf\">add_food</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n <span class=\"k\">for</span> <span class=\"n\">try_number</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">100</span><span class=\"p\">):</span>\n <span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">width</span><span class=\"p\">)</span>\n <span class=\"n\">y</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">height</span><span class=\"p\">)</span>\n <span class=\"n\">position</span> <span class=\"o\">=</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span>\n <span class=\"k\">if</span> <span class=\"p\">(</span><span class=\"n\">position</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">)</span> <span class=\"ow\">and</span> <span class=\"p\">(</span><span class=\"n\">position</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">):</span>\n <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">position</span><span class=\"p\">)</span>\n <span class=\"k\">return</span>\n</pre></div><p><code>ui.py</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">from</span> <span class=\"nn\">pathlib</span> <span class=\"kn\">import</span> <span class=\"n\">Path</span>\n\n<span class=\"kn\">import</span> <span class=\"nn\">pyglet</span>\n\n<span class=\"kn\">from</span> <span class=\"nn\">had</span> <span class=\"kn\">import</span> <span class=\"n\">State</span>\n\n<span class=\"n\">TILE_SIZE</span> <span class=\"o\">=</span> <span class=\"mi\">64</span>\n<span class=\"n\">TILES_DIRECTORY</span> <span class=\"o\">=</span> <span class=\"n\">Path</span><span class=\"p\">(</span><span class=\"s1\">'snake-tiles'</span><span class=\"p\">)</span>\n\n<span class=\"n\">red_image</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">image</span><span class=\"o\">.</span><span class=\"n\">load</span><span class=\"p\">(</span><span class=\"s1\">'apple.png'</span><span class=\"p\">)</span>\n<span class=\"n\">snake_tiles</span> <span class=\"o\">=</span> <span class=\"p\">{}</span>\n<span class=\"k\">for</span> <span class=\"n\">path</span> <span class=\"ow\">in</span> <span class=\"n\">TILES_DIRECTORY</span><span class=\"o\">.</span><span class=\"n\">glob</span><span class=\"p\">(</span><span class=\"s1\">'*.png'</span><span class=\"p\">):</span>\n <span class=\"n\">snake_tiles</span><span class=\"p\">[</span><span class=\"n\">path</span><span class=\"o\">.</span><span class=\"n\">stem</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">image</span><span class=\"o\">.</span><span class=\"n\">load</span><span class=\"p\">(</span><span class=\"n\">path</span><span class=\"p\">)</span>\n\n<span class=\"n\">window</span> <span class=\"o\">=</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">Window</span><span class=\"p\">()</span>\n\n<span class=\"n\">state</span> <span class=\"o\">=</span> <span class=\"n\">State</span><span class=\"p\">()</span>\n<span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">width</span> <span class=\"o\">//</span> <span class=\"n\">TILE_SIZE</span>\n<span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">height</span> <span class=\"o\">//</span> <span class=\"n\">TILE_SIZE</span>\n\n\n<span class=\"nd\">@window.event</span>\n<span class=\"k\">def</span> <span class=\"nf\">on_draw</span><span class=\"p\">():</span>\n <span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">clear</span><span class=\"p\">()</span>\n <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">glEnable</span><span class=\"p\">(</span><span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_BLEND</span><span class=\"p\">)</span>\n <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">glBlendFunc</span><span class=\"p\">(</span><span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_SRC_ALPHA</span><span class=\"p\">,</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">gl</span><span class=\"o\">.</span><span class=\"n\">GL_ONE_MINUS_SRC_ALPHA</span><span class=\"p\">)</span>\n <span class=\"k\">for</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"ow\">in</span> <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">snake</span><span class=\"p\">:</span>\n <span class=\"n\">source</span> <span class=\"o\">=</span> <span class=\"s1\">'tail'</span> <span class=\"c1\"># (Tady případně je nějaké</span>\n <span class=\"n\">dest</span> <span class=\"o\">=</span> <span class=\"s1\">'head'</span> <span class=\"c1\"># složitější vybírání políčka)</span>\n <span class=\"k\">if</span> <span class=\"n\">dest</span> <span class=\"o\">==</span> <span class=\"s1\">'head'</span> <span class=\"ow\">and</span> <span class=\"ow\">not</span> <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">snake_alive</span><span class=\"p\">:</span>\n <span class=\"n\">dest</span> <span class=\"o\">=</span> <span class=\"s1\">'dead'</span>\n <span class=\"n\">snake_tiles</span><span class=\"p\">[</span><span class=\"n\">source</span> <span class=\"o\">+</span> <span class=\"s1\">'-'</span> <span class=\"o\">+</span> <span class=\"n\">dest</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">blit</span><span class=\"p\">(</span>\n <span class=\"n\">x</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">width</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">height</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">)</span>\n <span class=\"k\">for</span> <span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"ow\">in</span> <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">food</span><span class=\"p\">:</span>\n <span class=\"n\">red_image</span><span class=\"o\">.</span><span class=\"n\">blit</span><span class=\"p\">(</span>\n <span class=\"n\">x</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">y</span> <span class=\"o\">*</span> <span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">width</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">,</span> <span class=\"n\">height</span><span class=\"o\">=</span><span class=\"n\">TILE_SIZE</span><span class=\"p\">)</span>\n\n\n<span class=\"nd\">@window.event</span>\n<span class=\"k\">def</span> <span class=\"nf\">on_key_press</span><span class=\"p\">(</span><span class=\"n\">symbol</span><span class=\"p\">,</span> <span class=\"n\">mod</span><span class=\"p\">):</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">LEFT</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">RIGHT</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">DOWN</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">1</span>\n <span class=\"k\">if</span> <span class=\"n\">symbol</span> <span class=\"o\">==</span> <span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">window</span><span class=\"o\">.</span><span class=\"n\">key</span><span class=\"o\">.</span><span class=\"n\">UP</span><span class=\"p\">:</span>\n <span class=\"n\">new_direction</span> <span class=\"o\">=</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">queued_directions</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">new_direction</span><span class=\"p\">)</span>\n\n\n<span class=\"k\">def</span> <span class=\"nf\">move</span><span class=\"p\">(</span><span class=\"n\">dt</span><span class=\"p\">):</span>\n <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">move</span><span class=\"p\">()</span>\n\n\n<span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">clock</span><span class=\"o\">.</span><span class=\"n\">schedule_interval</span><span class=\"p\">(</span><span class=\"n\">move</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"o\">/</span><span class=\"mi\">6</span><span class=\"p\">)</span>\n\n<span class=\"n\">pyglet</span><span class=\"o\">.</span><span class=\"n\">app</span><span class=\"o\">.</span><span class=\"n\">run</span><span class=\"p\">()</span>\n</pre></div>\n </div>\n</div><p>Najdeš ještě nějaké další vylepšení, které by se dalo udělat?</p>\n<p>Zkus třeba následující rozšíření:</p>\n<ul>\n<li><p>Každých 30 vteřin hry přibude samo od sebe nové jídlo,\ntakže jich pak bude na hrací ploše víc.</p>\n</li>\n<li><p>Hra se bude postupně zrychlovat.<br>\n<em>(Na to je nejlepší předělat funkci <code>move</code> v <code>ui.py</code>, aby </em>sama<em>\nnaplánovala, kdy se má příště zavolat. Volání <code>schedule_interval</code> tak už\nnebude potřeba.)</em></p>\n</li>\n<li><p>Hadi budou dva; druhý se ovládá klávesami\n<kbd>W</kbd> <kbd>A</kbd> <kbd>S</kbd> <kbd>D</kbd>.<br>\n<em>(Na to je nejlepší udělat novou třídu, <code>Snake</code>, a všechen stav hada\npřesunout ze <code>State</code> do ní. Ve <code>State</code> pak měj seznam hadů.\nTéhle změně je potřeba přizpůsobit celý zytek programu.)</em></p>\n</li>\n</ul>\n\n\n "
}
}
}