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

using namespace std;

const short N = 30;

enum class obiekt
{
    mur, pusty, poszukiwacz, wrog, skarb
};

enum class stan_gry
{
    otwarta, porazka, zwyciestwo
};

stan_gry stan;

struct koordynaty
{
    short x;
    short y;
};

void rysuj_plansze(obiekt plansza[][N])
{
    for(short i = 0; i < N + 2; ++i)
        cout << '-';
    cout << endl;
    for(short i = 0; i < N; ++i)
    {
        cout << '|';
        for(short j = 0; j < N; ++j)
        {
            switch(plansza[i][j])
            {
            case obiekt::mur:
                cout << '#';
                break;
            case obiekt::pusty:
                cout << ' ';
                break;
            case obiekt::poszukiwacz:
                cout << 'O';
                break;
            case obiekt::wrog:
                cout << '@';
                break;
            case obiekt::skarb:
                cout << 'X';
                break;
            }
        }
        cout << '|' << endl;
    }
    for(short i = 0; i < N + 2; ++i)
        cout << '-';
    cout << endl;
}

vector<koordynaty> wrogowie;
koordynaty bohater;
koordynaty cel;

vector<koordynaty> znajdz_puste(obiekt plansza[][N])
{
    koordynaty nowy;
    vector<koordynaty> wyniki;
    for(short i = 0; i < N; ++i)
        for(short j = 0; j < N; ++j)
        {
            if(plansza[i][j] == obiekt::pusty)
            {
                nowy.y = i;
                nowy.x = j;
                wyniki.push_back(nowy);
            }
        }
    return wyniki;
}

void wypelnij_plansze(obiekt plansza[][N], short ile_wrogow)
{
    for(short i = 0; i < N; ++i)
        for(short j = 0; j < N; ++j)
        {
            if(i % 2 == 0 && j % 2 == 0)
                plansza[i][j] = obiekt::mur;
            else
                plansza[i][j] = obiekt::pusty;
        }

    koordynaty nowy;

    // wypelnienie wrogami:
    wrogowie.clear();
    short ile_pustych;
    vector<koordynaty> puste;
    srand(static_cast<unsigned>(time(nullptr)));
    for(short i = 0; i < ile_wrogow; ++i)
    {
        puste = znajdz_puste(plansza);
        ile_pustych = puste.size();
        wrogowie.push_back(puste[rand() % ile_pustych]);
        nowy.x = wrogowie[i].x;
        nowy.y = wrogowie[i].y;
        plansza[nowy.y][nowy.x] = obiekt::wrog;
    }

    // dodanie poszukiwacza:
    puste = znajdz_puste(plansza);
    ile_pustych = puste.size();
    bohater = puste[rand() % ile_pustych];
    plansza[bohater.y][bohater.x] = obiekt::poszukiwacz;

    // dodanie skarbu:
    puste = znajdz_puste(plansza);
    ile_pustych = puste.size();
    cel = puste[rand() % ile_pustych];
    plansza[cel.y][cel.x] = obiekt::skarb;
}

