#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
#include <string>
#include <conio.h>
#include "Header.h"
#pragma warning(disable:4996)
using namespace std;

//---------------------------------------------------------------------------------------
// funkcje siatki
//---------------------------------------------------------------------------------------
const int p_rozmiar = 6; // rozmiar maksymalny planszy

// funkcja wypeliajaca plansze
void wypelnijplanasze(char plansza[p_rozmiar][p_rozmiar])
{
	char pionek = 'O'; // znacznik pionka
	for (int x = 5; x > 0; x--)
	{
		for (int y = 1; y < 6; y++) // wypelnia plansze pionkami
		{
			plansza[x][y] = pionek;
		}
	}
	plansza[3][3] = '-'; // tworzy puste miejsce
}

// funkcja rysowania planszy i elementow gry
void Rysuj(char plansza[p_rozmiar][p_rozmiar], int wynik, int ruchy, int pionki, int gry, int najwynik)
{
	cout << "-----------------------------------------\n";
	cout << "| Ilość gier: " << gry << " |     Najlepszy wynik: " << najwynik << "    |\n";
	cout << "-----------------------------------------\n\n";
	cout << "          ---------------------\n";
	for (int x = 5; x > 0; x--)
	{
		if (x == 3)
		{
			cout << "     Y  " << x << " | ";
		}
		else
		{
			cout << "        " << x << " | ";
		}
		for (int y = 1; y < 6; y++)
		{
			cout << plansza[y][x] << " | ";
		}
		cout << "\n          ---------------------\n";
	}
	cout << "           1   2   3   4   5  \n" << endl;
	cout << "                   X\n\n";
	cout << "-----------------------------------------\n";
	cout << "| Pozostałe pionki: " << pionki << " Wynik: " << wynik << " Ruchy: " << ruchy << "  |\n";
	cout << "-----------------------------------------\n";
}

// aktualizuje plansze
void Aktualizuj(char plansza[p_rozmiar][p_rozmiar], int x, int y, int usunX, int usunY, int xbackup, int ybackup)
{
	plansza[x][y] = 'O';
	plansza[usunX][usunY] = '-';
	plansza[xbackup][ybackup] = '-';
}
//---------------------------------------------------------------------------------------
// Zasady i bledy funkcje
//---------------------------------------------------------------------------------------
// zasady i bledy
int ZasadyiBledy(int &error)
{
	if (error == -1)
	{
		cout << "\nZasada 1: Nie może być pionka w miejscu, na które chcesz przeskoczyć"
			"\n\nZasada 2: Ruch pionkiem jest możliwy tylko po planszy 5x5"
			"\n\nZasada 3: Ruch pionka jest możliwy tylko na miejsca, które nie są zajęte\n" << endl;
	}
	if (error == 1)
	{
		cout << "\nNie może być pionka w wybranym kierunku, aby dało się przeskoczyć\n";
	}
	else if (error == 2)
	{
		cout << "\nRuch pionkiem jest możliwy tylko po planszy 5x5\n";
	}
	else if (error == 3)
	{
		cout << "\nRuch pionka jest możliwy tylko na miejsca, które nie są zajęte\n" << endl;
	}
	error = 0;
	return (error);
}

// funkcja sprawdza 3 zasady
int Errorsprawdz(int x, int y, int usunX, int usunY, int &error, char plansza[p_rozmiar][p_rozmiar])
{
	// zasada 1 czy da sie przeskoczyc
	if (plansza[usunX][usunY] != 'O')
	{
		error = 1;
		return (error);
	}
	// zasada 2 pionek nie moze wyjsc za plansze
	else if (usunX <= 0 || usunX >= 6 || usunY <= 0 || usunY >= 6)
	{
		error = 2;
		return (error);
	}
	// zasada 3 zajete miejsce
	else if (plansza[x][y] == 'O')
	{
		error = 3;
		return (error);
	}
	else
	{
		error = 0;
		return (error);
	}
}

