#include <iostream>
#include <cstdlib>
#include <ctime>
#include <conio.h>
#include <vector>
#include <fstream>


using namespace std;

const short ROZMIAR = 30;
const short W = 10;

enum class Pole
{
    pustka, mur, poszukiwacz, wrog, skarb
};

enum class StanGry
{
    otwarta, zwyciestwo, porazka
};

StanGry STAN = StanGry::otwarta;

Pole tablica[ROZMIAR][ROZMIAR];

void start_informacje_programu()
{
    cout << "Witaj, \nw grze ''Poszukiwacz'', niżej sa zasady gry ,jesli jestes gotowy na gre nacisnij 'ENTER'."  << endl;
    cout << endl;
    cout << endl;
    cout << endl;
    cout << "1.Gra odbywa sie na planszy o wymiarach 30x30 \n"<< "2.Na planszy znajduja sie: poszukiwacz, skarb, 10 wrogow i mury. \n" <<
         "3.Poszukiwacz moze poruszac sie o jedno pole w gore, w dol, w lewo lub w prawo. Po ruchu poszukiwacz zostawia za soba mur.\n" <<"4.Gra konczy sie jesli poszukiwacz dojdzie do skarbu (zwyciestwo), jesli wrog wejdzie na pole z poszukiwaczem (porazka) lub jesli poszukiwacz zostanie zablokowany i nie bedzie mogl wykonac prawidlowego ruchu (porazka).";
    char komenda;

    do
    {
        komenda = _getch();
        komenda = toupper(komenda);
    }
    while(static_cast<int>(komenda) != 13);
}


void wypisz_pole(Pole pole)
{
    switch(pole)
    {
    case Pole::pustka:
        cout << ' ';
        break;
    case Pole::mur:
        cout << '#';
        break;
    case Pole::poszukiwacz:
        cout << 'O';
        break;
    case Pole::wrog:
        cout << '@';
        break;
    case Pole::skarb:
        cout << '!';
    }
}

struct Wspolrzedne
{
    short x;
    short y;
};

Wspolrzedne poszukiwacz;
Wspolrzedne skarb;
Wspolrzedne wrogowie[W];

void wypelnienie_tablic()
{


    for(short i = 0; i < ROZMIAR; ++i)
    {
        for(short j = 0; j < ROZMIAR; ++j)
        {
            if(i== 0 || i==ROZMIAR-1 || j==0 || j==ROZMIAR-1)
                tablica[i][j] = Pole::mur;
            else
                tablica[i][j] = Pole::pustka;

        }

    }
    while(true)
    {
        poszukiwacz.x = (rand() % 27) + 1;
        poszukiwacz.y = (rand() % 27) + 1;
        if(tablica[poszukiwacz.x][poszukiwacz.y] == Pole::pustka)
        {
            tablica[poszukiwacz.x][poszukiwacz.y] = Pole::poszukiwacz;
            break;
        }
    }

    while(true)
    {
        skarb.x = (rand() % 27) + 1;
        skarb.y = (rand() % 27) + 1;
        if(tablica[skarb.x][skarb.y] == Pole::pustka && (skarb.x != poszukiwacz.x || skarb.y != poszukiwacz.y))
        {
            tablica[skarb.x][skarb.y] = Pole::skarb;
            break;
        }
    }

    for(short i = 0; i < W; ++i )
    {
        while(true)
        {
            wrogowie[i].x = (rand() % 27) + 1;
            wrogowie[i].y = (rand() % 27) + 1;
            if(tablica[wrogowie[i].x][wrogowie[i].y] == Pole::pustka)
            {
                tablica[wrogowie[i].x][wrogowie[i].y] = Pole::wrog;
                break;
            }
        }

    }

}


void wypisywanie_planszy_na_ekran()
{
    for(short i = 0; i < ROZMIAR; ++i)
    {
        for(short j = 0; j < ROZMIAR; ++j)
        {
            wypisz_pole(tablica[i][j]);
        }
        cout << endl;
    }


}

bool operator==(Wspolrzedne A, Wspolrzedne B)
{
    if(A.x == B.x && A.y == B.y)
        return true;
    return false;
}

