Soubory a JSON — aby si hra pamatovala

Co si z toho odnést: WriteAllText zakládá, AppendAllText přidává. Až si soubor denik.txt otevřeš v editoru, uvidíš přesně to, co program vypsal.

Co si z toho odnést: textový soubor s oddělovačem ; je nejjednodušší možná „databáze". Split(';') rozřeže řádek, int.Parse udělá z textu číslo.

Co si z toho odnést: slovník v paměti a JSON v souboru jsou dvě podoby té samé věci. Serialize je převede tam, Deserialize zpátky.

Co si z toho odnést: File.Exists je pojistka, JsonElement je „zabalená hodnota" a .GetString() / .GetInt32() ji rozbalí na správný typ.

Co si z toho odnést: tohle už je opravdová uložená hra. Spusť ji několikrát a uvidíš, jak hrdinovi roste úroveň i zlato — protože se to pamatuje.

Zadání:

Hrdina si vede deník. Ten musí přežít i vypnutí počítače.

1. Založ soubor denik.txt a zapiš do něj první zápis
   💡 Poradit

   Zakládá se jedním řádkem: File.WriteAllText(CESTA, "Den 1: …\n");
   Pokud soubor neexistuje, vyrobí se. Pokud existuje, přepíše se.
   Znak \n na konci je odřádkování — bez něj se zápisy slijí.
2. Přidej další tři zápisy, aniž bys ty předchozí smazal
   💡 Poradit

   Na přidávání je File.AppendAllText(CESTA, "Den 2: …\n");
   Kdybys znovu použil WriteAllText, zůstal by v souboru jen poslední zápis.
   Zkus to schválně a podívej se, co se stane — pochopíš to líp než z vysvětlení.
3. Přečti celý deník a vypiš ho na obrazovku
   💡 Poradit

   string obsah = File.ReadAllText(CESTA); vrátí celý soubor jako jeden text.
   Pak ho stačí vypsat: Console.WriteLine(obsah);
   Pro jistotu se nejdřív zeptej: if (File.Exists(CESTA)).
4. Vypiš zápisy očíslované a řekni, kolik jich je
   💡 Poradit

   string[] radky = File.ReadAllLines(CESTA); rozdělí soubor po řádcích.
   Počet zápisů je radky.Length.
   Očíslování: for (int i = 0; i < radky.Length; i++) Console.WriteLine($"{i + 1}. {radky[i]}");
5. Vypiš jen ty zápisy, ve kterých se objeví hledané slovo
   💡 Poradit

   Hledané slovo si dej do proměnné: string HLEDANE = "skřet";
   V cyklu přes řádky se ptej: if (radek.ToLower().Contains(HLEDANE))
ToLower() zajistí, že najdeš i „Skřet" s velkým S.

Zadání:

Nejlepší výsledky musí přežít restart. Ulož je do souboru a zase načti.

1. Zapiš do skore.txt čtyři řádky ve tvaru jmeno;skore
   💡 Poradit

   Nejdřív si připrav pole textů: string[] zaznamy = { "Arkon;1250", "Elara;980", … };
   Zapíšeš je najednou: File.WriteAllLines(CESTA, zaznamy);
   Každý prvek pole skončí na vlastním řádku.
2. Načti řádky, rozřež je a ulož do seznamu n-tic
   💡 Poradit

   string[] casti = radek.Split(';'); rozřeže řádek na dva kusy.
   casti[0] je jméno, casti[1] je skóre — ale jako text.
   Na číslo ho převedeš: int.Parse(casti[1])
   A přidáš: tabulka.Add((casti[0], int.Parse(casti[1])));
3. Seřaď žebříček od nejvyššího skóre a vypiš ho s pořadím
   💡 Poradit

   var serazeno = tabulka.OrderByDescending(h => h.skore).ToList();
   Pořadí vypíšeš klasickým for cyklem přes index.
   Zarovnání: {serazeno[i].jmeno.PadRight(8)} a {serazeno[i].skore,5}.
4. Přidej nový výsledek a ulož celou tabulku zpátky do souboru
   💡 Poradit

   Nejdřív do seznamu: tabulka.Add(("Nová hrdinka", 1420));
   Pak z n-tic udělej zase řádky:
   var vystup = new List<string>();
