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

using namespace std;

enum class pole
{
    puste, poszukiwacz, mur, skarb, przeciwnik
};

enum class stan_gry
{
    otwarta, zwyciestwo, porazka
};

stan_gry stan = stan_gry::otwarta;

struct wspolrzedne
{
    short i;
    short j;
    short los;
};

const short N = 33;
pole plansza[N][N];
wspolrzedne przeciwnicy[10];
wspolrzedne bohater;

void ruch_przeciwnikiem(short x)
{
    // sprawdzenie czy wokół danego przeciwnika stoi poszukiwacz:
    if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j - 1] == pole::poszukiwacz)
    {
        plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j - 1] = pole::przeciwnik;
        stan = stan_gry::porazka;
        return;
    }
    if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j] == pole::poszukiwacz)
    {
        plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j] = pole::przeciwnik;
        stan = stan_gry::porazka;
        return;
    }
    if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j + 1] == pole::poszukiwacz)
    {
        plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j + 1] = pole::przeciwnik;
        stan = stan_gry::porazka;
        return;
    }
    if(plansza[przeciwnicy[x].i][przeciwnicy[x].j - 1] == pole::poszukiwacz)
    {
        plansza[przeciwnicy[x].i][przeciwnicy[x].j - 1] = pole::przeciwnik;
        stan = stan_gry::porazka;
        return;
    }
    if(plansza[przeciwnicy[x].i][przeciwnicy[x].j + 1] == pole::poszukiwacz)
    {
        plansza[przeciwnicy[x].i][przeciwnicy[x].j + 1] = pole::przeciwnik;
        stan = stan_gry::porazka;
        return;
    }
    if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j - 1] == pole::poszukiwacz)
    {
        plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j - 1] = pole::przeciwnik;
        stan = stan_gry::porazka;
        return;
    }
    if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j] == pole::poszukiwacz)
    {
        plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j] = pole::przeciwnik;
        stan = stan_gry::porazka;
        return;
    }
    if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j + 1] == pole::poszukiwacz)
    {
        plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j + 1] = pole::przeciwnik;
        stan = stan_gry::porazka;
        return;
    }

    // ruch na wolne miejsce:
    vector<wspolrzedne> dostepne_pola;
    wspolrzedne nowe;
    if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j - 1] == pole::puste)
    {
        nowe.i = przeciwnicy[x].i - 1;
        nowe.j = przeciwnicy[x].j - 1;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j] == pole::puste)
    {
        nowe.i = przeciwnicy[x].i - 1;
        nowe.j = przeciwnicy[x].j;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j + 1] == pole::puste)
    {
        nowe.i = przeciwnicy[x].i - 1;
        nowe.j = przeciwnicy[x].j + 1;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[przeciwnicy[x].i][przeciwnicy[x].j - 1] == pole::puste)
    {
        nowe.i = przeciwnicy[x].i;
        nowe.j = przeciwnicy[x].j - 1;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[przeciwnicy[x].i][przeciwnicy[x].j + 1] == pole::puste)
    {
        nowe.i = przeciwnicy[x].i;
        nowe.j = przeciwnicy[x].j + 1;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j - 1] == pole::puste)
    {
        nowe.i = przeciwnicy[x].i + 1;
        nowe.j = przeciwnicy[x].j - 1;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j] == pole::puste)
    {
        nowe.i = przeciwnicy[x].i + 1;
        nowe.j = przeciwnicy[x].j;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j + 1] == pole::puste)
    {
        nowe.i = przeciwnicy[x].i + 1;
        nowe.j = przeciwnicy[x].j + 1;
        dostepne_pola.push_back(nowe);
    }
    if(dostepne_pola.size() > 0)
    {
        // losujemy na które pole ma pójść przeciwnik
        srand(time(nullptr));
        nowe = dostepne_pola[rand() % dostepne_pola.size()];
        plansza[przeciwnicy[x].i][przeciwnicy[x].j] = pole::puste;
        przeciwnicy[x].i = nowe.i;
        przeciwnicy[x].j = nowe.j;
        plansza[przeciwnicy[x].i][przeciwnicy[x].j] = pole::przeciwnik;
    }
}

void ruch_przeciwnikow()
{
    for(short i = 0; i < 10; ++i)
        ruch_przeciwnikiem(i);
}

