#include "pch.h"
#include <iostream>
#include <string>
#include <cstdlib>
#include <conio.h>
#include <stdlib.h>
#include <ctime>

using namespace std;
int punkty = 1;
string ranga = "DUPA";

namespace kontrola_rozgrywki
{
	struct dane
	{
		int const liczba_tur = 5;
		int const odleglosc = 25;
	};
}

//------------------------------------------------Zmienne----------------------------------------------------//
int si = 1;

//-------------------------------------------------Klasy-----------------------------------------------------//

class umieranie {
	string const wiadomosc1 = "-------------------------------------------PORAZKA-------------------------------------------------";
	string const wiadomosc2 = "Niestety, udalo Ci sie dotrzec do oprawcow, jednak Twoja postać nie byla wystarczajaco";
	string const wiadomosc3 = "dobrze przygotowana i polegla zanim dotarla do wrogiego wodza.";
	string const wiadomosc4 = "Niestety, trucizna okazala sie szybsza... Twoja postać dreczona przez bardzo wysoka goraczka, umiera w mekach...";
public:
	string wypisz1() { return wiadomosc1; }
	string wypisz2() { return wiadomosc2; }
	string wypisz3() { return wiadomosc3; }
	string wypisz4() { return wiadomosc4; }

};

class obsluga {
	static umieranie* a;
public:
	static string wyslij1() { return a->wypisz1(); }
	static string wyslij2() { return a->wypisz2(); }
	static string wyslij3() { return a->wypisz3(); }
	static string wyslij4() { return a->wypisz4(); }
	static void stworz() { a = new umieranie; }
	static void usun() { delete a; }
};

class Player
{

	string name;
	string nick;
public:
	string getName()
	{

		return name;

	}

	string getNick()
	{
		return nick;
	}
	void changeName(string new_name) {
		name = new_name;
	}
	friend istream& operator>>(istream& in, Player*& B)
	{
		cout << "Wprowadz swoje imie: " << endl;
		in >> B->name;
		cout << "Wprowadz swoj pseudonim: " << endl;
		in >> B->nick;
		return in;

	}

};


class bohater {
	friend class Wynik;
	class Wynik
	{
		friend class bohater;

	public:
		int pkt;
		string ran;
		Wynik() :pkt(1), ran("") {}

		friend ostream& operator<<(ostream& out, Wynik& other)       //<<<>>>><<<>>..//
		{
			other.pkt = punkty;
			other.ran = ranga;
			out << "TWOJA RANGA: " << other.ran << endl << "TWOJE PUNKTY: " << other.pkt;

			return out;
		}
	};
	Wynik* wynik = new Wynik;
public:
	int punkty_wytrzymalosci;
	int punkty_many;
	int punkty_akcji;
	int zadawane_obrazenia;
	friend class Wynik;

	void stworz_postac()
	{
		punkty_wytrzymalosci = 100;
		punkty_many = 100;
		punkty_akcji = 100;
		zadawane_obrazenia = 25;
	}

	Wynik* getWynik();

	static Player* player;

	static string zwroc() { return player->getName(); }

	static void stworz() { player = new Player; }

	static void usun() { delete player; }
};




bohater::Wynik* bohater::getWynik()
{
	return wynik;
}

class ekwipunek {
public:
	bool helm;
	bool zbroja;
	bool olej_na_miecz;
	bool buty;
	int jedzenie;
	int mikstura_many;
	int zloto;

	void stworz_plecak()
	{
		helm = false;
		zbroja = false;
		olej_na_miecz = false;
		buty = false;
		jedzenie = 0;
		mikstura_many = 0;
		zloto = 30;
	}

};

class czyczar {
public:
	bool kula_ognia;
	bool blyskawica;
	bool regeneracja_wytrzymalosci;

	void stworz_liste()
	{
		kula_ognia = false;
		blyskawica = false;
		regeneracja_wytrzymalosci = false;
	}
};


class skills {
public:

	string nazwa;
	int cena;
	int obrazenia;
	int punkty_wtrzymalosci;
	int punkty_many;

	skills(string n, int c, int o, int pw = 0, int pm = 0) :nazwa(n), cena(c), obrazenia(o), punkty_wtrzymalosci(pw), punkty_many(pm)
	{
	}
	string getNazwa() {
		return nazwa;
	}
	int getCena() {
		return cena;
	}
	int getObrazenia() {
		return obrazenia;
	}
	int getPW() {
		return punkty_wtrzymalosci;
	}
	int getPM() {
		return punkty_many;
	}
};


class pojemnik {
	skills* s;
	int ilosc;
public:
	pojemnik() :s(NULL) {}
	skills* getSkill() {
		return s;
	}
	void changeSkill(skills* sk) {
		s = sk;
	}
};