//---------------------------------------------------------------------------------------
// Funkcje gry
//---------------------------------------------------------------------------------------
// Funkcja okreslania X
int xRuch(char ruch, int &x)
{
	if (ruch == 'W' || ruch == 'w')
	{
		x = x;
	}
	else if (ruch == 'D' || ruch == 'd')
	{
		x = x + 2;
	}
	else if (ruch == 'S' || ruch == 's')
	{
		x = x;
	}
	else if (ruch == 'A' || ruch == 'a')
	{
		x = x - 2;
	}
	return (x);
}

// funkcja usuwania pionka z wpolzendnej X
int UsunX(char ruch, int x, int &usunX)
{
	if (ruch == 'W' || ruch == 'w')
	{
		usunX = x;
	}
	else if (ruch == 'D' || ruch == 'd')
	{
		usunX = x + 1;
	}
	else if (ruch == 'S' || ruch == 's')
	{
		usunX = x;
	}
	else if (ruch == 'A' || ruch == 'a')
	{
		usunX = x - 1;
	}
	return (usunX);
}

// Funkcja okreslania Y
int yRuch(char ruch, int &y)
{
	if (ruch == 'W' || ruch == 'w')
	{
		y = y + 2;
	}
	else if (ruch == 'D' || ruch == 'd')
	{
		y = y;
	}
	else if (ruch == 'S' || ruch == 's')
	{
		y = y - 2;
	}
	else if (ruch == 'A' || ruch == 'a')
	{
		y = y;
	}
	return (y);
}

// funkcja usuwania pionka z wpolzendnej Y
int UsunY(char ruch, int y, int &usunY)
{
	if (ruch == 'W' || ruch == 'w')
	{
		usunY = y + 1;
	}
	else if (ruch == 'D' || ruch == 'd')
	{
		usunY = y;
	}
	else if (ruch == 'S' || ruch == 's')
	{
		usunY = y - 1;
	}
	else if (ruch == 'A' || ruch == 'a')
	{
		usunY = y;
	}
	return (usunY);
}

//---------------------------------------------------------------------------------------
// zmienne funcje
//---------------------------------------------------------------------------------------

void Clear()
{
	system("cls");
}

int pioneklicznik(int &pionki, char plansza[p_rozmiar][p_rozmiar])
{
	pionki = 0;
	for (int i = 5; i > 0; i--)
	{
		for (int j = 1; j < 6; j++)
		{
			if (plansza[i][j] == 'O')
			{
				pionki++; // Liczy pionki
			}
		}
	}
	return (pionki);
}

int Wynik(int &wynik, int pionki, char plansza[p_rozmiar][p_rozmiar])
{
	switch (pionki)
	{
	case 8: wynik = 10; // 8 pionkow
		break;
	case 7: wynik = 20;
		break;
	case 6: wynik = 30;
		break;
	case 5: wynik = 40;
		break;
	case 4: wynik = 50;
		break;
	case 3: wynik = 60;
		break;
	case 2: wynik = 70;
		break;
	case 1: wynik = 80; // 1 pionek
		break;
	default: wynik = 0;
	}
	if (pionki == 1 && plansza[3][3] == 'O')
	{
		wynik = 100; // pionek na srodku
	}
	return (wynik);
}

int Najwynik(int wynik, int &najwynik)
{
	if (wynik > najwynik)
	{
		najwynik = wynik;
		cout << "Gratulacje masz nowy rekord!\n";
	}
	else
	{
		najwynik = najwynik;
	}
	return (najwynik);
}