void uzupelnij_plansze()
{
    srand(time(nullptr));
    vector<wspolrzedne> puste_pola;
    wspolrzedne nowe;
    for(short i = 0; i < N; ++i)
        for(short j = 0; j < N; ++j)
            if(i == 0 || i == N - 1 || j == 0 || j == N - 1 || ((i-1) * (j-1)) % 2 != 0)
                plansza[i][j] = pole::mur;
            else
            {
                plansza[i][j] = pole::puste;
                nowe.i = i;
                nowe.j = j;
                nowe.los = rand();
                puste_pola.push_back(nowe);
            }
    unsigned n = puste_pola.size();
    for(unsigned i = 0; i < n - 1; ++i)
        for(unsigned j = 0; j < n - i - 1; ++j)
            if(puste_pola[j].los > puste_pola[j + 1].los)
                swap(puste_pola[j], puste_pola[j + 1]);
    for(unsigned i = 0; i < 10; ++i)
    {
        plansza[puste_pola[i].i][puste_pola[i].j] = pole::przeciwnik;
        przeciwnicy[i].i = puste_pola[i].i;
        przeciwnicy[i].j = puste_pola[i].j;
    }
    plansza[puste_pola[10].i][puste_pola[10].j] = pole::poszukiwacz;
    bohater.i = puste_pola[10].i;
    bohater.j = puste_pola[10].j;
    plansza[puste_pola[11].i][puste_pola[11].j] = pole::skarb;
}

void ruch_bohaterem()
{
    // sprawdzamy czy bohater ma siê gdzie ruszyæ:
    vector<wspolrzedne> dostepne_pola;
    wspolrzedne nowe;
    if(plansza[bohater.i - 1][bohater.j] == pole::puste || plansza[bohater.i - 1][bohater.j] == pole::skarb)
    {
        nowe.i = bohater.i - 1;
        nowe.j = bohater.j;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[bohater.i + 1][bohater.j] == pole::puste || plansza[bohater.i + 1][bohater.j] == pole::skarb)
    {
        nowe.i = bohater.i + 1;
        nowe.j = bohater.j;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[bohater.i][bohater.j - 1] == pole::puste || plansza[bohater.i][bohater.j - 1] == pole::skarb)
    {
        nowe.i = bohater.i;
        nowe.j = bohater.j - 1;
        dostepne_pola.push_back(nowe);
    }
    if(plansza[bohater.i][bohater.j + 1] == pole::puste || plansza[bohater.i][bohater.j + 1] == pole::skarb)
    {
        nowe.i = bohater.i;
        nowe.j = bohater.j + 1;
        dostepne_pola.push_back(nowe);
    }
    if(dostepne_pola.size() == 0)
    {
        stan = stan_gry::porazka;
        return;
    }

    // w³aœciwy ruch:
    char direction;
    while(true)
    {
        do
        {
            direction = getch();
            direction = toupper(direction);
        }
        while(direction != 'J' && direction != 'K' && direction != 'L' && direction != 'I' && direction != 'Z');
        switch(direction)
        {
        case 'J':   // ruch w lewo
            if(plansza[bohater.i][bohater.j - 1] == pole::puste)
            {
                plansza[bohater.i][bohater.j - 1] = pole::poszukiwacz;
                plansza[bohater.i][bohater.j] = pole::mur;
                bohater.j--;
                return;
            }
            if(plansza[bohater.i][bohater.j - 1] == pole::skarb)
            {
                plansza[bohater.i][bohater.j - 1] = pole::poszukiwacz;
                plansza[bohater.i][bohater.j] = pole::mur;
                bohater.j--;
                stan = stan_gry::zwyciestwo;
                return;
            }
            break;
        case 'K':   // ruch w dol
            if(plansza[bohater.i + 1][bohater.j] == pole::puste)
            {
                plansza[bohater.i + 1][bohater.j] = pole::poszukiwacz;
                plansza[bohater.i][bohater.j] = pole::mur;
                bohater.i++;
                return;
            }
            if(plansza[bohater.i + 1][bohater.j] == pole::skarb)
            {
                plansza[bohater.i + 1][bohater.j] = pole::poszukiwacz;
                plansza[bohater.i][bohater.j] = pole::mur;
                bohater.i++;
                stan = stan_gry::zwyciestwo;
                return;
            }
            break;
        case 'I':   // ruch w gore
            if(plansza[bohater.i - 1][bohater.j] == pole::puste)
            {
                plansza[bohater.i - 1][bohater.j] = pole::poszukiwacz;
                plansza[bohater.i][bohater.j] = pole::mur;
                bohater.i--;
                return;
            }
            if(plansza[bohater.i - 1][bohater.j] == pole::skarb)
            {
                plansza[bohater.i - 1][bohater.j] = pole::poszukiwacz;
                plansza[bohater.i][bohater.j] = pole::mur;
                bohater.i--;
                stan = stan_gry::zwyciestwo;
                return;
            }
            break;
        case 'L':   // ruch w prawo
            if(plansza[bohater.i][bohater.j + 1] == pole::puste)
            {
                plansza[bohater.i][bohater.j + 1] = pole::poszukiwacz;
                plansza[bohater.i][bohater.j] = pole::mur;
                bohater.j++;
                return;
            }
            if(plansza[bohater.i][bohater.j + 1] == pole::skarb)
            {
                plansza[bohater.i][bohater.j + 1] = pole::poszukiwacz;
                plansza[bohater.i][bohater.j] = pole::mur;
                bohater.j++;
                stan = stan_gry::zwyciestwo;
                return;
            }
            break;
        case 'Z':   // zapis gry
            ofstream plik;
            plik.open("gra.txt");
            // zapisywanie pozycji poszukiwacza:
            plik << bohater.i << ' ' << bohater.j << endl;
            // zapisywanie pozycji wrogów:
            for(short i = 0; i < 10; ++i)
                plik << przeciwnicy[i].i << ' ' << przeciwnicy[i].j << endl;
            // zapisywanie planszy:
            for(short i = 0; i < 33; ++i)
                for(short j = 0; j < 33; ++j)
                    plik << static_cast<int>(plansza[i][j]) << ' ';
            plik.close();
            cout << "Zapisano gre!\n";
            break;
        }
    }
}