void stworz(pojemnik**& pudelko, int& size, skills& sk) {
	pudelko = new pojemnik *[size];
	for (auto i = 0; i < size; i++) {
		pudelko[i] = new pojemnik;
		pudelko[i]->changeSkill(&sk);
	}
}
void usun(pojemnik**& pudelko) {
	delete[] pudelko;
	pudelko = nullptr;
}
void zwieksz(pojemnik**& pudelko, int& size, skills& sk) {
	pojemnik** pomoc;
	stworz(pomoc, size, sk);
	for (auto i = 0; i < size; i++)
	{
		pomoc[i] = pudelko[i];
	}
	usun(pudelko);
	size++;
	stworz(pudelko, size, sk);
	size--;
	for (auto i = 0; i < size; i++)
	{
		pudelko[i] = pomoc[i];
	}
	usun(pomoc);
	size++;

}

void zmniejsz(pojemnik**& pudelko, int& size, skills& sk) {
	pojemnik** tmp = new pojemnik *[size];
	for (auto i = 0; i < size; i++)
	{
		tmp[i] = new pojemnik;
		tmp[i] = pudelko[i];
	}
	usun(pudelko);
	size--;
	stworz(pudelko, size, sk);

	for (auto i = 0; i < size; i++)
		pudelko[i] = tmp[i];
	usun(tmp);

}
void wyswietl(pojemnik * *&pudelko, int& size)
{
	for (auto i = 0; i < size; i++) {
		cout << "  []" << i + 1 << ". " << pudelko[i]->getSkill()->getNazwa() << "[]  ";
	}
}
void dodajPunkty(pojemnik * &pudelko, bohater & b)
{
	b.zadawane_obrazenia += pudelko->getSkill()->getObrazenia();
}


class bandyta {
public:
	string const nazwa;
	int const punkty_wytrzymalosci;
	int const zadawane_obrazenia;

	bandyta() :nazwa("bandyta"), punkty_wytrzymalosci(30), zadawane_obrazenia(20)
	{
	}

};


class Nekromanci {
	int zycie;
	mutable int ilosc_nieumarlych;
	mutable int obrazenia;

	class Nieumarli {
		int n_zycie;
		const int n_obrazenia;
	public:
		Nieumarli() = default;
		Nieumarli(int z, int o) :n_zycie(z), n_obrazenia(o) {}
		friend class Nekromanci;

	};
	Nieumarli** nieum;
public:
	friend class Bohater;
	Nekromanci(int z, int in, int o) :zycie(z), ilosc_nieumarlych(in), obrazenia(o)
	{
		nieum = new Nieumarli *[ilosc_nieumarlych];
		for (auto i = 0; i < ilosc_nieumarlych; i++)
		{
			nieum[i] = new Nieumarli(5, 3);
		}
	}
	Nekromanci(const Nekromanci& inny) {
		zycie = inny.zycie;
		ilosc_nieumarlych = inny.ilosc_nieumarlych;
		obrazenia = inny.obrazenia;

		nieum = new Nieumarli *[ilosc_nieumarlych];
		for (auto i = 0; i < ilosc_nieumarlych; i++)
		{
			nieum[i] = new Nieumarli(5, 3);

		}

	}


	Nekromanci& operator=(const Nekromanci&inny)   //<<<>>><<>>//
	{
		if (&inny != this)
		{


			this->zycie = inny.zycie;
			this->ilosc_nieumarlych = inny.ilosc_nieumarlych;
			this->obrazenia = inny.obrazenia;

			this->nieum = new Nieumarli *[ilosc_nieumarlych];
			for (auto i = 0; i < ilosc_nieumarlych; i++)
			{
				nieum[i] = new Nieumarli(5, 3);
	}

			return *this;
		}
	}

	~Nekromanci() {
		delete[] nieum;
		nieum = nullptr;
	}
	int atak() {
		return obrazenia + ilosc_nieumarlych * nieum[0]->n_obrazenia;
	}
};

umieranie* obsluga::a;

void koniec_rozgrywki1()
{
	obsluga::stworz();
	cout << obsluga::wyslij1() << endl;
	cout << obsluga::wyslij2() << endl;
	cout << obsluga::wyslij3() << endl;
	cout << obsluga::wyslij1() << endl;
	obsluga::usun();
}

void koniec_rozgrywki2()
{
	obsluga::stworz();
	cout << obsluga::wyslij1() << endl;
	cout << obsluga::wyslij4() << endl;
	cout << obsluga::wyslij1() << endl;
	obsluga::usun();
}

//-------------------------------------------------Systemy losowe----------------------------------------------//

int losowa_kostka()
{
	srand(int(time(NULL)));
	int los = ((rand() % 6) + 1);
	return los;
}

int losowa_liczba()
{
	srand(int(time(NULL)));
	int los = ((rand() % 10) + 1);
	return los;
}

int magiczna_kostka()
{
	srand(int(time(NULL)));
	int los = ((rand() % 3) + 4);
	return los;
}


//------------------------------------Przeladowanie funkcji----------------------------------------------//

