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

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');
        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;
        }
    }
}

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;
    }
}

int main()
{
    uzupelnij_plansze();
    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";
    return 0;
}