void wypisz_plansze()
{
    for(short i = 0; i < N; ++i)
    {
        for(short j = 0; j < N; ++j)
        {
            switch(plansza[i][j])
            {
            case pole::puste:
                cout << ' ';
                break;
            case pole::mur:
                cout << '#';
                break;
            case pole::poszukiwacz:
                cout << 'O';
                break;
            case pole::skarb:
                cout << 'X';
                break;
            case pole::przeciwnik:
                cout << '@';
                break;
            }
            cout << ' ';
        }
        cout << endl;
    }
}

void nowa_gra()
{
    uzupelnij_plansze();
    system("cls");
    wypisz_plansze();
    while(stan == stan_gry::otwarta)
    {
        ruch_bohaterem();
        ruch_przeciwnikow();
        system("cls");      // wyzerowanie konsoli
        wypisz_plansze();
    }
    if(stan == stan_gry::zwyciestwo)
        cout << "Gratulacje! Wygrales/wygralas!\n";
    else
        cout << "Niestety, porazka :(\n";
}

void wczytaj_gre(ifstream& plik)
{
    short x;
    plik >> bohater.i >> bohater.j;
    for(short i = 0; i < 10; ++i)
        plik >> przeciwnicy[i].i >> przeciwnicy[i].j;
    for(short i = 0; i < 33; ++i)
        for(short j = 0; j < 33; ++j)
        {
            plik >> x;
            plansza[i][j] = static_cast<pole>(x);
        }
    stan = stan_gry::otwarta;

    system("cls");
    wypisz_plansze();
    while(stan == stan_gry::otwarta)
    {
        ruch_bohaterem();
        ruch_przeciwnikow();
        system("cls");      // wyzerowanie konsoli
        wypisz_plansze();
    }
    if(stan == stan_gry::zwyciestwo)
        cout << "Gratulacje! Wygrales/wygralas!\n";
    else
        cout << "Niestety, porazka :(\n";
}

int main()
{
    cout << "Witaj w grze!\n";
    cout << "Twoim celem jest dotarcie poszukiwaczem (O) do skarbu (X). Mozesz sie poruszac nastepujaco:\n";
    cout << "\tI - gora\n";
    cout << "\tJ - lewo\n";
    cout << "\tK - dol\n";
    cout << "\tL - prawo\n";
    cout << "\tZ - zapis stanu gry\n";
    cout << "Uwazaj na swoich wrogow (@), ktorzy rowniez sie poruszaja. Kontakt z ktoryms z nich oznacza przegrana!\n";
    cout << "Pamietaj, ze poruszajac sie, zostawiasz za soba mur (#), na ktory nikt nie moze wejsc. Powodzenia!\n";
    ifstream plik;
    plik.open("gra.txt");
    if(plik.good())
    {
        cout << endl;
        cout << "N - nowa gra\n";
        cout << "W - wczytaj zapisana gre\n";
        char komenda;
        do
        {
            komenda = _getch();
            komenda = toupper(komenda);
        } while(komenda != 'N' && komenda != 'W');
        if(komenda == 'N')
            nowa_gra();
        else
            wczytaj_gre(plik);
    }
    else
    {
        cout << "Wcisnij dowolny przycisk, aby rozpoczac gre...";
        _getch();
        nowa_gra();
    }
    return 0;
}