int dodawanie(int a, int b, int c)
{
	return a + b + c;
}

int dodawanie(int a, int b)
{
	return a + b;
}

//------------------------------------zmiana rozmiaru tablicy----------------------------------------------//

void dodaj(int& ilosc_graczy, int*& gracze)
{
	int* temp;
	temp = new int[ilosc_graczy + 1];
	for (int i = 0; i < ilosc_graczy; i++)
	{
		temp[i] = gracze[i];
	}
	delete[] gracze;
	gracze = new int[ilosc_graczy + 1];
	for (int i = 0; i < ilosc_graczy; i++)
	{
		gracze[i] = temp[i];
	}
	ilosc_graczy++;
	delete[] temp;
}

//------------------------------------Funckje do zdarzeń losowych----------------------------------------------//

void otwieranie_skrzynki(bohater & postac, ekwipunek & plecak, czyczar & zaklecia)
{
	int liczba = losowa_liczba();
	switch (liczba)
	{
	case 1:
		if (plecak.helm == false)
		{
			cout << "Znalazles helm - otrzymujesz dodatkowe punkty wytrzymalosci" << endl;
			postac.punkty_wytrzymalosci = postac.punkty_wytrzymalosci + 20;
			plecak.helm = true;
			break;
		}
		else
		{
			cout << "Znalazles helm - jako, iĹĽ posiadasz juĹĽ ten przedmiot, sprzedajesz go" << endl;
			plecak.zloto = plecak.zloto + 15;
			break;
		}
	case 2:
		if (plecak.zbroja == false)
		{
			cout << "Znalazles zbroje - otrzymujesz dodatkowe punkty wytrzymalosci" << endl;
			postac.punkty_wytrzymalosci = postac.punkty_wytrzymalosci + 40;
			plecak.zbroja = true;
			break;
		}
		else
		{
			cout << "Znalazles zbroje - jako, iĹĽ posiadasz juĹĽ ten przedmiot, sprzedajesz go" << endl;
			plecak.zloto = plecak.zloto + 25;
			break;
		}
	case 3:
		if (plecak.olej_na_miecz == false)
		{
			cout << "Znalazles olej na miecz - ilosc zadawanych obrazen wzrosla" << endl;
			postac.zadawane_obrazenia = postac.zadawane_obrazenia + 15;
			plecak.olej_na_miecz = true;
			break;
		}
		else
		{
			cout << "Znalazles olej na miecz - jako, iĹĽ posiadasz juĹĽ ten przedmiot, sprzedajesz go" << endl;
			plecak.zloto = plecak.zloto + 10;
			break;
		}
	case 4:
		if (plecak.buty == false)
		{
			cout << "Znalazles buty - od nastepnej tury otrzymujesz dodatkowe punkty akcji" << endl;
			postac.punkty_akcji = postac.punkty_akcji + 20;
			plecak.buty = true;
			break;
		}
		else
		{
			cout << "Znalazles buty - jako, iĹĽ posiadasz juĹĽ ten przedmiot, sprzedajesz go" << endl;
			plecak.zloto = plecak.zloto + 10;
			break;
		}
	case 5:
		cout << "Znalazles porcje jedzenia - wzrastaja punkty wytrzymalosci" << endl;
		plecak.jedzenie = plecak.jedzenie + 1;
		postac.punkty_wytrzymalosci = postac.punkty_wytrzymalosci + 20;
		break;
	case 6:
		cout << "Znalazles miksture many" << endl;
		plecak.mikstura_many = plecak.mikstura_many + 1;
		postac.punkty_many = postac.punkty_many + 30;
		break;
	case 7:
		if (zaklecia.kula_ognia == false)
		{
			cout << "Znalazles zwoj z czarem 'kula ognia' - wzrastaja zadawane obrazenia i mana " << endl;
			zaklecia.kula_ognia = true;
			postac.punkty_many = postac.punkty_many + 15;
			postac.zadawane_obrazenia = postac.zadawane_obrazenia + 30;
			break;
		}
		else
		{
			cout << "Znalazles zwoj z czarem 'kula ognia' - jako, iĹĽ posiadasz juĹĽ ten przedmiot, sprzedajesz go" << endl;
			plecak.zloto = plecak.zloto + 15;
			break;
		}
	case 8:
		if (zaklecia.regeneracja_wytrzymalosci == false)
		{
			cout << "Znalazles zwoj z czarem 'regeneracja zycia' - mozna go uzyc jesli zostaniesz pokonany w walce " << endl;
			zaklecia.regeneracja_wytrzymalosci = true;
			break;
		}
		else
		{
			cout << "Znalazles zwoj z czarem 'regeneracja zycia' - jako, iĹĽ posiadasz juĹĽ ten przedmiot, sprzedajesz go" << endl;
			plecak.zloto = plecak.zloto + 15;
			break;
		}
	case 9:
		if (zaklecia.blyskawica == false)
		{
			cout << "Znalazles zwoj z czarem 'blyskawica' - wzrastaja zadawane obrazenia " << endl;
			zaklecia.blyskawica = true;
			postac.zadawane_obrazenia = postac.zadawane_obrazenia + 30;
			break;
		}
		else
		{
			cout << "Znalazles zwoj z czarem 'blyskawica' - jako, iĹĽ posiadasz juĹĽ ten przedmiot, sprzedajesz go" << endl;
			plecak.zloto = plecak.zloto + 15;
			break;
		}
	case 10:
		cout << "Znalazles 30 sztuk zlota - mozesz za nie kupic przydatne przedmioty gdy napotkasz kupca" << endl;
		plecak.zloto = plecak.zloto + 30;
		break;
	default:
		cout << "blad w losowaniu liczby(zly przedzial)" << endl;
		break;
	}
}

