Lekce 8 - Bojovník do arény v Pythonu

V předešlém cvičení, Řešené úlohy k 6.-7. lekci OOP v Pythonu, jsme si procvičili nabyté zkušenosti z předchozích lekcí.

Již tedy víme, jak fungují reference a jak můžeme s objekty zacházet. Bude se nám to hodit dnes i příště. Tento a příští Python tutoriál budou věnovány dokončení naší arény. Hrací kostku již máme, ještě nám chybí další dva objekty: bojovník a samotná aréna. Dnes se budeme věnovat bojovníkovi. Nejprve si popišme, co má bojovník umět, poté se pustíme do psaní kódu.

Atributy

Bojovník se bude nějak jmenovat a bude mít určitý počet hp (tedy bodů života, např. 80hp). Budeme uchovávat jeho maximální život (bude se lišit u každé instance) a jeho současný život, tedy např. zraněný bojovník bude mít 40hp z 80. Bojovník má určitý útok a obranu, obojí vyjádřené opět v hp. Když bojovník útočí s útokem 20hp na druhého bojovníka s obranou 10hp, ubere mu 10hp života. Bojovník bude mít referenci na instanci objektu Kostka. Při útoku či obraně si vždy hodí kostkou a k útoku/obraně přičte padlé číslo. (Samozřejmě by mohl mít každý bojovník svou kostku, ale chtěl jsem se přiblížit stolní podobě hry a ukázat, jak OOP opravdu simuluje realitu. Bojovníci tedy budou sdílet jednu instanci kostky.) Kostkou dodáme hře prvek náhody, v realitě se jedná vlastně o štěstí, jak se útok nebo obrana vydaří. Konečně budeme chtít, aby bojovníci podávali zprávy o tom, co se děje, protože jinak by z toho uživatel nic neměl. Zpráva bude vypadat např. "Zalgoren útočí s úderem za 25hp.". Zprávami se zatím nebudeme zatěžovat a vrátíme se k nim až nakonec.

Již víme, co budeme dělat, pojďme na to! 🙂 Nejprve upravíme strukturu našeho projektu TahovyBoj. Třídu Kostka v souboru kostka.py máme hotovou a dál se jí nebudeme zabývat, jen ji budeme používat. Aby to bylo možné, budeme si ji muset do všech dalších souborů, kde ji chceme využít, nejprve importovat. V našem případě to bude import do nového souboru main.py, který si založíme. V něm bude hlavní kód programu, tedy to, co budeme psát mimo třídy. Arénu budeme mít v souboru arena.py. Ten si jen založíme a necháme na příště. Strukturu projektu tím máme hotovou a nic nám nebrání pustit se do bojovníka. Do nového souboru bojovnik.py si tedy přidejme třídu Bojovnik. Za moment ji dodáme i patřičné atributy. Všechny budou privátní. Třída Bojovnik zatím vypadá tedy takto:

class Bojovnik:
    """
    Třída reprezentující bojovníka do arény.
    """

Metody

Pojďme pro atributy vytvořit konstruktor, nebude to nic těžkého. Komentáře zde vynechám, vy si je dopište podobně, jako u atributů výše. Nebudu je psát ani u dalších metod, aby se tutoriál zbytečně neroztahoval a zůstal přehledný (případně se podívejte do archivu):

def __init__(self, jmeno, zivot, utok, obrana, kostka):
    self._jmeno = jmeno
    self._zivot = zivot
    self._max_zivot = zivot
    self._utok = utok
    self._obrana = obrana
    self._kostka = kostka

Všimněme si, že maximální zdraví si v konstruktoru odvodíme a nemáme na něj parametr v hlavičce. Předpokládáme, že je bojovník při vytvoření plně zdravý. Stačí nám tedy znát pouze jeho život a maximální život bude stejný.

