dotnet publish, prezentaceTenhle blok je jen pro vás — dětem ho nepromítejte.
| Fáze | Co se děje | Čas |
|---|---|---|
| Definice hotového | Blok 2, společně na tabuli | 10 min |
| Menu a obrazovky | Blok 3 + ukázka 1 | 15 min |
| Vyvažování | Blok 4 + ukázka 2 | 15 min |
| Ladění cizího kódu | Blok 5 + ukázka 3 | 15 min |
| Cvičení 1–4 | Děti pracují samy | 45 min |
| Cvičení 5 + sestavení | Finální verze, dotnet publish |
25 min |
| Prezentace | Každý 3 minuty | 20 min |
| Zakončení | Blok 10, společně | 10 min |
Tahle hodina má jiný cíl než všechny předchozí. Dosud šlo o učení nových věcí. Dnes jde o dokončení. To je samostatná dovednost a většina lidí ji neumí — proto na světě existuje tolik rozdělaných projektů.
Nejdůležitější věta hodiny, kterou řeknete hned na začátku: „Dnes nesmíte přidat žádnou novou funkci. Dnes se jenom dodělává." Počítejte s odporem. Vysvětlete, že hotová malá hra je víc než nehotová velká.
Praktická poznámka k času. Prezentace zaberou víc, než čekáte. Když máte 20 studentů, dejte na každého 2 minuty a pusťte stopky nahlas. Radši méně času a všichni, než tři podrobné ukázky a zbytek se nedostane na řadu.
Na co si dát pozor. Vždycky jsou ve třídě dva až tři, kterým hra nefunguje. Mějte připravenou funkční verzi CsQuestu z minulé hodiny, kterou si můžou zkopírovat a upravit. Cílem dneška není trestat, ale aby každý odešel s něčím, co běží.
Než dneska napíšeš první řádek, musíš si odpovědět na jednu otázku: co přesně znamená, že je hra hotová?
Bez téhle odpovědi se projekt nedokončí nikdy — vždycky tě napadne ještě jedna věc. Proto si to napiš dopředu a drž se toho:
| Hra je hotová, když… | Splněno? |
|---|---|
| jde spustit a nespadne | |
| někdo cizí pochopí, co má dělat, bez tvé pomoci | |
| dá se dohrát do konce (vyhrát i prohrát) | |
| jde ukončit, aniž bys zavřel okno | |
| má název, autora a rok | |
| jde vyhrát, ale ne pokaždé |
Šest řádků. Nic víc. Nápady navíc si napiš do seznamu „verze 2.0" — a dneska na ně nesahej.
Žádná nová funkce. Když tě něco napadne, zapiš si to a pokračuj v dodělávání. Programátoři tomuhle říkají feature freeze — zmrazení funkcí. Dělá se to před každým vydáním hry i programu, protože jinak by se nevydalo nikdy.
Dosud tvoje hra spustila jednu výpravu a skončila. Hotová hra má menu — místo, kam se hráč vrací a odkud si vybírá.
Základ je jednoduchý: cyklus, výpis nabídky, načtení volby, switch.
Console.ReadLine() — jeden řádek na jedno čtení.Všimni si dvou důležitých detailů:
if (volba == null) break; — když vstup dojde, ReadLine vrátí null.
Bez téhle pojistky by se program zacyklil donekonečna.default: — hráč napíše „ahoj" a hra nespadne. To je rozdíl mezi
školním programem a hotovou hrou.Protože program čte z klávesnice. Do okénka napiš volby pod sebe —
každý řádek je jedno zmáčknutí Enteru. Zkus třeba 1, pak 9, pak 0.
Teď ta část, kterou většina lidí vynechá a která rozhoduje o tom, jestli hru někdo dohraje.
Když si hru vyzkoušíš třikrát, nevíš nic. Náhoda je zrádná. Programátor si proto napíše simulaci: nechá hru odehrát tisíckrát a podívá se na čísla.
Random kostka = new Random(1);
int vyher = 0;
int pokusu = 1000;
for (int i = 0; i < pokusu; i++)
{
if (Simuluj(kostka))
{
vyher++;
}
}
Console.WriteLine($"Úspěšnost: {vyher * 100.0 / pokusu:F1} %");
bool Simuluj(Random r)
{
int hrdina = 120;
int netvor = 90;
int kolo = 1;
while (hrdina > 0 && netvor > 0 && kolo <= 50)
{
netvor -= 12 + r.Next(1, 7);
if (netvor <= 0)
{
return true;
}
hrdina -= 9 + r.Next(1, 5);
kolo++;
}
return hrdina > 0;
}
Co s tím číslem dělat? Existuje osvědčené rozmezí:
| Úspěšnost | Co to znamená | Co udělat |
|---|---|---|
| nad 90 % | hra je nuda, nedá se prohrát | přidej nepříteli životy nebo sílu |
| 55–80 % | přesně tak akorát | nech to být |
| pod 40 % | hráč to vzdá | uber nepříteli nebo přidej lektvary |
| 0 % nebo 100 % | někde je chyba v pravidlech | zkontroluj podmínky cyklu |
Změň jedno číslo, spusť simulaci, podívej se na výsledek. Ne dvě čísla naráz — pak nevíš, které z nich zafungovalo.
Dnešní třetí dovednost: najít chybu v programu, který jsi nepsal. V praxi tím programátor stráví víc času než psaním nového kódu.
Máš na to tři nástroje a všechny tři umíš:
Console.WriteLine($"zivoty = {zivoty}");
na správném místě odhalí víc než hodina přemýšlení.Nejzákeřnější chyby jsou ty, které nespadnou. Program běží, ale počítá blbě:
int zivoty = 40;
int max = 120;
// CHYBA: nejdřív se dělí, pak násobí — celočíselné dělení dá nulu
int spatne = zivoty / max * 100;
// SPRÁVNĚ: nejdřív násobit
int dobre = zivoty * 100 / max;
Console.WriteLine($"Špatně: {spatne} %");
Console.WriteLine($"Správně: {dobre} %");
// CHYBA: přiřazení místo porovnání by tady byla chyba překladu,
// ale tahle podmínka je vždycky pravdivá a nikdo si toho nevšimne
int sila = 0;
if (sila >= 0)
{
Console.WriteLine("Hrdina má sílu. (Ale má? Má nulu.)");
}
Console.WriteLine("Program nespadl. Přesto je špatně.");
Zapamatuj si: „program běží" neznamená „program je správně".
Tenhle blok je návod pro vás, ať máte postup po ruce. Dětem ho promítněte až v okamžiku, kdy mají hru hotovou.
Krok 1 — ověřte, že projekt běží.
cd cesta/k/projektu
dotnet run
Krok 2 — sestavte vydání (release).
dotnet publish -c Release -o vydani
Vznikne složka vydani s programem, který se dá spustit poklepáním.
Krok 3 — samostatný soubor bez instalace .NET (volitelné, ale efektní):
dotnet publish -c Release -r win-x64 --self-contained true -o vydani-win
Výsledek je jeden spustitelný soubor pro Windows. Na macOS použijte
osx-arm64 (nové Macy) nebo osx-x64, na Linuxu linux-x64.
Soubor bude mít kolem 60–70 MB — obsahuje celé běhové prostředí.
Krok 4 — sdílení. Složku vydani zazipujte a nahrajte do školního úložiště
nebo na sdílený disk. Alternativně nahrajte zdrojový kód na GitHub —
to je z hlediska profese hodnotnější a zabere pět minut.
Typické problémy:
| Problém | Příčina | Řešení |
|---|---|---|
„příkaz dotnet nenalezen" |
.NET SDK není nainstalované | viz úvodní hodina, instalace SDK |
| publish projde, ale nic nevznikne | špatná složka | cd do složky s .csproj |
| program blikne a zmizí | konzole se zavře na konci | přidat Console.ReadKey() na konec |
| antivirus soubor blokuje | nepodepsaný spustitelný soubor | sdílejte jako .zip, nebo raději zdroják |
Rada z praxe: program blikne a zmizí potká letos skoro každého.
Naučte je hned na začátku hodiny ukončovat hru řádkem
Console.WriteLine("Zmáčkni Enter pro ukončení."); Console.ReadLine();.
Ušetří vám to dvacet stejných dotazů.
Formát, který funguje: tři minuty na osobu, přesně tahle čtyři témata. Napište je na tabuli a nechte je tam po celou dobu prezentací.
Bod 3 je nejcennější. Nechte na něj čas a ptejte se doplňujícími otázkami. Děti se tak dozvědí, že i ostatní se sekli — a to je pro jejich vztah k programování důležitější než cokoli, co jim řeknete vy.
Hodnocení. Nehodnoťte hru, hodnoťte dokončení. Návrh rozdělení:
| Kritérium | Váha |
|---|---|
| Hra běží a dá se dohrát | 40 % |
| Kód je rozdělený do tříd a modulů | 25 % |
| Hra je vyvážená (ne 0 % ani 100 % výher) | 15 % |
| Prezentace — srozumitelnost | 20 % |
Co nehodnotit: délku kódu, počet funkcí, grafické efekty. Odměňujete tím špatné návyky.
Tip na atmosféru: nechte třídu po každé prezentaci říct jednu věc, která se jim líbila. Nic víc, žádná kritika. Zabere to 15 vteřin na osobu a změní to celý závěr kurzu.
Co se děje při dotnet publish. Překladač přeloží kód do mezijazyka (IL)
a uloží ho do souboru .dll. Vedle vznikne malý spouštěč .exe,
který najde nainstalované běhové prostředí a předá mu tu .dll.
Při --self-contained true se celé běhové prostředí zkopíruje do složky —
proto je výsledek tak velký, ale běží i na počítači bez .NET.
Rozdíl Debug a Release. V Debug (výchozí při dotnet run) překladač
nechává kód „rozvolněný", aby se dal ladit krok po kroku. V Release
zapne optimalizace. Rozdíl ve výkonu je u konzolových her neměřitelný,
ale je to správný návyk.
Proč simulace funguje. Simulace tisíce soubojů je Monte Carlo metoda — místo počítání pravděpodobnosti vzorcem se jev mnohokrát zopakuje a spočítá se poměr. Používá se ve fyzice, financích i při návrhu her. Dětem to takhle neříkejte dopředu, ale po cvičení 2 to zmiňte — udělá to dojem a je to pravda.
Seed a reprodukovatelnost. new Random(1) dá pokaždé stejnou posloupnost.
Pro vyvažování je to nutnost: měníte jen jedno číslo v pravidlech
a chcete vidět jeho vliv, ne vliv jiné náhody. Ve výsledné hře pak
seed odstraníte (new Random()).
Co kurz vědomě neobsahoval. Asynchronní programování, práci s databází,
webové aplikace, testovací frameworky, generika psaná od nuly a rozhraní
(interface). To všechno stojí na tom, co děti umí — a je to přesně ten
seznam, kterým můžete odpovídat na otázku „a co dál?".
| Chyba | Jak se projeví | Co s tím |
|---|---|---|
menu bez default: |
neznámá volba nic neudělá | vždy přidat větev pro zbytek |
chybí if (volba == null) break; |
nekonečný cyklus | ošetřit konec vstupu |
volba == "1" s mezerou |
volba nefunguje | volba.Trim() |
porovnání textů přes == bez Trim |
hráč napíše „ Ano" a neprojde | Trim() a ToLower() |
| dělení před násobením | procenta vždycky 0 | násob dřív, než dělíš |
| cyklus bez pojistky | hra „zamrzne" | while (… && kolo <= 50) |
| nová funkce na poslední chvíli | rozbitá hra před prezentací | feature freeze — nic nového |
| žádné ukončení programu | okno blikne a zmizí | Console.ReadLine() na konci |
| nevyvážená obtížnost | hráč vyhraje vždy nebo nikdy | simulace tisíce soubojů |
| kód bez jména autora | nikdo neví, čí to je | titulky s tvým jménem a rokem |
Tři čtvrtiny dnešních problémů jsou „hra mi nefunguje a nevím proč". Neopravujte to za ně. Ptejte se pořád dokola stejnou otázkou: „co jsi čekal a co se stalo?" Většina studentů si při formulaci odpovědi chybu najde sama.
Druhá nejužitečnější věta: „vypiš si to." Jeden Console.WriteLine
na správném místě řeší víc než desetiminutové koukání do kódu.
Zkus si vzpomenout, co všechno jsi za ten rok poznal:
Proměnné. Datové typy. Vstup od uživatele. Podmínky. Cykly. Seznamy a slovníky. Práce s textem. Metody. Náhoda. Soubory. Třídy a objekty. Dědičnost. Moduly. Sestavení hotové aplikace.
To je celý základ programování. Ne „základ pro děti" — základ, na kterém stojí skutečné programy. Rozdíl mezi tebou a někým, kdo tohle dělá v práci, je hlavně počet odpracovaných hodin.
Kam pokračovat v C#:
| Směr | Co to je | Kde začít |
|---|---|---|
| Unity | tvorba her ve 2D a 3D, skriptuje se v C# | unity.com/learn |
| ASP.NET Core | weby a webová API | Tutoriály ASP.NET Core |
| Blazor | webové stránky psané celé v C# | Blazor |
| MAUI | aplikace pro mobil a desktop | .NET MAUI |
| Konzolové nástroje | malé programy, které ti šetří čas | cokoli, co tě otravuje dělat ručně |
Kam pokračovat obecně:
A poslední věta celého kurzu: hotová malá věc je vždycky víc než nehotová velká. Dneska jsi jednu dokončil. To umí míň lidí, než si myslíš.
Hotová hra se pozná podle toho, že se hráč neztratí. Tohle je kostra, na kterou dneska navlečeš svůj CsQuest.
9 a podívej se, co udělá default:.Console.ReadLine() — jeden řádek na jedno čtení.Co si z toho odnést: while + switch + default: je kostra
každé konzolové aplikace na světě. Jednou ji napíšeš a používáš pořád.
Tohle je nejcennější nástroj dnešní hodiny. Místo hádání pustíš tisíc soubojů a podíváš se na čísla.
SilaHrdiny o 2 a spusť znovu. O kolik stoupla úspěšnost?ZivotyNetvora a najdi hodnotu, kde je úspěšnost mezi 55 a 80 %.Co si z toho odnést: vyvažování není o pocitu. Je to tabulka čísel, kterou si vyrobíš za dvě minuty.
Tenhle program se přeloží a spustí. Přesto je v něm pět chyb. Žádná z nich hru neshodí — jen ji tiše rozbijí. Najdeš je?
// ???.Řešení chyb (nejdřív ať hádají, teprve pak ukažte):
| # | Chyba | Oprava |
|---|---|---|
| 1 | i <= Length sáhne za konec pole |
i < obtiznosti.Length |
| 2 | obtiznost / 20 je celočíselně vždy 0 |
obtiznosti[i] * 20 |
| 3 | dělení před násobením | zivoty * 100 / maxZivotu |
| 4 | < 0 propustí přesnou nulu |
zivoty <= 0 |
| 5 | celočíselné dělení poraveno / 3 |
poraveno * 100 / 3 |
Co si z toho odnést: čtyři z pěti chyb souvisí s celočíselným dělením a hraničními hodnotami. Přesně to jsou místa, kde se chybuje nejčastěji.
Tohle je rozdíl mezi „školním úkolem" a „hrou". Trvá to deset minut a je to nejvíc vidět.
═ a ║.Co si z toho odnést: titulky nejsou ozdoba. Jsou to informace, které hráč potřebuje — název, autor, verze a jak se to hraje.
Všechno dohromady: moduly z minulé hodiny, menu, vyvážená čísla a titulky. Takhle vypadá hotová hra.
Titulky.Autor.Data.ZivotyZaUroven.Data.Console.ReadLine() — jeden řádek na jedno čtení.Co si z toho odnést: tohle je celá hra. Moduly, menu, souboje, titulky. A všechno jsou to věci, které jsi se naučil během tohohle kurzu.
Zadání:
Postav své hře menu, ze kterého se ovládá všechno ostatní.
- Udělej cyklus
whiles výpisem nabídky💡 Poradit
Potřebuješ proměnnou, která cyklus drží naživu:bool bezi = true;while (bezi){Console.WriteLine(" 1) Výprava");}- Načti volbu a ošetři konec vstupu
💡 Poradit
string? volba = Console.ReadLine();if (volba == null) { break; }
Bez téhle pojistky se program zacyklí, jakmile vstup dojde.- Rozhodni podle volby pomocí
switch💡 Poradit
switch (volba.Trim()){case "1": … break;case "0": bezi = false; break;}Trim()odstraní mezery, které hráč omylem napíše.- Přidej větev
default:pro neznámou volbu💡 Poradit
default:Console.WriteLine("Takovou volbu neznám.");break;
Díky tomu hra nespadne, když hráč napíše „ahoj".- Napoj na menu skutečné akce hry
💡 Poradit
Každýcaseať jen zavolá metodu —Hra.Vyprava(...),Hra.Odpocinek(...). Menu má rozhodovat, ne počítat. A po každém kole zkontroluj, jestli hrdina žije.
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–3, menu se dá ukončit |
| Rozšíření | Bod 4, neznámá volba nespadne |
| Výzva | Bod 5 plus obrazovka s nápovědou |
Console.ReadLine() — jeden řádek na jedno čtení.Očekávaný výsledek: hra se dá ovládat, ukončit a nespadne na nesmyslném vstupu.
Kde se zaseknou:
if (volba == null) break;
se po vyčerpání vstupu točí napořád. V prohlížeči to vypadá jako zamrznutí.
Řekněte to hned na začátku, ne až se to stane.break; ve switch → CS0163. C# na rozdíl od jiných jazyků
nedovolí „propadnout" do další větve.volba == 1 místo "1" → CS0019. ReadLine vrací text, ne číslo.Trim() — hráč napíše mezeru a volba nefunguje. Nechte je to zkusit.Dobrá otázka do třídy: „co se stane, když hráč jen zmáčkne Enter?"
Odpověď: prázdný text spadne do default: a hra řekne, že volbu nezná.
Je to správně a je to zadarmo — díky té jedné větvi.
Rychlíkům zadejte volbu „4) Statistiky", která vypíše počet výprav, celkem utrpěná zranění a nasbírané zlato.
Toto je jedna z možných variant. Tvoje řešení se může lišit a to je v pořádku.
Console.ReadLine() — jeden řádek na jedno čtení.Zadání:
Zjisti simulací, jestli se tvoje hra dá vyhrát — a uprav čísla tak, aby to bylo napínavé.
- Napiš metodu
Simuluj, která odehraje jeden souboj💡 Poradit
Lokální funkce, která vrátítruepři vítězství:bool Simuluj(Random r, int zivotyNetvora){int hrdina = 120;…return netvor <= 0;}
Nezapomeň na pojistkukolo < 50, jinak se to může zacyklit.- Spusť ji tisíckrát a spočítej úspěšnost
💡 Poradit
Počítadlo výher a podíl na konci:double uspesnost = vyher * 100.0 / pokusu;
Pozor na100.0— bez tečky nuly by ti celočíselné dělení všechno zaokrouhlilo.- Vyzkoušej víc hodnot najednou a udělej tabulku
💡 Poradit
foreach (int hodnota in new int[] { 60, 80, 100, 120 })
a uvnitř pokaždé novýnew Random(1), aby se porovnávaly stejné podmínky.- Ohodnoť každý řádek slovem
💡 Poradit
Malá metoda, která z čísla udělá text:if (uspesnost > 90) return "moc lehké";if (uspesnost >= 55) return "akorát";
Pásmo 55–80 % je to, co chceš.- Dosaď nejlepší hodnotu do své hry
💡 Poradit
Změň jedno číslo vDataa spusť simulaci znovu. Pak přidej i sloupec s průměrným počtem kol — souboj kratší než 3 kola je nuda, delší než 15 otravný.
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–2, jedno číslo úspěšnosti |
| Rozšíření | Body 3–4, tabulka s hodnocením |
| Výzva | Bod 5 plus průměrná délka souboje |
Očekávaný výsledek: tabulka čísel, ze které se dá rozhodnout. A hlavně poznání, že se obtížnost dá změřit.
Kde se zaseknou:
vyher * 100 / pokusu bez desetinné tečky → výsledek je celé číslo
a vypadá to, že simulace nefunguje. Ukažte rozdíl 100 a 100.0.Random pro celou tabulku → každý řádek dostane jinou náhodu
a výsledky se nedají porovnat. Nový new Random(1) před každým řádkem.kolo < 50 → při špatných číslech se program zacyklí.out int kola je pro ně nové. Vysvětlete jednou větou:
„metoda vrátí dvě věci — návratovou hodnotu a ještě tohle."
Kdo to nechce, ať vrátí místo bool číslo kol a vítězství pozná podle znaménka.Nejsilnější moment hodiny: nechte je změnit jedno číslo v simulaci (třeba sílu hrdiny z 12 na 14) a znovu spustit. Úspěšnost vyskočí o desítky procent. Tohle je okamžik, kdy pochopí, proč se hry testují a nevymýšlejí od oka.
Rychlíkům zadejte simulaci celé výpravy přes tři místa — kolik procent hráčů dojde na konec?
Toto je jedna z možných variant. Tvoje řešení se může lišit a to je v pořádku.
Zadání:
V programu níž je pět chyb. Žádná z nich program neshodí — všechny jen tiše počítají špatně. Najdi je a oprav.
- Spusť program a řekni, co je na výstupu divné
💡 Poradit
Nekoukej hned do kódu. Podívej se na čísla: procenta jsou pořád 0, zlato skoro nepřibývá, úspěšnost je 0 %. To nejsou tři chyby — to jsou stopy.- Najdi chybu v cyklu procházejícím pole
💡 Poradit
for (int i = 0; i <= pole.Length; i++)sáhne o jeden prvek za konec. Poslední platný index jeLength - 1, takže podmínka musí býti < pole.Length.- Oprav všechna celočíselná dělení
💡 Poradit
V C# je40 / 120rovno nule. Vždycky nejdřív násob:zivoty * 100 / maxZivotu
Podívej se na každé místo, kde je lomítko.- Oprav hraniční podmínky
💡 Poradit
Hrdina s přesně 0 životy je mrtvý, ne živý. Protozivoty <= 0, ne< 0. Stejně tak u nepřítele.- Přidej kontrolní výpis, který chybu odhalí
💡 Poradit
Dočasně si vypiš mezivýsledky:Console.WriteLine($" [ladění] zivoty={zivoty} netvor={netvor} kolo={kolo}");
Uvnitř cyklu ti to ukáže přesně, kde se čísla rozjedou.
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–2, chyba v cyklu opravena |
| Rozšíření | Body 3–4, všechna dělení a hranice |
| Výzva | Bod 5 plus popis, jak by se každá chyba dala odhalit |
Očekávaný výsledek: pět oprav a — hlavně — pochopení, že program může běžet a přitom být celý špatně.
Chyby a jejich lék:
| # | Chyba | Proč je zrádná |
|---|---|---|
| A | netvor < 0 |
netvor s přesně nulou HP „přežije" |
| B | obtiznost / 20 |
celočíselné dělení dá vždy 0 |
| C | zivoty / max * 100 |
procenta jsou vždy 0 |
| D | zivoty < 0 |
hrdina s nulou životů „žije" |
| E | poraveno / 3 * 100 |
úspěšnost je vždy 0 |
Postup, který doporučuji vnutit: ať opravují po jedné a po každé opravě spustí program. Kdo opraví všechno naráz a program pořád nefunguje, neví, která oprava byla špatně.
Nejdůležitější věta: „čtyři z pěti chyb jsou celočíselné dělení nebo hranice. Tohle jsou dvě místa, kde chybuje úplně každý — i profesionál po dvaceti letech."
K poslednímu kroku. Proměnná ladeni je jednoduchá verze toho,
čemu se v praxi říká logování. Řekněte, že opravdové programy mají
těchto výpisů stovky a zapínají se podle potřeby.
Rychlíkům zadejte, ať do programu sami schovají šestou chybu a nechají ji najít sousedovi.
Toto je jedna z možných variant. Tvoje řešení se může lišit a to je v pořádku.
Zadání:
Udělej ze svého programu svoji hru. Název, autor, nápověda, titulky.
- Založ modul
Titulkys konstantami💡 Poradit
static class Titulky{public const string Nazev = "…";public const string Autor = "Tvoje jméno";public const int Rok = 2026;}- Napiš metodu
Uvod()s rámečkem💡 Poradit
Skládej řádky do seznamu a pak je spoj:List<string> radky = new List<string>();radky.Add("╔" + new string('═', 46) + "╗");return string.Join("\n", radky);- Vycentruj text v rámečku
💡 Poradit
Trik na vystředění:text.PadLeft((Sirka + text.Length) / 2).PadRight(Sirka)
PrvníPadLeftpřidá mezery zleva,PadRightdorovná zbytek.- Přidej
Napoveda()s pravidly hry💡 Poradit
Čtyři až pět odrážek stačí. Piš je tak, aby jim rozuměl někdo, kdo tvoji hru vidí poprvé — ne ty za měsíc.- Přidej
Zaver()s výsledkem a hodností💡 Poradit
Metoda dostane výsledky a vrátí celý závěrečný text:public static string Zaver(int poraveno, int zlato)
Hodnost odvoď od zlata — třeba nováček / dobrodruh / veterán / legenda.
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–2, rámeček s názvem a autorem |
| Rozšíření | Body 3–4, vycentrovaný text a nápověda |
| Výzva | Bod 5 plus hodnost a vlastní ASCII obrázek |
Očekávaný výsledek: hra má název, autora, rok a nápovědu. Vypadá jako produkt, ne jako školní úkol.
Proč to není ztráta času. Tohle cvičení dělá pro motivaci víc než cokoli jiného v hodině. Děti poprvé vidí svoje jméno „v programu" a začnou tomu říkat moje hra, ne ten úkol.
Kde se zaseknou:
PadRight počítá znaky, ne šířku — u emodži se to rozjede.
Dobrá příležitost říct, že „znak" a „to, co vidíš" není totéž.static u metod v Titulky → CS0120, už poněkolikáté.\\ v běžném řetězci znamená jedno lomítko.Nenechte je u toho strávit celou hodinu. Dvacet minut a jde se dál. Kdo chce kreslit ASCII draky, ať to dodělá doma.
Rychlíkům zadejte nápovědu, která se zobrazí jen napoprvé,
a metodu Titulky.Verze čtenou z jednoho místa v celé hře.
Toto je jedna z možných variant. Tvoje řešení se může lišit a to je v pořádku.
Zadání:
Poskládej všechno dohromady, projdi si kontrolní seznam a připrav prezentaci.
- Spoj moduly
Data,Postava,HraaTitulkydo jedné hry💡 Poradit
Nic nového nepiš. Vezmi hotové kousky z předchozích cvičení a dej je pod sebe. Hlavní část ať obsahuje jen menu a volání metod.- Ověř, že hra jde vyhrát i prohrát
💡 Poradit
Musí existovat obě koncovky. Přidej podmínku vítězství (prošel jsi všechna místa) i prohry (životy na nule) a po každé akci obě zkontroluj.- Projdi kontrolní seznam „definice hotového"
💡 Poradit
Šest bodů z úvodu hodiny: spustí se, cizí to pochopí, dá se dohrát, jde ukončit, má titulky, není 100% ani 0% výher. Napiš si je do programu jako komentář a odškrtej.- Ukonči program slušně
💡 Poradit
Na úplný konec patří závěrečné shrnutí a pak:Console.WriteLine("Zmáčkni Enter pro ukončení.");Console.ReadLine();
Bez toho okno na počítači blikne a zmizí.- Připrav si kartu projektu na prezentaci
💡 Poradit
Čtyři věty: co to je, co ukážu, co mi nešlo, na co jsem pyšný. Napiš je rovnou do programu jako metoduTitulky.Karta()— máš je pak po ruce a nezapomeneš.
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–2, hra běží a má obě koncovky |
| Rozšíření | Body 3–4, kontrolní seznam a slušné ukončení |
| Výzva | Bod 5 plus sestavení přes dotnet publish doma |
Console.ReadLine() — jeden řádek na jedno čtení.Očekávaný výsledek: hotová hra, která má obě koncovky, jde ukončit a má titulky. A karta projektu, podle které student odprezentuje.
Kde se zaseknou:
dalsiMisto přeteče za konec seznamu → ArgumentOutOfRangeException.
Kontrola vítězství musí být po každém kole, ne až na konci.CS0101. Řešení: skládat po jednom modulu a po každém spustit.Karta projektu není buzerace. Bez ní většina studentů při prezentaci řekne „no, je to hra" a sedne si. Se čtyřmi připravenými větami mluví tři minuty a zní jistě.
K nasazení. Kdo pracuje doma ve VS Code, ať zkusí dotnet publish
podle učitelského bloku v první části hodiny. V prohlížeči to nejde
a nevadí — hlavní je, aby věděli, že to existuje a jak se to jmenuje.
Poslední věc. Až budou všichni hotoví, nechte je hru vyměnit se sousedem a pět minut hrát tu cizí. Zpětná vazba od vrstevníka je desetkrát účinnější než vaše.
Toto je jedna z možných variant. Tvoje řešení se může lišit a to je v pořádku.
Řešení je totožné s posledním krokem v dílně výše — CsQuest 1.0 se všemi čtyřmi moduly, dvěma koncovkami, nápovědou, titulky, hodností a kartou projektu pro prezentaci.
Co ještě můžeš přidat doma:
| Nápad | Co se naučíš |
|---|---|
| ukládání pozice do souboru | File.WriteAllLines a File.ReadAllLines |
| žebříček nejlepších výsledků | řazení seznamu přes OrderByDescending |
| druhý hrdina ovládaný počítačem | jednoduchá rozhodovací pravidla |
| obchod s předměty | slovník a kontrola zlata |
| více typů nepřátel | dědičnost z 16. hodiny |
A nezapomeň: verze 1.0 je hotová. Tohle všechno je verze 1.1 a dál.
Není. Máš hotovou hru.
Jestli chceš pokračovat: zkus si ji doma sestavit přes
dotnet publisha pošli kamarádovi. Nebo přidej ukládání pozice do souboru, obchod s předměty či druhého hrdinu, kterého ovládá počítač.A hlavně — ukaž hru někomu, kdo o programování nic neví. Ať vidí, co umíš.
Tenhle „nulový" domácí úkol je záměr. Kurz končí a poslední zpráva, kterou si děti odnesou, nemá být „ještě něco dodělejte", ale „dokončil jsi to, je to hotové."
Kdo chce pokračovat, dostane seznam nápadů — a to stačí. Zkušenost říká, že dva až tři studenti ve třídě opravdu pokračují. Těm se vyplatí dát odkaz na Unity nebo ASP.NET a nechat je být.
Praktická poznámka na závěr. Vyberte od dětí zdrojové soubory a založte z nich sdílenou složku. Příští rok je pustíte nové třídě jako ukázku, co se dá za rok zvládnout. Funguje to lépe než jakákoli motivační řeč.
Úkol nemá jedno řešení — je jím tvoje hotová hra.
Tady je aspoň kontrolní seznam, podle kterého poznáš, že je verze 1.0 opravdu hotová:
| Bod | Splněno? |
|---|---|
| Program se spustí a nespadne ani na nesmyslném vstupu | |
| Hra má nápovědu, kterou pochopí i cizí člověk | |
| Existuje vítězná i prohraná koncovka | |
| Hra jde ukončit volbou z menu | |
| Titulky obsahují název, autora, rok a verzi | |
| Úspěšnost mezi 40 a 80 % (ověřeno simulací) | |
| Kód je rozdělený do modulů, hlavní část má pod 40 řádků | |
| Mám připravenou kartu projektu na prezentaci |
Osm zaškrtnutých políček = CsQuest 1.0 je hotový.
Oficiální dokumentace je místo, kam se programátoři chodí podívat, když si chtějí něco ověřit nebo zjistit víc detailů. Je většinou v angličtině, ale to nevadí — zkus se orientovat podle názvu příkazu a podle ukázek kódu.
| Co jsme použili | Oficiální dokumentace | Co tam najdeš |
|---|---|---|
switch |
Příkaz switch |
větvení podle hodnoty, včetně default |
while a break |
Iterační příkazy | cykly a jejich ukončení |
Console.ReadLine |
Console.ReadLine |
proč vrací null na konci vstupu |
string.Trim |
String.Trim |
odstranění mezer z okrajů |
out parametry |
Modifikátor out |
jak metoda vrátí víc hodnot |
| formátování čísel | Formátovací řetězce | :F1, :P0 a další |
Random |
Random |
seed a reprodukovatelné výsledky |
dotnet publish |
dotnet publish |
sestavení hotové aplikace |
| samostatný soubor | Self-contained nasazení | program běžící bez instalace .NET |
| ladění ve VS Code | Ladění v C# | zarážky a krokování |
| kam dál | Dokumentace C# | rozcestník celého jazyka |
| Unity | Unity Learn | tvorba her v C# |
Dnes je nejdůležitější stránka dotnet publish. Promítněte ji a ukažte,
že v ní je přesně ten příkaz, který jste jim diktovali. Je to poslední
příležitost ukázat, že dokumentace není nepřátelské území —
je to místo, kde jsou odpovědi.
Rozcestník dokumentace C# nechte otevřený na projektoru během prezentací. Až se někdo zeptá „a jak by se udělalo…", ukažte, kde by odpověď hledal. To je poslední a nejdůležitější dovednost celého kurzu.
Pro rychlejší studenty, kteří dokončí dřív, nebo na posledních 10–15 minut.
| Cvičení | Odkaz | Proč se hodí |
|---|---|---|
| Programování — základy | umimeinformatiku.cz | zopakování všeho, co kurz probral |
| Ladění a čtení kódu | umimeinformatiku.cz | přesně dnešní dovednost — najít chybu v cizím programu |
| Algoritmy | umimeinformatiku.cz | další krok za hranice tohohle kurzu |
Dnes je ale nejlepší „cvičení" jiné: zahrát si hru spolužáka a napsat mu jednu věc, která se povedla, a jednu, která by šla vylepšit.
Nechte poslední čtvrthodinu úplně volnou na vzájemné hraní. Děti se tak dozvědí víc než z jakéhokoli cvičení — uvidí, že stejné zadání jde vyřešit deseti různými způsoby, a najdou v cizí hře nápady, které je samotné nenapadly.
A vy si mezitím udělejte poznámky k hodnocení. Je to jediná chvíle v roce, kdy máte všechny projekty naráz před sebou a všichni jsou spokojení.