void handel(bohater & postac, ekwipunek & plecak, czyczar & zaklecia)
{
	bool petla = false;
	while (petla == false)
	{
		int wybor = 0;
		cout << "Witaj jesli posiadasz wystarczajaco duzo zlota, mozesz kupic u mnie przydatny przedmiot" << endl;
		cout << "1-buty, 30 sztuk zlota (wieksza ilosc punktow akcji podczas rundy)" << endl;
		cout << "2-olej na miecz, 20 sztuk zlota (zwiekszona ilosc obrazen)" << endl;
		cout << "3-jedzenie, 10 sztuk zlota (wieksza ilosc punktow wytrzymalosci)" << endl;
		cout << "4-koniec handlu" << endl;
		cin >> wybor;
		switch (wybor)
		{
		case 1:
			if ((plecak.buty == false) && (plecak.zloto >= 30))
			{
				cout << "kupiles buty - od nastepnej tury otrzymujesz dodatkowe punkty akcji" << endl;
				cout << endl;
				postac.punkty_akcji = postac.punkty_akcji + 20;
				plecak.zloto = plecak.zloto - 30;
				plecak.buty = true;
				break;
			}
			else
			{
				cout << "Posiadasz juz buty lub nie posiadasz wystarczajaco duzo zlota by je zakupic" << endl;
				cout << endl;
				break;
			}
			break;

		case 2:
			if ((plecak.olej_na_miecz == false) && (plecak.zloto >= 20))
			{
				cout << "Kupiles olej na miecz - ilosc zadawanych obrazen wzrosla" << endl;
				cout << endl;
				postac.zadawane_obrazenia = postac.zadawane_obrazenia + 15;
				plecak.olej_na_miecz = true;
				plecak.zloto = plecak.zloto - 20;
				break;
			}
			else
			{
				cout << "Posiadasz juz olej lub nie posiadasz wystarczajaco duzo zlota by go zakupic" << endl;
				cout << endl;
				break;
			}
			break;

		case 3:
			if (plecak.zloto >= 10)
			{
				cout << "Znalazles porcje jedzenia - wzrastaja punkty wytrzymalosci" << endl;
				cout << endl;
				plecak.jedzenie = plecak.jedzenie + 1;
				postac.punkty_wytrzymalosci = postac.punkty_wytrzymalosci + 20;
				break;
			}
			else
			{
				cout << "Nie posiadasz wystarczajaco duzo zlota by zakupic przedmiot" << endl;
				cout << endl;
				break;
			}
			break;

		case 4:
			petla = true;
			break;

		default:
			cout << "Podana zostala zla liczba" << endl;
			break;
		}
	}
}

int student()
{
	int a, b, c;
	cout << "Pierwsza liczba to 19 i musisz podac dwie liczby," << endl << "ktorych suma jest rowna wlasnie tyle" << endl;
	cin >> a;
	cin >> b;
	if (dodawanie(a, b) == 19)
	{
		cout << "Udalo Ci sie dobrze podac pierwsza sume" << endl;
	}
	else
	{
		cout << "Suma podanych liczb wynosila " << dodawanie(a, b) << " a nie 19" << endl;
		cout << "Niestety nie pokonales wyzwania, nic nie tracisz, ale tez nic nie zyskujesz" << endl;
		return 0;
	}
	cout << "Druga liczba to 34 i musisz podac trzy liczby," << endl << "ktorych suma jest rowna wlasnie tyle" << endl;
	cin >> a;
	cin >> b;
	cin >> c;
	if (dodawanie(a, b, c) == 34)
	{
		cout << "Udalo Ci sie dobrze podac druga sume, wygrales miksture many" << endl;
		return 1;
	}
	else
	{
		cout << "Suma podanych liczb wynosila " << dodawanie(a, b, c) << " a nie 34" << endl;
		cout << "Niestety nie pokonales wyzwania, nic nie tracisz, ale tez nic nie zyskujesz" << endl;
		return 0;
	}
}