foreach (var h in serazeno) vystup.Add($"{h.jmeno};{h.skore}");
   A zapiš: File.WriteAllLines(CESTA, vystup);
5. Vypiš statistiku: nejlepší, nejhorší a průměrné skóre
   💡 Poradit

   LINQ to umí jedním voláním:
   tabulka.Max(h => h.skore), tabulka.Min(h => h.skore), tabulka.Average(h => h.skore)
   Průměr je desetinné číslo, zaokrouhli ho: $"{prumer:F0}"
   Sloupec k výsledku: new string('█', h.skore / 200)

Zadání:

Textový soubor na postavu nestačí. Ulož ji ve formátu, kterému rozumí celý svět.

1. Připrav postavu jako Dictionary<string, object>
   💡 Poradit

   Nahoru patří using System.Text.Json;
   Slovník se zapisuje takhle:
   var postava = new Dictionary<string, object> { ["jmeno"] = "Arkon", ["uroven"] = 3 };
   Hodnota smí být číslo, text i celý List<string>.
2. Převeď postavu na JSON s odsazením a vypiš text
   💡 Poradit

   var nastaveni = new JsonSerializerOptions { WriteIndented = true };
string text = JsonSerializer.Serialize(postava, nastaveni);
   Bez WriteIndented by byl celý JSON na jediném řádku.
3. Ulož JSON do souboru a vypiš, kam ses ho uložil
   💡 Poradit

   File.WriteAllText("postava.json", text);
   Kde soubor skončil, zjistíš takhle:
   Console.WriteLine(Directory.GetCurrentDirectory());
   Otevři si ho pak v editoru — je to obyčejný text.
4. Načti soubor zpátky a vypiš jméno, úroveň a životy
   💡 Poradit

   var data = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(File.ReadAllText(CESTA)) ?? new Dictionary<string, JsonElement>();
   Text vytáhneš .GetString() ?? "", číslo .GetInt32().
   Před čtením se zeptej if (File.Exists(CESTA)).
5. Vypiš inventář a poskládej z toho kartu postavy
   💡 Poradit

   Seznam se prochází přes EnumerateArray:
   foreach (JsonElement polozka in data["inventar"].EnumerateArray())
   Uvnitř: Console.WriteLine(" • " + polozka.GetString());
   Rámeček karty poskládej ze znaků ─ a ║ jako v ukázce 4.

Zadání:

Příšery nepatří do kódu, ale do datového souboru. Pak je můžeš měnit bez překládání hry.

1. Vyrob bestiář jako seznam slovníků a ulož ho do bestiar.json
   💡 Poradit

   Jedna příšera je slovník, bestiář je jejich seznam:
   var bestiar = new List<Dictionary<string, object>>();
bestiar.Add(new Dictionary<string, object> { ["jmeno"] = "Skřet", ["zivoty"] = 30, ["utok"] = 6 });
   Uložení je stejné jako u postavy: JsonSerializer.Serialize(bestiar, nastaveni).
2. Načti soubor zpátky a vypiš jména všech příšer
   💡 Poradit

   Typ při čtení je seznam slovníků s JsonElement:
   var nactene = JsonSerializer.Deserialize<List<Dictionary<string, JsonElement>>>(text) ?? new List<Dictionary<string, JsonElement>>();
   Pak stačí foreach (var prisera in nactene) Console.WriteLine(prisera["jmeno"].GetString());
3. Vypiš přehlednou tabulku: jméno, životy, útok
   💡 Poradit

   Zarovnání drží tabulku pohromadě:
   $"{jmeno.PadRight(14)} {zivoty,4} HP {utok,3} ATK"
   Čísla čti přes prisera["zivoty"].GetInt32().
   Nad tabulku si vypiš hlavičku a čáru z ─.
4. Najdi nejsilnější příšeru podle útoku
   💡 Poradit

   Klasický průchod s pamatováním nejlepšího:
   string nejJmeno = ""; a int nejUtok = -1;
   V cyklu: if (utok > nejUtok) { nejUtok = utok; nejJmeno = jmeno; }
   Začíná se od -1, aby první příšera vždycky vyhrála.
