Gra RPG

# zaimportuj funkcje randint oraz choice z biblioteki random
from random import randint, choice

# ----------------------- POSTAC ----------------------------

# stwórz klasę Postac
class Postac:
# niech posiada ona konstruktor z zmiennymi w klasie:
#   - nazwa
#   - życie
#   - max życie
    def __init__(self, nazwa, zycie, max_zycie):
        self.nazwa = nazwa
        self.zycie = zycie
        self.max_zycie = max_zycie


# dodaj do klasy Postac metode atakuj() przyjmujaca jako parametr przeciwnika
# niech metoda korzystając z losowania - funkcja randint(min, max) ustali siłę ataku
# w przedziale 0-3. Jeśli wylosowano 0 oznacza to że przeciwnik uniknął ataku (trzeba
# wyświetlić odpowiedni komunikat) - w przeciwnym przypadku zadajemy obrażenia i wypisujemy
# odpowieni komunikat
    def atakuj(self, przeciwnik):
        atak = randint(0,3)

        # unik
        if atak == 0:
            print(f'{przeciwnik.nazwa} unika ataku {self.nazwa}')
        else:
            print(f'{self.nazwa} atakuje {przeciwnik.nazwa}, zadając {atak} obrażeń')
            # przeciwnik.zycie = max(przeciwnik.zycie-atak, 0)
            przeciwnik.zycie -= atak
            if przeciwnik.zycie < 0:
                przeciwnik.zycie = 0




# ----------------------- PRZECIWNIK ---------------------------

# stwórz klasę Przeciwnik dziedziczącą z klasy Postac
class Przeciwnik(Postac):

# niech konstruktor przyjmuje jako argument postać gracza i losuje swoje życie w przedziale
# między 1 a aktualne życie gracza
# ponadto uruchom na początku konstruktor klasy bazowej
# nazwa przeciwnika ma być również wylosowana z określonej listy przeciwników, np.
# ['goblin', 'szkielet', 'zombie']
    def __init__(self, gracz):
        zycie = randint(1, gracz.zycie)
        nazwa = choice(['goblin', 'szkielet', 'zombie'])
        super().__init__(nazwa, zycie, zycie)



# ---------------------- GRACZ ----------------------------------

# stwórz klasę Gracz dziedziczącą z klasy Postac
class Gracz(Postac):

# konstruktor niech uruchamia na początku konstruktor klasy bazowej
# oraz niech ustala jakieś początkowe wartości max życia oraz życia
# nazwa ma być podawana przez uzytkownika z konsoli (metoda input())
    def __init__(self):
        zycie = 10
        nazwa = input('Podaj nazwę dla gracza: ')
        super().__init__(nazwa, zycie, zycie)


# stwórz metodę odpoczynek() umożliwiającą odzyskanie nieco życia (np. +1HP)
# ogranicz życie gracza do maksymalnego (jeśli odpoczynek zwiększy życie powyżej
# max zmniejszamy je do maksymalnego)
    def odpoczynek(self):
        # self.zycie = min(self.zycie+1, self.max_zycie)
        self.zycie += 1
        if self.zycie > self.max_zycie:
            self.zycie = self.max_zycie
        print(f'{self.nazwa} opoczywa, życie {self.zycie}/{self.max_zycie}')

# stwórz metodę walka() która przyjmie jako argument przeciwnika
# niech walka trwa do tak długo aż nie nastąpi jeden z warunków:
#   - gracz pokona przeciwnika
#   - gracz zginie
#   - gracz wybierze akcję ucieczki
# metoda powinna dać graczowi dwie możliwości wyboru: (atak, uciekaj)
#   - jeśli gracz wybierze akcję ucieczki tylko przeciwnik atakuje gracza
#     a następnie walka natychmiastowo się kończy
#   - jeżeli gracz wybierze akcję walki wówczas gracz najpierw atakuje przeciwnika
#     sprawdzamy czy przecwinik został pokonany - jeśli tak to walka się kończy,
#     jeśli nie - przeciwnik atakuje gracza
# Po zakończeniu jednej rundy musimy sprawdzić czy gracz przetrwał ostatni atak wroga.
# dodaj informacje o nieznanej akcji (nie 'atak' i nie 'uciekaj')
    def walka(self, przeciwnik):
        walka_trwa = True
        while walka_trwa:
            print(f'życie gracza: {self.zycie}')
            print(f'życie {przeciwnik.nazwa}: {przeciwnik.zycie}')
            akcja_walki = input('Akcja: (atak, uciekaj): ')
            if akcja_walki == 'atak':
                #kod ataku
                self.atakuj(przeciwnik)
                if przeciwnik.zycie == 0:
                    print(f'{self.nazwa} pokonuje {przeciwnik.nazwa}')
                    return True
                przeciwnik.atakuj(self)
                pass
            elif akcja_walki == 'uciekaj':
                #kod ucieczki
                print(f'Gracz {self.nazwa} próbuje uciec')
                przeciwnik.atakuj(self)
                walka_trwa = False
                pass
            else:
                print('Niepoprawna akcja')

            if self.zycie == 0:
                print(f'{self.nazwa} ginie')
                # walka zakończona porażką
                return False
        return True # ucieczka