int turniej_w_kosci(int ilosc_graczy)
{
	cout << endl << endl << "NOWA RUNDA" << endl;
	int* gracze;
	gracze = new int[ilosc_graczy];

	int twoj_rzut = 0;
	int los = ((rand() % 3) + 4);
	twoj_rzut = los;
	cout << "Twoj wynik = " << twoj_rzut << endl;
	cout << "Podchodzi dodatkowa osoba i pyta sie czy moze do was dolaczyc" << endl;
	bool kolejnapetla = false;
	while (kolejnapetla == false)
	{
		int pytanie = 0;
		cout << "Zgadzasz sie?" << endl;
		cout << "1. Tak" << endl;
		cout << "2. Nie" << endl << endl;
		cin >> pytanie;
		if (pytanie == 1)
		{
			dodaj(ilosc_graczy, gracze);
			kolejnapetla = true;
		}
		if (pytanie == 2)
		{
			kolejnapetla = true;
		}
		if ((pytanie != 1) && (pytanie != 2))
		{
			cout << "Zla liczba - musisz wybrac miedzy opcja numer 1 i 2" << endl;
			kolejnapetla = false;
		}
	}
	for (int i = 0; i < ilosc_graczy; i++)
	{
		gracze[i] = ((rand() % 6) + 1);
		cout << "Wynik przeciwnika" << " = " << gracze[i] << endl;
	}


	int maks = twoj_rzut;
	int licznik = 0;
	for (int i = 0; i < ilosc_graczy; i++)
	{
		if (gracze[i] > maks)
		{
			maks = gracze[i];
		}
	}

	if (maks == twoj_rzut)
	{
		for (int i = 0; i < ilosc_graczy; i++)
		{
			if (maks == gracze[i])
			{
				licznik++;
			}
		}
		if (licznik == 0)
		{
			delete[] gracze;
			return ilosc_graczy;
		}
		else
		{
			cout << "Dobrze poszlo!" << endl << "Jednak " << licznik << " graczy mialo taka sama ilosc oczek co Ty!" << endl;
			cout << "Przechodzicie do nastepnej rundy" << endl;
			delete[] gracze;
			turniej_w_kosci(licznik);
		}
	}
	else
	{
		delete[] gracze;
		cout << "przykro mi - przegrales" << endl;
		return 0;
	}
}

void walka_bandyta(bohater & postac, ekwipunek & plecak, czyczar & zaklecia)
{
	bandyta b1;
	if (b1.punkty_wytrzymalosci > postac.zadawane_obrazenia)
	{
		cout << "Udaje Ci sie pokonac przeciwnika, jednak poniewaz twoje obrazenia sa mniejsze od jego zdrowia," << endl << "zostajesz ranny (-20 punktow wytrzymalosci)" << endl;
		postac.punkty_wytrzymalosci = postac.punkty_wytrzymalosci - b1.zadawane_obrazenia;
	}
	else
	{
		cout << "Udaje Ci sie pokonac przeciwnika bez odniesienia zadnych ran" << endl;
	}

}

//-------------------------------------------------Zdarzenia losowe--------------------------------------------//