vector<koordynaty> znajdz_dostepne_poszukiwacz(obiekt plansza[][N], koordynaty xy)
{
    vector<koordynaty> wyniki;
    koordynaty nowy;
    wyniki.clear();

    // w lewo
    if(xy.x > 0)
        if(plansza[xy.y][xy.x - 1] == obiekt::poszukiwacz)
        {
            nowy.x = xy.x - 1;
            nowy.y = xy.y;
            wyniki.push_back(nowy);
            return wyniki;
        }
    // w lewo i w górę
    if(xy.x > 0 && xy.y > 0)
        if(plansza[xy.y - 1][xy.x - 1] == obiekt::poszukiwacz)
        {
            nowy.x = xy.x - 1;
            nowy.y = xy.y - 1;
            wyniki.push_back(nowy);
            return wyniki;
        }
    // w górę
    if(xy.y > 0)
        if(plansza[xy.y - 1][xy.x] == obiekt::poszukiwacz)
        {
            nowy.x = xy.x;
            nowy.y = xy.y - 1;
            wyniki.push_back(nowy);
            return wyniki;
        }
    // w prawo i w górę
    if(xy.x < N - 1 && xy.y > 0)
        if(plansza[xy.y - 1][xy.x + 1] == obiekt::poszukiwacz)
        {
            nowy.x = xy.x + 1;
            nowy.y = xy.y - 1;
            wyniki.push_back(nowy);
            return wyniki;
        }
    // w prawo
    if(xy.x < N - 1)
        if(plansza[xy.y][xy.x + 1] == obiekt::poszukiwacz)
        {
            nowy.x = xy.x + 1;
            nowy.y = xy.y;
            wyniki.push_back(nowy);
            return wyniki;
        }
    // w prawo i w dół
    if(xy.x < N - 1 && xy.y < N - 1)
        if(plansza[xy.y + 1][xy.x + 1] == obiekt::poszukiwacz)
        {
            nowy.x = xy.x + 1;
            nowy.y = xy.y + 1;
            wyniki.push_back(nowy);
            return wyniki;
        }
    // w dół
    if(xy.y < N - 1)
        if(plansza[xy.y + 1][xy.x] == obiekt::poszukiwacz)
        {
            nowy.x = xy.x;
            nowy.y = xy.y + 1;
            wyniki.push_back(nowy);
            return wyniki;
        }
    // w lewo i w dół
    if(xy.x > 0 && xy.y < N - 1)
        if(plansza[xy.y + 1][xy.x - 1] == obiekt::poszukiwacz)
        {
            nowy.x = xy.x - 1;
            nowy.y = xy.y + 1;
            wyniki.push_back(nowy);
            return wyniki;
        }


    // puste pola:
    // w lewo
    if(xy.x > 0)
        if(plansza[xy.y][xy.x - 1] == obiekt::pusty)
        {
            nowy.x = xy.x - 1;
            nowy.y = xy.y;
            wyniki.push_back(nowy);
        }
    // w lewo i w górę
    if(xy.x > 0 && xy.y > 0)
        if(plansza[xy.y - 1][xy.x - 1] == obiekt::pusty)
        {
            nowy.x = xy.x - 1;
            nowy.y = xy.y - 1;
            wyniki.push_back(nowy);
        }
    // w górę
    if(xy.y > 0)
        if(plansza[xy.y - 1][xy.x] == obiekt::pusty)
        {
            nowy.x = xy.x;
            nowy.y = xy.y - 1;
            wyniki.push_back(nowy);
        }
    // w prawo i w górę
    if(xy.x < N - 1 && xy.y > 0)
        if(plansza[xy.y - 1][xy.x + 1] == obiekt::pusty)
        {
            nowy.x = xy.x + 1;
            nowy.y = xy.y - 1;
            wyniki.push_back(nowy);
        }
    // w prawo
    if(xy.x < N - 1)
        if(plansza[xy.y][xy.x + 1] == obiekt::pusty)
        {
            nowy.x = xy.x + 1;
            nowy.y = xy.y;
            wyniki.push_back(nowy);
        }
    // w prawo i w dół
    if(xy.x < N - 1 && xy.y < N - 1)
        if(plansza[xy.y + 1][xy.x + 1] == obiekt::pusty)
        {
            nowy.x = xy.x + 1;
            nowy.y = xy.y + 1;
            wyniki.push_back(nowy);
        }
    // w dół
    if(xy.y < N - 1)
        if(plansza[xy.y + 1][xy.x] == obiekt::pusty)
        {
            nowy.x = xy.x;
            nowy.y = xy.y + 1;
            wyniki.push_back(nowy);
        }
    // w lewo i w dół
    if(xy.x > 0 && xy.y < N - 1)
        if(plansza[xy.y + 1][xy.x - 1] == obiekt::pusty)
        {
            nowy.x = xy.x - 1;
            nowy.y = xy.y + 1;
            wyniki.push_back(nowy);
        }

    return wyniki;
}