void zapisywanie_postepu_gry()
{
    cout << "Trwa zapis do pliku\n";
    ofstream plik;
    plik.open("plik.txt");

    // zapisanie planszy
    for(short i = 0; i < ROZMIAR; ++i)
    {
        for(short j = 0; j < ROZMIAR; ++j)
        {
            plik << static_cast<short>(tablica[i][j]) << ' ';
        }
    }
    // zapisanie wspolrzednych poszukiwacza
    // zapisanie wspolrzednych skarbu
    // zapisanie wspolrzednych wrogow
    plik.close();
    cout << "Udalo sie zapisac do pliku\n";
}

void poruszanie_sie_po_planszy()
{
    if(tablica[poszukiwacz.x - 1][poszukiwacz.y] == Pole::mur || tablica[poszukiwacz.x - 1][poszukiwacz.y] == Pole::wrog)
        if(tablica[poszukiwacz.x + 1][poszukiwacz.y] == Pole::mur || tablica[poszukiwacz.x + 1][poszukiwacz.y] == Pole::wrog)
            if(tablica[poszukiwacz.x][poszukiwacz.y - 1] == Pole::mur || tablica[poszukiwacz.x][poszukiwacz.y - 1] == Pole::wrog)
                if(tablica[poszukiwacz.x][poszukiwacz.y + 1] == Pole::mur || tablica[poszukiwacz.x][poszukiwacz.y + 1] == Pole::wrog)
                {
                    STAN = StanGry::porazka;
                    return;
                }

    char klawisz;
    bool flaga = true;

    while(flaga)
    {
        do
        {
            klawisz = _getch();
            klawisz = toupper(klawisz);
        }
        while(klawisz != 'W' && klawisz != 'A' && klawisz != 'S'&& klawisz != 'D' && klawisz != 'Z');

        switch(klawisz)
        {
        case 'W':       // poruszanie się w górę
            if(tablica[poszukiwacz.x - 1][poszukiwacz.y] == Pole::pustka || tablica[poszukiwacz.x - 1][poszukiwacz.y] == Pole::skarb)
            {
                tablica[poszukiwacz.x][poszukiwacz.y] = Pole::mur;
                poszukiwacz.x--;
                tablica[poszukiwacz.x][poszukiwacz.y] = Pole::poszukiwacz;
                flaga = false;
            }
            break;
        case 'A':
            if(tablica[poszukiwacz.x ][poszukiwacz.y - 1] == Pole::pustka || tablica[poszukiwacz.x][poszukiwacz.y - 1] == Pole::skarb)
            {
                tablica[poszukiwacz.x][poszukiwacz.y] = Pole::mur;
                poszukiwacz.y--;
                tablica[poszukiwacz.x][poszukiwacz.y] = Pole::poszukiwacz;
                flaga = false;
            }
            break;
        case 'S':
            if(tablica[poszukiwacz.x + 1 ][poszukiwacz.y] == Pole::pustka || tablica[poszukiwacz.x + 1][poszukiwacz.y] == Pole::skarb)
            {
                tablica[poszukiwacz.x][poszukiwacz.y] = Pole::mur;
                poszukiwacz.x++;
                tablica[poszukiwacz.x][poszukiwacz.y] = Pole::poszukiwacz;
                flaga = false;
            }
            break;
        case 'D':
            if(tablica[poszukiwacz.x][poszukiwacz.y + 1] == Pole::pustka || tablica[poszukiwacz.x][poszukiwacz.y + 1] == Pole::skarb)
            {
                tablica[poszukiwacz.x][poszukiwacz.y] = Pole::mur;
                poszukiwacz.y++;
                tablica[poszukiwacz.x][poszukiwacz.y] = Pole::poszukiwacz;
                flaga = false;
            }
            break;
        case 'Z':
            zapisywanie_postepu_gry();
        }
    }

    if(poszukiwacz == skarb)
        STAN = StanGry::zwyciestwo;

}