int losowe_zdarzenie()
{

	bool petla = true;
	int wybor;
	int liczba = losowa_liczba();
	//liczba=6;
	switch (liczba)
	{
	case 1:
		cout << "ZNALAZLES NIESTRZEZONA SKRZYNIE" << endl;
		while (petla == true)
		{
			cout << "Zdecyduj co chcesz zrobic!" << endl;
			cout << "Wybierz: 1-otworz - 10 punktow akcji" << endl;
			cout << "wybierz: 2-nic nie rob" << endl;
			cin >> wybor;
			if (wybor == 1)
			{
				petla = false;
				return 1;
			}
			if (wybor == 2)
			{
				petla = false;
			}
			if ((wybor != 1) && (wybor != 2))
			{
				cout << "Zla liczba - musisz wybrac miedzy opcja numer 1 i 2";
			}
		}
		return 0;


	case 2:
		cout << "SPOTKALES WEDROWNEGO KUPCA" << endl;
		while (petla == true)
		{
			cout << "Zdecyduj co chcesz zrobic!" << endl;
			cout << "Wybierz: 1-zacznij handlowac " << endl;
			cout << "wybierz: 2-odejdz" << endl;
			cin >> wybor;
			if (wybor == 1)
			{
				petla = false;
				return 2;
			}
			if (wybor == 2)
			{
				petla = false;
			}
			if ((wybor != 1) && (wybor != 2))
			{
				cout << "Zla liczba - musisz wybrac miedzy opcja numer 1 i 2";
			}
		}
		return 0;

	case 3:
		cout << "SPOTYKASZ STUDENTA, KTORY RZUCA CI WYZWANIE MATEMATYCZNE" << endl;
		cout << "Wyzwanie polega na tym, iz poda on jakas liczbe calkowita" << endl;
		cout << "a Ty musisz napisac mu dwie lub trzy liczby ktorych suma jest rowna jego liczbie" << endl;
		cout << "Jesli uda Ci sie podolac wyzwaniu otrzymasz od niego miksture many" << endl;
		return 3;

	case 4:
		cout << "TURNIEJ W KOSCI" << endl;
		cout << endl;
		cout << "Trafiles do karczmy, szukajac rozrywki wpadasz na pomysl zorganizowania turnieju w kosci." << endl;
		cout << "Sam decydujesz z iloma przeciwnikami chcesz sie zmierzyc." << endl;
		cout << "Im wiecej przeciwnikow, tym wieksze prawdopodobienstwo porazki, ale tez szansa na wieksza wygrana!" << endl;
		cout << "Kazdy gracz wplaca po 10 sztuk zlota wejsciowego." << endl;
		cout << "Wygrywa osoba ktora wyrzuci najwieksza liczbe oczek na kostce." << endl;
		cout << "Jesli dwoch lub wiecej graczy, bedzie mialo taki sam wynik, wtedy obaj przechodza" << endl;
		cout << "do nastepnej rundy, az do momentu gdy ktorys bedzie mial wiecej szczescia" << endl;
		cout << "Aha! Warto tez dodac, ze nasza bohaterka ma magiczna kosc, dzieki ktorej wyrzuca tylko 4,5 i 6 ;)" << endl << endl;
		return 4;

	case 5:
		cout << "Spotkales bandyte!" << endl << "Mozesz stanac z nim do walki, albo zaplacic mu 30 sztuk zlota i odejsc" << endl;
		while (petla == true)
		{
			cout << "Zdecyduj co chcesz zrobic!" << endl;
			cout << "1. Walka" << endl;
			cout << "2. Zaplac" << endl;
			cin >> wybor;
			if (wybor == 1)
			{
				petla = false;
				return 5;
			}
			if (wybor == 2)
			{
				petla = false;
				return 6;
			}
			if ((wybor != 1) && (wybor != 2))
			{
				cout << "Zla liczba - musisz wybrac miedzy opcja numer 1 i 2";
			}
		}
		return 0;

	case 6:
		cout << "POMOGLES KUPCOWI" << endl;
		cout << "W ramach podziekowania oddaje Ci on za darmo pusta ksiege" << endl;
		return 7;

	case 7:
		cout << "7" << endl;
		return 0;

	case 8:
		cout << "8" << endl;
		return 0;

	case 9:
		cout << "9" << endl;
		return 0;

	case 10:
		cout << "10" << endl;
		return 0;

	}
}

//-------------------------------------------------Funckja main----------------------------------------------//