5. Seřaď bestiář podle životů a dokresli sloupce
   💡 Poradit

   Nejdřív si přelij data do n-tic, ať se dobře řadí:
   var prehled = new List<(string jmeno, int zivoty, int utok)>();
   Pak: prehled.OrderByDescending(p => p.zivoty).ToList()
   Sloupec: new string('█', p.zivoty / 10)

Zadání:

Tohle je to, kvůli čemu se celá hodina děje. Hra, která si tě pamatuje.

1. Napiš metodu NovaHra(), která vrátí výchozí stav včetně klíče "verze"
   💡 Poradit

   Metoda vrací slovník:
   Dictionary<string, object> NovaHra() { return new Dictionary<string, object> { ["verze"] = VERZE, ["jmeno"] = "Arkon", … }; }
   Klíč "verze" je nejdůležitější — díky němu poznáš staré uložené hry.
2. Napiš metodu Uloz(stav), která stav zapíše jako JSON
   💡 Poradit

   void Uloz(Dictionary<string, object> stav) { … }
   Uvnitř: string text = JsonSerializer.Serialize(stav, new JsonSerializerOptions { WriteIndented = true });
   a File.WriteAllText(CESTA, text);
   Na konec přidej hlášku, ať víš, že se uložilo.
3. Když soubor neexistuje, založ novou hru; jinak ho načti
   💡 Poradit

   if (!File.Exists(CESTA)) { Uloz(NovaHra()); }
   Teprve potom čti:
   var stav = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(File.ReadAllText(CESTA)) ?? new Dictionary<string, JsonElement>();
4. Zkontroluj verzi a při neshodě založ hru novou
   💡 Poradit

   Nejdřív se zeptej, jestli klíč vůbec existuje:
   if (!stav.ContainsKey("verze") || stav["verze"].GetInt32() != VERZE)
   Uvnitř zavolej Uloz(NovaHra()); a soubor načti znovu.
   Bez téhle pojistky se hra rozbije, jakmile změníš strukturu uložené hry.
5. Odehraj jeden tah: úroveň nahoru, zlato, nový předmět — a ulož
   💡 Poradit

   Nejdřív si vytáhni, co v uložené hře je (GetString, GetInt32, EnumerateArray).
   Inventář přelij do obyčejného seznamu:
   var inventar = new List<string>(); foreach (JsonElement p in stav["inventar"].EnumerateArray()) inventar.Add(p.GetString() ?? "");
   Pak přidej předmět, poskládej nový slovník a zavolej Uloz.

Vyrob program „Kronika tvé postavy", který si pamatuje, co se dělo:

• při každém spuštění načte kronika.json (a když neexistuje, založí ho),
• přidá nový záznam s číslem spuštění, datem a nějakou událostí,
• celou kroniku uloží zpátky do souboru,
• vypíše všechny dosavadní záznamy očíslované pod sebou,
• a na konci napíše, kolikrát už jsi program spustil.

Pošli Program.cs i výsledný kronika.json po nejméně třech spuštěních. Ať je na něm vidět, že si program opravdu pamatuje.

Všechno, co jsme dnes použili, je popsané na Microsoft Learn. Odkazy jsou anglicky — klidně si je nech přeložit prohlížečem, kód je stejný v každém jazyce.

Dneškem se z tvých programů staly aplikace. Rozdíl je jediný, zato zásadní: aplikace si pamatuje, co se stalo.

• Umíš zapsat text do souboru a víš, čím se liší WriteAllText od AppendAllText.
• Umíš soubor přečíst celý i po řádcích a rozřezat ho na data.
• Vždycky se zeptáš File.Exists, než začneš číst.
• Víš, co je JSON, umíš ho přečíst očima i programem.
• Používáš JsonSerializer.Serialize a Deserialize a rozumíš tomu, že jde o cestu tam a zpátky mezi pamětí a diskem.
• A umíš uložit a načíst rozehranou hru — včetně kontroly verze, což dělají i opravdové hry.

Podívej se na to takhle: každá aplikace v tvém mobilu dělá přesně tohle. Ukládá si nastavení, postup ve hře, rozepsané zprávy. Formát je většinou JSON a metody se jmenují skoro stejně. Dneska jsi otevřel dveře, za kterými programy přestávají být hračkou na jedno spuštění.

Příště začneme skládat CsQuest dohromady — mapu z dvanácté hodiny, seřazený inventář ze třinácté a uloženou hru z dnešní.