Přejděme k metodám a opět se nejprve zamysleme nad tím, co by měl bojovník umět. Začněme tím jednodušším, budeme chtít nějakou textovou reprezentaci, abychom mohli bojovníka vypsat. Překryjeme tedy metodu __str__(), která vrátí jméno bojovníka. Určitě se nám bude hodit metoda vracející, zda je bojovník naživu. Aby to bylo trochu zajímavější, budeme chtít kreslit život bojovníka do konzole, nebudeme tedy psát, kolik má života, ale "vykreslíme" ho takto:

[#########    ]

Výše uvedený život by odpovídal asi 70%. Dosud zmíněné metody nepotřebovaly žádné parametry. Samotný útok a obranu nechme na později a pojďme si implementovat metody __str__(), je_nazivu() a graficky_zivot(). Začněme se __str__(), tam není co vymýšlet:

def __str__(self):
    return str(self._jmeno)

Nyní implementujme metodu je_nazivu(), opět to nebude nic těžkého. Stačí zkontrolovat, zda je život větší než 0 a podle toho se zachovat:

def je_nazivu(self):
    if self._zivot > 0:
       return True
    else:
       return False

Jelikož i samotný výraz (self._zivot > 0) je vlastně logická hodnota, můžeme vrátit tu a kód se značně zjednoduší:

def je_nazivu(self):
    return self._zivot > 0

Grafický život

Jak už jsme zmínili, metoda graficky_zivot() umožní vykreslit ukazatel života v grafické podobě. Již víme, že z hlediska objektového návrhu není vhodné, aby metoda objektu přímo vypisovala do konzole (pokud není k výpisu objekt určený), proto si znaky uložíme do řetězce a ten vrátíme pro pozdější vypsání. Podívejme se na kód metody a následně si jej podrobně popíšeme:

def graficky_zivot(self):
    celkem = 20
    pocet = int(self._zivot / self._max_zivot * celkem)
    if (pocet == 0 and self.je_nazivu()):
        pocet = 1
    return f"[{'#'*pocet}{' '*(celkem-pocet)}]"

Určíme si celkovou délku ukazatele života do proměnné celkem (například 20). Nyní v podstatě nepotřebujeme nic jiného, než trojčlenku. Pokud max_zivot odpovídá celkem dílků, zivot bude odpovídat pocet dílkům. Proměnná pocet je počet dílků aktuálního zdraví.

Matematicky platí, že pocet = (zivot / maxZivot) * celkem. My ještě doplníme přetypování na celé číslo.

Měli bychom ošetřit případ, kdy je život tak nízký, že nám vyjde na 0 dílků, ale bojovník je stále naživu. V tom případě vykreslíme jeden dílek, jinak by to vypadalo, že je již mrtvý. Dále využijeme formátování a replikování.

Vše si vyzkoušíme. Přejděme do souboru main.py a importujme si třídy Bojovnik a Kostka:

from bojovnik import Bojovnik
from kostka import Kostka

Dále si vytvoříme instanci bojovníka (a kostky, protože tu musíme konstruktoru bojovníka předat). Následně vypíšeme, zda je naživu a jeho život graficky:

{PYTHON}
from kostka import Kostka
from bojovnik import Bojovnik

kostka = Kostka(10)
bojovnik = Bojovnik("Zalgoren", 100, 20, 10, kostka)
print(f"Bojovník: {bojovnik}")  # test __str__()
print(f"Naživu: {bojovnik.je_nazivu()}")  # test naživu
print(f"Život: {bojovnik.graficky_zivot()}")  # test graficky_zivot()
{/PYTHON}
{PYTHON}
class Bojovnik:
    """
    Třída reprezentující bojovníka do arény.
    """

    def __init__(self, jmeno, zivot, utok, obrana, kostka):
        """
        jmeno - jméno bojovníka
        zivot - maximální život bojovníka
        utok - útok bojovníka
        obrana - obrana bojovníka
        kostka - instance kostky
        """
        self._jmeno = jmeno
        self._zivot = zivot
        self._max_zivot = zivot
        self._utok = utok
        self._obrana = obrana
        self._kostka = kostka

    def __str__(self):
        return str(self._jmeno)

    def je_nazivu(self):
        return self._zivot > 0

    def graficky_zivot(self):
        celkem = 20
        pocet = int(self._zivot / self._max_zivot * celkem)
        if pocet == 0 and self.je_nazivu():
           pocet = 1
        return f"[{'#'*pocet}{' '*(celkem-pocet)}]"
{/PYTHON}
{PYTHON}
class Kostka:
    """
    Třída reprezentuje hrací kostku.
    """

    def __init__(self,pocet_sten=6):
        self._pocet_sten = pocet_sten

    def vrat_pocet_sten(self):
        """
        Vrátí počet stěn kostky.
        """
        return self._pocet_sten

    def hod(self):
        """
        Vykoná hod kostkou a vrátí číslo od 1 do
        počtu stěn.
        """
        import random as _random
        return _random.randint(1, self._pocet_sten)

    def __str__(self):
        """
        Vrací textovou reprezentaci kostky.
        """
        return f"Kostka({self._pocet_sten})"
{/PYTHON}

Podívejme se na výstup:

Zalgoren žije!
Bojovník: Zalgoren
Naživu: True
Život: [####################]

Boj

Dostáváme se k samotnému boji. Implementujeme metody pro útok a obranu.

Obrana

Začněme obranou. Vrátíme se do souboru bojovnik.py a do třídy Bojovnik přidáme obrannou metodu. Metoda bran_se() bude umožňovat bránit se úderu, jehož síla bude předána metodě jako parametr. Metodu si opět ukážeme a poté popíšeme:

def bran_se(self, uder):
    zraneni = uder - (self._obrana + self._kostka.hod())
    if zraneni > 0:
        self._zivot = self._zivot - zraneni
        if self._zivot < 0:
            self._zivot = 0

Nejprve spočítáme skutečné zranění a to tak, že z útoku nepřítele odečteme naši obranu zvýšenou o číslo, které padlo na hrací kostce. Pokud jsme zranění celé neodrazili (zraneni > 0), budeme snižovat náš život. Tato podmínka je důležitá, kdybychom zranění odrazili a bylo například -2, bez podmínky by se život zvýšil. Po snížení života zkontrolujeme, zda není v záporné hodnotě a případně ho dorovnáme na nulu.

Útok

Metoda utoc() bude brát jako parametr instanci bojovníka, na kterého se útočí. To proto, abychom na něm mohli zavolat metodu bran_se(), která na náš útok zareaguje a zmenší protivníkův život. Zde vidíme výhody referencí v Pythonu, můžeme si instance jednoduše předávat a volat na nich metody, aniž by došlo k jejich zkopírování. Jako první vypočteme úder. Podobně jako při obraně bude úder tvořit náš útok + hodnota z hrací kostky. Na soupeři následně zavoláme metodu bran_se() s hodnotou úderu:

def utoc(self, souper):
    uder = self._utok + self._kostka.hod()
    souper.bran_se(uder)

To bychom měli, pojďme si zkusit v našem hlavním programu (v main.py) zaútočit a poté znovu vykreslit život. Pro jednoduchost nebudeme zakládat dalšího bojovníka, ale zaútočíme sami na sebe:

{PYTHON}
from kostka import Kostka
from bojovnik import Bojovnik

kostka = Kostka(10)
bojovnik = Bojovnik("Zalgoren", 100, 20, 10, kostka)
print(f"Bojovník: {bojovnik}")  # test __str__()
print(f"Naživu: {bojovnik.je_nazivu()}")  # test naživu
print(f"Život: {bojovnik.graficky_zivot()}")  # test graficky_zivot()
bojovnik.utoc(bojovnik)
print(f"Život po útoku: {bojovnik.graficky_zivot()}")
{/PYTHON}
{PYTHON}
class Bojovnik:
    """
    Třída reprezentující bojovníka do arény.
    """

    def __init__(self, jmeno, zivot, utok, obrana, kostka):
        """
        jmeno - jméno bojovníka
        zivot - maximální život bojovníka
        utok - útok bojovníka
        obrana - obrana bojovníka
        kostka - instance kostky
        """
        self._jmeno = jmeno
        self._zivot = zivot
        self._max_zivot = zivot
        self._utok = utok
        self._obrana = obrana
        self._kostka = kostka

    def __str__(self):
        return str(self._jmeno)

    def je_nazivu(self):
        return self._zivot > 0

    def graficky_zivot(self):
        celkem = 20
        pocet = int(self._zivot / self._max_zivot * celkem)
        if (pocet == 0 and self.je_nazivu()):
            pocet = 1
        return "[{0}{1}]".format("#"*pocet, " "*(celkem-pocet))

    def bran_se(self, uder):
        zraneni = uder - (self._obrana + self._kostka.hod())
        if zraneni > 0:
            self._zivot = self._zivot - zraneni
            if self._zivot < 0:
                self._zivot = 0

    def utoc(self, souper):
        uder = self._utok + self._kostka.hod()
        souper.bran_se(uder)
{/PYTHON}
{PYTHON}
class Kostka:
    """
    Třída reprezentuje hrací kostku.
    """

    def __init__(self,pocet_sten=6):
        self._pocet_sten = pocet_sten

    def vrat_pocet_sten(self):
        """
        Vrátí počet stěn kostky.
        """
        return self._pocet_sten

    def hod(self):
        """
        Vykoná hod kostkou a vrátí číslo od 1 do
        počtu stěn.
        """
        import random as _random
        return _random.randint(1, self._pocet_sten)

    def __str__(self):
        """
        Vrací textovou reprezentaci kostky.
        """
        return f"Kostka({self._pocet_sten})"
{/PYTHON}

Vše funguje, jak má:

Zalgoren se zranil!
Bojovník: Zalgoren
Naživu: True
Život: [####################]
Život po útoku: [#################   ]

Přejděme k poslednímu bodu dnešního tutoriálu a to ke zprávám.

Zprávy

Jak již bylo řečeno, o útocích a obraně budeme uživatele informovat výpisem na konzoli. Výpis nebude provádět samotná třída Bojovnik, ta bude jen vracet zprávy jako textové řetězce. Jedna možnost by byla při volání metod utoc() a bran_se() vrátit i zprávu. Problém by však nastal v případě, když bychom chtěli získat zprávu od metody, která již něco vrací. Metoda samozřejmě nemůže jednoduše vrátit dvě věci.

Pojďme na věc univerzálněji, zprávu budeme ukládat do privátní proměnné zprava a napíšeme metody pro její uložení a navrácení. Samozřejmě bychom mohli udělat proměnnou veřejnou (a fungovalo by to stejně), ale není důvod, proč umožnit zvenčí zápis do zprávy. Skládání složitější zprávy uvnitř třídy by také mohlo být někdy problematické.

Vždy je lepší být "přehnaně" důsledný a využívat zapouzdření všude, kde je to možné.

Do metody konstruktoru bojovníka __init__() tedy přidáme:

self._zprava = ""

Nyní si ve třídě Bojovník vytvoříme dvě metody. Privátní metodu _nastav_zpravu(), která bere jako parametr text zprávy a slouží pro vnitřní účely třídy, kde nastaví zprávu do privátní proměnné:

def _nastav_zpravu(self, zprava):
    self._zprava = zprava

Nic složitého. Podobně jednoduchá bude veřejná metoda pro navrácení zprávy:

def vrat_posledni_zpravu(self):
    return self._zprava

O práci se zprávami obohatíme naše metody utoc() a bran_se(). Nyní budou vypadat takto:

    def bran_se(self, uder):
    zraneni = uder - (self._obrana + self._kostka.hod())
    if zraneni > 0:
        zprava = f"{self._jmeno} utrpěl poškození {zraneni} hp."
        self._zivot = self._zivot - zraneni
        if self._zivot < 0:
            self._zivot = 0
            zprava = f"{zprava[:-1]} a zemřel."
    else:
        zprava = f"{self._jmeno} odrazil útok."
    self._nastav_zpravu(zprava)

def utoc(self, souper):
    uder = self._utok + self._kostka.hod()
    zprava = f"{self._jmeno} útočí s úderem za {uder} hp."
    self._nastav_zpravu(zprava)
    souper.bran_se(uder)

Vše si opět vyzkoušíme v main.py. Tentokrát již vytvoříme druhého bojovníka:

{PYTHON}
from kostka import Kostka
from bojovnik import Bojovnik

kostka = Kostka(10)
bojovnik = Bojovnik("Zalgoren", 100, 20, 10, kostka)
print("Život: {0}".format(bojovnik.graficky_zivot())) #test graficky_zivot()
#útok na našeho bojovníka
souper = Bojovnik("Shadow", 60, 18, 15, kostka)
souper.utoc(bojovnik)
print(souper.vrat_posledni_zpravu())
print(bojovnik.vrat_posledni_zpravu())
print("Život: {0}".format(bojovnik.graficky_zivot()))
{/PYTHON}
{PYTHON}
class Bojovnik:
    """
    Třída reprezentující bojovníka do arény.
    """

    def __init__(self, jmeno, zivot, utok, obrana, kostka):
        """
        jmeno - jméno bojovníka
        zivot - maximální život bojovníka
        utok - útok bojovníka
        obrana - obrana bojovníka
        kostka - instance kostky
        """
        self._jmeno = jmeno
        self._zivot = zivot
        self._max_zivot = zivot
        self._utok = utok
        self._obrana = obrana
        self._kostka = kostka
        self._zprava = ""

    def __str__(self):
        return str(self._jmeno)

    def je_nazivu(self):
        return self._zivot > 0

    def graficky_zivot(self):
        celkem = 20
        pocet = int(self._zivot / self._max_zivot * celkem)
        if pocet == 0 and self.je_nazivu():
            pocet = 1
        return f"[{'#' * pocet}{' ' * (celkem - pocet)}]"

    def bran_se(self, uder):
        zraneni = uder - (self._obrana + self._kostka.hod())
        if zraneni > 0:
            zprava = f"{self._jmeno} utrpěl poškození {zraneni} hp."
            self._zivot = self._zivot - zraneni
            if self._zivot < 0:
                self._zivot = 0
                zprava = f"{zprava[:-1]} a zemřel."
        else:
            zprava = f"{self._jmeno} odrazil útok."
        self._nastav_zpravu(zprava)

    def utoc(self, souper):
        uder = self._utok + self._kostka.hod()
        zprava = f"{self._jmeno} útočí s úderem za {uder} hp."
        self._nastav_zpravu(zprava)
        souper.bran_se(uder)

    def _nastav_zpravu(self, zprava):
        self._zprava = zprava

    def vrat_posledni_zpravu(self):
        return self._zprava
{/PYTHON}
{PYTHON}
class Kostka:
    """
    Třída reprezentuje hrací kostku.
    """

    def __init__(self,pocet_sten=6):
        self._pocet_sten = pocet_sten

    def vrat_pocet_sten(self):
        """
        Vrátí počet stěn kostky.
        """
        return self._pocet_sten

    def hod(self):
        """
        Vykoná hod kostkou a vrátí číslo od 1 do
        počtu stěn.
        """
        import random as _random
        return _random.randint(1, self._pocet_sten)

    def __str__(self):
        """
        Vrací textovou reprezentaci kostky.
        """
        return f"Kostka({self._pocet_sten})"
{/PYTHON}

Podívejme se na výsledek:

Shadow útočí!
Život: [####################]
Shadow útočí s úderem za 24 hp.
Zalgoren utrpěl poškození 7 hp.
Život: [##################  ]

To je k dnešní lekci vše

V další lekci, Aréna s bojovníky v Pythonu. dokončíme arénu simulující zápas dvou bojovníků.

 

Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.