Player* bohater::player;
int main()
{
	bohater::stworz();
	cin >> bohater::player;

	bohater maciej;
	system("CLS");
	cout << "WITAJ: ";

	cout << bohater::zwroc() << endl;
	cout << *maciej.getWynik() << endl; // zrobiłem ci jakeigoś bohatera macieja i jego wynik i lv ci to będzie wyswietlało
	// to przykładowo że np zdobywa jakies punkty i jakiś lv ma i wyswietla ci to
	//punkty możesz za cos tam dodać


	skills brak("BRAK", 99999, 0);
	skills kula_ognia("kula ognia", 20, 30);
	skills blyskawica("blyskawica", 10, 25);
	skills regeneracja_wytrzymalosci("regeneracja wytrzymalosci", 30, 0, 20);

	Nekromanci nek1(100, 5, 2);
	Nekromanci nek2=nek1; //PRZECIĄŻENIE =





	pojemnik** p;
	stworz(p, si, brak);
	p[0]->changeSkill(&kula_ognia);
	/*wyswietl(p, si);
	cout << endl;
	zwieksz(p, si, brak);
	wyswietl(p, si);
	cout << endl;
	zmniejsz(p, si, brak);
	wyswietl(p, si);
	cout << endl;
	zwieksz(p, si, brak);
	wyswietl(p, si);
	cout << endl;
	zwieksz(p, si, brak);
	wyswietl(p, si);
	cout << endl;
	zwieksz(p, si, brak);
	wyswietl(p, si);
	cout << endl;*/


	bohater postac;
	postac.stworz_postac();



	/*string name;
	name = postac.getName();
	cout << name << endl;

	cout << "Podaj name swojej bohaterki" << endl;
	cin >> name;
	postac.changeName(name);

	cout << name << endl;*/

	srand(int(time(NULL)));
	//-------------------------------------------Wprowadzenie------------------------------------------------//
	cout << "|___WITAJ W GRZE___XXXXX____!|" << endl;
	cout << "Przejmiesz wkrotce kontrole nad swoja postacja" << endl;
	cout << "Wcielisz sie w 16 letnia dziewczyne, ktorej cala wioska zostala najechana i spalona" << endl;
	cout << "przez zamaskowanych oprawcow. Jestes jedyna osoba, ktorej udalo sie wyjsc z tego calo" << endl;
	cout << "jednak nasza bohaterka zostala zraniona zatruta strzala" << endl;
	cout << "zeby wiedziec co za toksyna wyniszcza jej organizm, musi wycignac ta informacje od zamaskowanych oprawcow," << endl;
	cout << "wiec nie liczac roznych przeciwnosci losu, bedziesz musial dodatkowo walczyc z czasem." << endl;
	cout << "Aby pomscic najblizszych i uratowac swoje zycie" << endl;
	cout << endl;
	cout << "Zeby wygrac rozgrywke uzbieraj wymagana ilosc punktow wytrzymalosci,zadawanych obrazen i punktow many" << endl;
	cout << "a nastepnie dotrzyj do przeciwnikow zanim trucizna doprowadzi Cie do smierci." << endl;;
	system("PAUSE");
	cout << endl;

	ekwipunek plecak;
	plecak.stworz_plecak();

	czyczar zaklecia;
	zaklecia.stworz_liste();
	zaklecia.kula_ognia = true;
	//---------------------------------------------Rozgrywka-----------------------------------------------//
	bool koniec_gry = false;
	int pokonany_dystans = 0;
	int ubyte_tury = 0;
	//int liczba_tur = 5;
	while (koniec_gry == false)
	{
		bool koniec_tury = false;
		postac.punkty_akcji = 100;
		while ((postac.punkty_akcji >= 10) && (koniec_tury == false))
		{
			int akcja = 0;
			cout << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << endl;
			cout << "Statystyki postaci:   " << "                       ";
			cout << "Zawartosc plecaka:" << "            " << "Umiejetnosci specjalne:" << endl;
			cout << "punkty wytrzymalosci = " << postac.punkty_wytrzymalosci << "/200               ";
			cout << "zbroja = " << plecak.zbroja << "                    ";
			cout << "kula ognia = " << zaklecia.kula_ognia << endl;
			cout << "punkty many = " << postac.punkty_many << "/150                        ";
			cout << "helm = " << plecak.helm << "                      ";
			cout << "regeneracja wytrzymalosci = " << zaklecia.regeneracja_wytrzymalosci << endl;
			cout << "zadawane obrazenia = " << postac.zadawane_obrazenia << "/100                  ";
			cout << "buty = " << plecak.buty << "                      ";
			cout << "blyskawica = " << zaklecia.blyskawica << endl;
			cout << "                                 " << "            ";
			cout << "jedzenie= " << plecak.jedzenie << endl;
			cout << "                                             mikstury many = " << plecak.mikstura_many << endl;
			cout << "                                             zloto = " << plecak.zloto << endl << endl;
			cout << "Ksiegi z zakleciami, pozwalaja nam one nauczyc sie nowych zaklec, jesli ktoras z nich jest wolna" << endl;
			wyswietl(p, si);
			cout << endl;
			int dystans = 25;
			int liczba_tur = 5;
			cout << endl;
			cout << "Pozostaly dystans do spotkania z oprawcami (skracac mozna za pomoca kostki przemieszczania sie) = " << dystans - pokonany_dystans << endl;
			cout << "Pozostala ilosc tur do smierci na wskutek dzialania trucizny = " << liczba_tur - ubyte_tury << endl;
			cout << "Pozostale punkty akcji w turze = " << postac.punkty_akcji << endl << endl;
			cout << "Akcje (wpisz odpowiadajacy numer):" << endl;
			cout << "1. Kulaj kostka losowych zdarzen (-10 punktow akcji)" << endl;
			cout << "2. Kulaj kostka przemieszczania sie(-20 punktow akcji)" << endl;
			cout << "3. Zrezygnuj z podejmowania jakichkolwiek akcji i zakoncz ture (punkty akcji nie sumuja sie po zakonczeniu tury)" << endl;
			cin >> akcja;
			bool ilosc_akcji = false;
			while (ilosc_akcji == false)
			{
				//---------------------------------------------------------Akcja1-------------------------------------------------------//
				if (akcja == 1)
				{
					if (postac.punkty_akcji >= 10)
					{
						int losowe;
						postac.punkty_akcji = postac.punkty_akcji - 10;
						losowe = losowe_zdarzenie();
						{
							switch (losowe)
							{
							case 1:
								otwieranie_skrzynki(postac, plecak, zaklecia);
								break;

							case 2:
								handel(postac, plecak, zaklecia);
								break;

							case 3:
								int rezultat;
								rezultat = student();
								if (rezultat == 1)
								{
									plecak.mikstura_many = plecak.mikstura_many + 1;
									postac.punkty_many = postac.punkty_many + 30;
								}
								break;

							case 4:
							{
								bool czyzagrac = false;

								if (plecak.zloto >= 10)
								{
									while ((czyzagrac == false) && (plecak.zloto >= 10))
									{
										int ilosc_graczy = 0;
										int wygrana = 0;
										cout << "Ilu graczy chcesz zaprosic do turnieju?" << endl;
										cin >> ilosc_graczy;
										wygrana = turniej_w_kosci(ilosc_graczy);
										if (wygrana == 0)
										{
											plecak.zloto = plecak.zloto - 10;
											cout << "Straciles 10 sztuk zlota" << endl;
										}
										else
										{
											int dodosoby;
											cout << "Ile dodatkowych osob dolaczylo do Ciebie podczas gry? (podaj liczbe)" << endl;
											cin >> dodosoby;
											cout << "Wygrales!" << endl << "Zarobiles " << (10 * ilosc_graczy) + (10 * dodosoby) << " sztuk zlota!" << endl << endl;
											plecak.zloto = plecak.zloto + (10 * ilosc_graczy);
										}
										bool kolejnapetla = false;
										while (kolejnapetla == false)
										{
											int pytanie = 0;
											cout << "Czy chcesz zagrac ponownie?" << endl;
											cout << "1. Tak" << endl;
											cout << "2. Nie" << endl << endl;
											cin >> pytanie;
											if (pytanie == 1)
											{
												czyzagrac = false;
												kolejnapetla = true;
											}
											if (pytanie == 2)
											{
												czyzagrac = true;
												kolejnapetla = true;
											}
											if ((pytanie != 1) && (pytanie != 2))
											{
												cout << "Zla liczba - musisz wybrac miedzy opcja numer 1 i 2" << endl;
												kolejnapetla = false;
											}
										}
									}
								}
								if (plecak.zloto < 10)
								{
									cout << "Nie posiadasz wystarczajaco zlota zeby postawic zaklad" << endl;
								}
							}
							break;
							case 5:

								walka_bandyta(postac, plecak, zaklecia);
								break;

							case 6:
								if (plecak.zloto >= 30)
								{
									cout << "Zdecydowales sie zaplacic, tracisz 30 sztuk zlota" << endl;
									plecak.zloto = plecak.zloto - 30;
								}
								else
								{
									cout << "Nie posiadasz wystarczajaco duzo zlota, musisz stanac do walki" << endl << endl;
									walka_bandyta(postac, plecak, zaklecia);
								}
								break;
							case 7:
								zwieksz(p, si, brak);
							}
							ilosc_akcji = true;
						}
					}
					else
					{
						cout << "Posiadasz za malo punktow akcji na wykonanie tej czynnosci" << endl;
						break;
					}
				}
				//---------------------------------------------------------Akcja2-------------------------------------------------------//
				if (akcja == 2)
				{
					if (postac.punkty_akcji >= 20)
					{
						int odleglosc = 0;
						odleglosc = losowa_kostka();
						cout << "Pokonany dystans = " << odleglosc << endl;
						pokonany_dystans = pokonany_dystans + odleglosc;
						postac.punkty_akcji = postac.punkty_akcji - 20;
						ilosc_akcji = true;
						using namespace kontrola_rozgrywki;
						dane danekontroli;
						if (pokonany_dystans >= danekontroli.odleglosc)
						{
							koniec_tury = true;
							if ((postac.punkty_wytrzymalosci < 200) || (postac.punkty_many < 150) || (postac.zadawane_obrazenia < 100))
							{
								//---------------------------------------------------------Negatywne zakonczenie nr.1-------------------------------------------------------//
								koniec_rozgrywki1();
								koniec_gry = true;
							}
							else
							{
								//---------------------------------------------------------Pozytywne zakonczenie pierwszego etapu-------------------------------------------------------//
													//JESLI GRACZ DA RADE UZBIERAC WSZYSTKIE WYMAGAJACE UMIEJETNOSCI I WYROBI SIE Z DOTARCIEM DO WROGOW (POZYTYWNE ZAKONCZENIE EW.WALKA Z BOSSEM)

							}
						}
					}
					else
					{
						cout << "Posiadasz za malo punktow akcji na wykonanie tej czynnosci" << endl;
						ilosc_akcji = true;
						break;
					}
				}
				//----------------------------------------------------------------Akcja3----------------------------------------------------------------//
				if (akcja == 3)
				{
					ilosc_akcji = true;
					koniec_tury = true;
				}


			}
			cout << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << endl;
			system("PAUSE");
		}
		if (koniec_gry == false)
		{
			ubyte_tury++;
			cout << "******************" << endl;
			cout << "* Koniec " << ubyte_tury << " tury! *" << endl;
			cout << "******************" << endl;
			cout << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << endl;
			system("PAUSE");
		}
		using namespace kontrola_rozgrywki;
		dane danekontroli;
		if (ubyte_tury >= danekontroli.liczba_tur)
		{
			//---------------------------------------------------------Negatywne zakonecznie nr.2-------------------------------------------------------//
			koniec_rozgrywki2();
			koniec_gry = true;
		}
	}
	return 0;
}