# stwórz program testujący powyższe klasy
# stwórz obiekt Gracz
# dodaj pętlę gry
# gra toczy się tak długo aż gracz nie zginie
# dajemy graczowi do wyboru dwie akcje (zwiedzaj, odpocznij)
#   - jeśli gracz wybrał opcję 'odpocznij' uruchamiamy jego metodę odpoczynek()
#   - jeśli gracz wybrał opcję zwiedzaj losujemy jedną z dwóch opcji:
#       -> jaskinia - piszemy tylko komunikat żę gracz odnalazł jaskinię
#       -> walka - tworzymy nowego przeciwnika, informujemy o tym
#          gracza i przeprowadzamy z nim walkę
# dodaj zabezpieczenie z informacją o wyborze nieznanej opcji

gracz = Gracz()

gra_trwa = True
while gra_trwa:
    akcja_gry = input('akcja (zwiedzaj, odpocznij): ')
    if akcja_gry == 'zwiedzaj':
        # kod zwiedzania
        los = randint(0,1)
        if los == 0:
            print(f'{gracz.nazwa} zwiedza jaskinię')
        else:
            przeciwnik = Przeciwnik(gracz)
            print(f'{gracz.nazwa} trafia na {przeciwnik.nazwa}')
            gra_trwa = gracz.walka(przeciwnik)
        pass
    elif akcja_gry == 'odpocznij':
        # kod odpoczynku
        gracz.odpoczynek()
        pass
    else:
        print('Niepoprawna akcja')



# ZADANIA DODATKOWE

# ===== ZAD 1. Statystyka Szybkosc =====
#
# Dodaj do klasy Postac statystyke Szybkosc
# ustaw ja w klasie gracza
# klasa Przeciwnika ma losowac swoją Szybkosc
# - niech bedzie w przedziale od 50% do 150% szybkosci gracza
# szybkosc decyduje kto pierwszy zaatakuje w danej rundzie podczas walki
# pierwsza atakuje postac z wieksza szybkoscia
# w przypadku remisu w kazdej rundzie bedzie losowane kto pierwszy zaatakuje
# szybkosc ma rowniez wplyw na ucieczke - jesli Gracz ma wieksza szybkosc niz Przeciwnik
# ma szanse uciec bez obrazen. Szansa w% wynosi (1-szybkosc_przeciwnika/szybkosc_gracza)*100
# (czyli tyle ile procentowo gracz ma wiecej szybkosci od przeciwnika).



# ===== ZAD 2. Klasa Lochy =====
#
# Zamień konstruktor Przeciwnika aby przyjmował swoją nazwę jako argument.
#
# Stwórz klasę Loch (Dungeon)
#
# Niech w konstruktorze będzie przekazywana w parametrze nazwa
# oraz lista nazw przyciwników, których możemy spotkać w danym lochu.
#
# Dodaj metodę zwiedzaj(), która będzie zwiedzała dany loch. Jeśli loch nie ma
# żadnego przeciwnika (lista jest pusta do spotkania niech wyświetla się
# informacja o zwiedzaniu lochu.
# Jeśli występują jacyś przeciwnicy, mamy wylosować nazwę jednego z nich,
# stworzyć obiekt Przeciwnik z wybraną nazwą oraz zawalczyć z nim.
#
# W programie testowym dodaj liste lochow i przypisz im kilkoro przeciwników.
# Niektore lochy moga okazać się puste (nie mają przeciwników - tak jak wcześniej jaskinia).
# W glownej petli programu zamien akcje zwiedzania tak aby korzystala z listy dostepnych
# lochow niech korzysta ona z metody zwiedzaj wybranego losowo z listy Lochu.



# ===== ZAD 3. Zloto/loot z mobów =====
#
# Dodaj do klasy Postac zmienna Zloto (Gold).
# Niech w klasie przeciwnika bedzie ono oznaczalo liczbe zlota do zdobycia po jego pokonaniu
# - niech wartość złota Przeciwnika będzie losowana w jego konstruktorze - niech będzie
# proporcjonalne do życia przeciwnika.
# W klasie Gracz niech zmienna Zloto oznacza ile gracz ma obecnie złota. Liczba zlota będzie
# zwiększana po pokonaniu przeciwnika o tyle ile przeciwnik miał
# ustawione w swojej zmiennej Zloto.
#
# W glownym programie podczas dopoczynku możliwość wyboru odpoczynku w stajni na sianie (darmowe)
# który odnawia +1HP oraz pokoju dla VIP-ów, który odnawia całe życie i kosztuje 50 sztuk złota.


# ===== ZAD 4. Akcja sklepu =====
# Dodaj do akcji w grze (poza odpoczynkiem i zwiedzaniem) odwiedzenia sklepu.
# Niech sklep oferuje Pióro Feniksa (niech będzie to zmienna bool - True/False, w klasie
# Gracza) która będzie służyła jako pojedyncze odrodzenie w przypadku przegranej walki.
# Jeśli gracz zginie posiadając pióro Feniksa, gra nie kończy się ale gracz trafia do "miasta"
# (walka po prostu się kończy) a gracz przeżywa z 1HP.
# Niech sklep oferuje także Miksturę lecznia - niech gracz może nosić przy sobie do
# max 3 fiolek mistury leczenia (pole do dodania w klasie Gracz). Niech mikstura leczy
# 30% życia gracza i będzie dodatkową opcją w czasie walki (poza ucieczką lub walką).
# Pióro Feniksa niech kosztuje 100sztuk złota, a mistury leczenia po 15 sztuk złota każda.