void poruszanie_sie_jednym_wrogiem(int i)
{
    vector<Wspolrzedne> wolne_pola;
    Wspolrzedne nowe_pole;

    nowe_pole.x = wrogowie[i].x - 1;
    nowe_pole.y = wrogowie[i].y;
    if(nowe_pole == poszukiwacz)
    {
        STAN = StanGry::porazka;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        return;
    }
    if(tablica[nowe_pole.x][nowe_pole.y] == Pole::pustka)
        wolne_pola.push_back(nowe_pole);

    nowe_pole.x = wrogowie[i].x + 1;
    nowe_pole.y = wrogowie[i].y;
    if(nowe_pole == poszukiwacz)
    {
        STAN = StanGry::porazka;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        return;
    }
    if(tablica[nowe_pole.x][nowe_pole.y] == Pole::pustka)
        wolne_pola.push_back(nowe_pole);

    nowe_pole.x = wrogowie[i].x;
    nowe_pole.y = wrogowie[i].y + 1;
    if(nowe_pole == poszukiwacz)
    {
        STAN = StanGry::porazka;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        return;
    }
    if(tablica[nowe_pole.x][nowe_pole.y] == Pole::pustka)
        wolne_pola.push_back(nowe_pole);

    nowe_pole.x = wrogowie[i].x;
    nowe_pole.y = wrogowie[i].y - 1;
    if(nowe_pole == poszukiwacz)
    {
        STAN = StanGry::porazka;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        return;
    }
    if(tablica[nowe_pole.x][nowe_pole.y] == Pole::pustka)
        wolne_pola.push_back(nowe_pole);

    nowe_pole.x = wrogowie[i].x - 1;
    nowe_pole.y = wrogowie[i].y - 1;
    if(nowe_pole == poszukiwacz)
    {
        STAN = StanGry::porazka;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        return;
    }
    if(tablica[nowe_pole.x][nowe_pole.y] == Pole::pustka)
        wolne_pola.push_back(nowe_pole);

    nowe_pole.x = wrogowie[i].x + 1;
    nowe_pole.y = wrogowie[i].y - 1;
    if(nowe_pole == poszukiwacz)
    {
        STAN = StanGry::porazka;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        return;
    }
    if(tablica[nowe_pole.x][nowe_pole.y] == Pole::pustka)
        wolne_pola.push_back(nowe_pole);

    nowe_pole.x = wrogowie[i].x - 1;
    nowe_pole.y = wrogowie[i].y - 1;
    if(nowe_pole == poszukiwacz)
    {
        STAN = StanGry::porazka;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        return;
    }
    if(tablica[nowe_pole.x][nowe_pole.y] == Pole::pustka)
        wolne_pola.push_back(nowe_pole);

    nowe_pole.x = wrogowie[i].x - 1;
    nowe_pole.y = wrogowie[i].y + 1;
    if(nowe_pole == poszukiwacz)
    {
        STAN = StanGry::porazka;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        return;
    }
    if(tablica[nowe_pole.x][nowe_pole.y] == Pole::pustka)
        wolne_pola.push_back(nowe_pole);


    unsigned size = wolne_pola.size();
    if(size > 0)
    {
        nowe_pole = wolne_pola[rand() % size];
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::pustka;
        wrogowie[i] = nowe_pole;
        tablica[wrogowie[i].x][wrogowie[i].y] = Pole::wrog;
    }
}



void poruszanie_sie_wrogow()
{
    for(int j = 0; j<W; j++)
        poruszanie_sie_jednym_wrogiem(j);
}



int main()
{
    srand(time(nullptr));
    int ilosc_ruchow;
    wypelnienie_tablic();
    start_informacje_programu();
    system("cls");

    time_t poczatek, koniec;

    time(&poczatek);
    while(STAN == StanGry::otwarta)
    {

        wypisywanie_planszy_na_ekran();
        poruszanie_sie_po_planszy();
        poruszanie_sie_wrogow();
        ilosc_ruchow = ilosc_ruchow + 1;
        system("cls");
    }
    time(&koniec);
    wypisywanie_planszy_na_ekran();

    time_t uplynelo = koniec - poczatek;
    if(STAN == StanGry::porazka)
    {
        cout << "PRZEGRALES!" << endl;
        cout << "Przegrales gre w " << ilosc_ruchow << " ruchach";
    }
    else
    {
        cout << "WYGRALES!" << endl;
        cout << "Wygrales gre w " << ilosc_ruchow << " ruchach";
    }
    cout << "(" << uplynelo << " sekund).\n";



    return 0;
}