//---------------------------------------------------------------------------------------
// Gra
//---------------------------------------------------------------------------------------
void main()
{
	setlocale(LC_ALL, "");
	//---------------------------------------------------------------------------------------
	// Zmienne
	//---------------------------------------------------------------------------------------
	char plansza[p_rozmiar][p_rozmiar]; // plansza
	char ruch = ' '; // gdzie poruszyc
	int error = 0; // Sprawdzanie bledow
	int x = 0; // poczatkowy X
	int xbackup = 0; // backup wczesniejszej pozycji X
	int y = 0; // poczatkowy Y
	int ybackup = 0; // backup wczesniejszej pozycji Y
	int usunX = 0; // usuwanie pionka z wspolzendnej X
	int usunY = 0; // usuwanie pionka z wspolzendnej Y
	int wynik = 0; // wynik
	int najwynik = 0; // najlepszy wynik
	int ruchy; // licznik ruchow
	int pionki = 0; // licznik pionkow
	int gry = 0; // ilosc gier
	bool wlasciwy = false;
	//---------------------------------------------------------------------------------------
	// zmienne menu
	//---------------------------------------------------------------------------------------
	bool Gra = true; // czy gracz jest w grze
	bool Rozpocznijgre = false; // rozpoczyna gre
	//---------------------------------------------------------------------------------------
	// Menu
	//---------------------------------------------------------------------------------------

	string imie;
	cout<<"Witaj"<<endl;
	cout<<"Podaj Nick"<<endl;
	cin >> imie;
    osoba gracz1;
    gracz1.imie = imie;
	Clear();


	while (Gra == true)
	{
		// tytul



		int wybierz; // Wybor gracza
		bool menu = true; // menu petla
		while (menu == true)
		{		cout <<
"\n  ######     ###    ##     ##  #######  ######## ##    ## #### ##    ## \n"
" ##    ##   ## ##   ###   ### ##     ##    ##    ###   ##  ##  ##   ## \n "
"##        ##   ##  #### #### ##     ##    ##    ####  ##  ##  ##  ##  \n "
" ######  ##     ## ## ### ## ##     ##    ##    ## ## ##  ##  #####   \n "
"      ## ######### ##     ## ##     ##    ##    ##  ####  ##  ##  ##  \n "
"##    ## ##     ## ##     ## ##     ##    ##    ##   ###  ##  ##   ## \n"
"  ######  ##     ## ##     ##  #######     ##    ##    ## #### ##    ## \n\n"<< endl;


		cout << "Menu główne\n\n"
			"1. Rozpocznij gre\n"
			"2. Instrukcja gry\n"
			"3. Zasady gry\n"
			"4. Wyjście\n\n";
			cout << "Wybierz: ";
			cin >> wybierz; // wprowadz
			switch (wybierz)
			{
			case 1: menu = false; // zamyka menu
				wypelnijplanasze(plansza); // wypelnia plansze
				gry++;
				ruchy = 0;
				Rozpocznijgre = true; // rozpoczyna gre
				Clear();
				menu = true;
				break;
			case 2: do{
				cout << "\nGra _Samotnik_ polega na poruszaniu tylko jednego pionka tak aby przeskoczył\n"
				"nad innym pionkiem na planszy. Pionek może przeskoczyć pionka,\n"
				"który jest tuż obok i tylko w pozycji pionowej lub poziomej.\nNie można przeskoczyć "
				"pionka po skosie planszy.\nŻeby przeskoczyć pionka musi być puste miejsce obok niego,\n"
				"aby można go było przeskoczyć.\n"
				"Nie można przeskoczyć na miejsce, w którym jest już inny pionek.\n"
				"Przeskoczony pionek znika z planszy.\n\n"

				"W każdej turze wybierasz jeden z możliwych pionków przyległy do pionka,\n"
				"którego można przeskoczyć. Możesz kontynuować grę jednym pionkiem,\n"
				"aż braknie pionka którego można przeskoczyć.\n"
				"Nowy ruch rozpoczyna się po wybraniu innego pionka.\n\n"

				"Żeby zrobić pierwszy ruch musisz wybrać pionek,\n"
				"który chcesz poruszyć przez wpisywanie współrzędnych X i Y\n"
				"i później wybrać jeden z kierunków góra, dół, lewo, prawo ,\n"
				"używając przycisków W S A D.\n\n"
				"Aby powrócic wcisnij ESC ,\n";}
				while(getch() != 27);
				Clear();
				break;
			case 3: error = -1; // pokazuje zasady
				ZasadyiBledy(error); // wywoluje funkcje
				while(getch() != 27);
				Clear();
				break;
			case 4: menu = false; // zamyka menu
				Gra = false; // koniec gry
				break;
			case 5: error = -1; // pokazuje zasady
				ZasadyiBledy(error); // wywoluje funkcje
				break;

			default: cout << "Spróbuj inny klawisz\n";
			}
		}
		if (Gra == false)
		{
			break;
		}
		//---------------------------------------------------------------------------------------
		// Gra
		//---------------------------------------------------------------------------------------
		while (Rozpocznijgre = true)
		{
			pioneklicznik(pionki, plansza);
			Wynik(wynik, pionki, plansza); // sprawdza wynik
			Rysuj(plansza, wynik, ruchy, pionki, gry, najwynik); // Rysuje plansze
			cout << endl;
			while (wlasciwy == false)
			{
				cout << "Którym pionkiem chcesz zacząć?" << endl;
				cout << "Jeśli chcesz wyjść wpisz dwa razy 0" << endl;
				cout << "Wybierz pozycje na osi x: ";
				cin >> x;
				cout << "Wybierz pozycje na osi y: ";
				cin >> y;
				if (x == 0 && y == 0)
				{
					Rozpocznijgre = false;
					wlasciwy = true;
				}
				else if (x <= -1 || x >= 6 || y <= -1 || y >= 6 || plansza[x][y] != 'O')
				{
					cout << "Podałeś nieprawidłową pozycje, sprobuj ponownie. \n\n"; // zly rych
				}

				else
				{
					xbackup = x;
					ybackup = y;
					wlasciwy = true;
				}
			}//
			if (Rozpocznijgre == false)
			{
				Clear();
				break;
			}
			wlasciwy = false;
			while (wlasciwy == false)
			{
				cout << "W którą stronę chcesz się ruszyć?" << endl;
				cout << "Góra, Dół, Lewo, Prawo => WSAD : ";
				cin >> ruch; // podaj ruch
				switch (ruch)
				{
				case 'W': wlasciwy = true;
					break;
				case 'w': wlasciwy = true;
					ruch = 'W';
					break;
				case 'D': wlasciwy = true;
					break;
				case 'd': wlasciwy = true;
					ruch = 'D';
					break;
				case 'S': wlasciwy = true;
					break;
				case 's': wlasciwy = true;
					ruch = 'S';
					break;
				case 'A': wlasciwy = true;
					break;
				case 'a': wlasciwy = true;
					ruch = 'A';
					break;
				default: cout << "Spróbuj jeszcze raz\n";
				}
			}
			wlasciwy = false; //resetuje dobry ruch mozliwosc nastepnego
			UsunX(ruch, x, usunX); // ktore pole jest uwuane?
			xRuch(ruch, x); // ktore pole jest nowym polem?
			UsunY(ruch, y, usunY); // ktore pole jest uwuane?
			yRuch(ruch, y); // ktore pole jest nowym polem?
			Errorsprawdz(x, y, usunX, usunY, error, plansza); // sprawdza zeby zobaczyc czy jest zly ruch
			if (error != 0) // jesli nie jest wazny
			{
				ZasadyiBledy(error); // pokazuje dlaczego
			}
			else if (error == 0) // inaczej
			{
				Aktualizuj(plansza, x, y, usunX, usunY, xbackup, ybackup); // aktualizuje siatke
				ruchy++; // aktualizuje ruchy
				Clear();
			}
		}
		cout << "Twój wynik końcowy to: " << wynik << "\n";
		Najwynik(wynik, najwynik);
		gracz1.punkty = Najwynik(wynik, najwynik);
		Top10 ranking("ranking.txt");
		ranking._getTop10();
		ranking._inputPerson(gracz1,1);
		ranking._displayRank();
	    ranking._setTop10();
		Clear();
	}
}