void wykonaj_ruch(obiekt plansza[][N])
{
    char znak;
    bool flaga;
    do
    {
        flaga = true;
        znak = getch();
        znak = toupper(znak);
        switch(znak)
        {
        case 'P':       // pauza
            system("cls");
            cout << "Gra zostala zapauzowana. Wcisnij dowolny przycisk, aby kontynuowac...\n";
            getch();
            system("cls");
            rysuj_plansze(plansza);
            break;

        case 'I':       // poruszaj w gore
            if(bohater.y > 0)
                if(plansza[bohater.y - 1][bohater.x] == obiekt::pusty || plansza[bohater.y - 1][bohater.x] == obiekt::skarb)
                {
                    if(plansza[bohater.y - 1][bohater.x] == obiekt::skarb)
                    {
                        plansza[bohater.y][bohater.x] = obiekt::mur;
                        plansza[bohater.y - 1][bohater.x] = obiekt::poszukiwacz;
                        stan = stan_gry::zwyciestwo;
                        return;
                    }
                    plansza[bohater.y][bohater.x] = obiekt::mur;
                    plansza[bohater.y - 1][bohater.x] = obiekt::poszukiwacz;
                    --bohater.y;
                    flaga = false;
                }
            break;
        case 'J':       // poruszaj w lewo
            if(bohater.x > 0)
                if(plansza[bohater.y][bohater.x - 1] == obiekt::pusty || plansza[bohater.y][bohater.x - 1] == obiekt::skarb)
                {
                    if(plansza[bohater.y][bohater.x - 1] == obiekt::skarb)
                    {
                        plansza[bohater.y][bohater.x] = obiekt::mur;
                        plansza[bohater.y][bohater.x - 1] = obiekt::poszukiwacz;
                        stan = stan_gry::zwyciestwo;
                        return;
                    }
                    plansza[bohater.y][bohater.x] = obiekt::mur;
                    plansza[bohater.y ][bohater.x - 1] = obiekt::poszukiwacz;
                    --bohater.x;
                    flaga = false;
                }
            break;
        case 'K':       // poruszaj w dol
            if(bohater.y < N - 1)
                if(plansza[bohater.y + 1][bohater.x] == obiekt::pusty || plansza[bohater.y + 1][bohater.x] == obiekt::skarb)
                {
                    if(plansza[bohater.y + 1][bohater.x] == obiekt::skarb)
                    {
                        plansza[bohater.y][bohater.x] = obiekt::mur;
                        plansza[bohater.y + 1][bohater.x] = obiekt::poszukiwacz;
                        stan = stan_gry::zwyciestwo;
                        return;
                    }
                    plansza[bohater.y][bohater.x] = obiekt::mur;
                    plansza[bohater.y + 1][bohater.x] = obiekt::poszukiwacz;
                    ++bohater.y;
                    flaga = false;
                }
            break;
        case 'L':       // poruszaj w prawo
            if(bohater.x < N - 1)
                if(plansza[bohater.y][bohater.x + 1] == obiekt::pusty || plansza[bohater.y][bohater.x + 1] == obiekt::skarb)
                {
                    if(plansza[bohater.y][bohater.x + 1] == obiekt::skarb)
                    {
                        plansza[bohater.y][bohater.x] = obiekt::mur;
                        plansza[bohater.y][bohater.x + 1] = obiekt::poszukiwacz;
                        stan = stan_gry::zwyciestwo;
                        return;
                    }
                    plansza[bohater.y][bohater.x] = obiekt::mur;
                    plansza[bohater.y][bohater.x + 1] = obiekt::poszukiwacz;
                    ++bohater.x;
                    flaga = false;
                }
            break;
        }
    }
    while(flaga);
}

void wykonaj_ruch_wrogiem(koordynaty& przeciwnik, obiekt plansza[][N])
{
    vector<koordynaty> dostepne = znajdz_dostepne_poszukiwacz(plansza, przeciwnik);

    short dostepne_pola = dostepne.size();
    if(dostepne_pola == 0)
        return;
    if(dostepne_pola == 1)
    {
        if(plansza[dostepne[0].y][dostepne[0].x] == obiekt::poszukiwacz)
        {
            plansza[dostepne[0].y][dostepne[0].x] = obiekt::wrog;
            stan = stan_gry::porazka;
            return;
        }
        // opuszczenie pola
        plansza[przeciwnik.y][przeciwnik.x] = obiekt::pusty;
        // zajęcie nowego pola:
        przeciwnik = dostepne[0];
        plansza[przeciwnik.y][przeciwnik.x] = obiekt::wrog;
    }

    // wylosuj kierunek:
    srand(static_cast<unsigned>(time(nullptr)));
    short nr = rand() % dostepne_pola;
    // opuszczenie pola
    plansza[przeciwnik.y][przeciwnik.x] = obiekt::pusty;
    // zajęcie nowego pola:
    przeciwnik = dostepne[nr];
    plansza[przeciwnik.y][przeciwnik.x] = obiekt::wrog;
}

void ruszaj_wrogami(obiekt plansza[][N])
{
    short ilu_wrogow = wrogowie.size();
    for(short i = 0; i < ilu_wrogow; ++i)
        wykonaj_ruch_wrogiem(wrogowie[i], plansza);
}

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 << "\tP - pauza\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";
    obiekt plansza[N][N];
    cout << "Wpisz ilu chcesz przeciwnikow na planszy (od 1 do 9): ";
    short ilu_wrogow;
    cin >> ilu_wrogow;
    while(ilu_wrogow < 1 || ilu_wrogow > 9)
    {
        cout << "Wpisz liczbe od 1 do 9: ";
        cin >> ilu_wrogow;
    }

    wypelnij_plansze(plansza, ilu_wrogow);

    stan = stan_gry::otwarta;

    cout << "Wcisnij dowolny przycisk, aby rozpoczac gre...";
    getch();
    system("cls");

    while(stan == stan_gry::otwarta)
    {
        rysuj_plansze(plansza);
        wykonaj_ruch(plansza);
        ruszaj_wrogami(plansza);
        system("cls");
    }
    rysuj_plansze(plansza);
    if(stan == stan_gry::porazka)
        cout << "Niestety, przegrales!\n";
    else
        cout << "Brawo! Wygrales!\n";

    return 0;
}