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

using namespace std;

const int N = 33;

struct koordynaty
{
    int x;
    int y;
};

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

enum class stan_gry
{
    gra_otwarta, koniec_zwyciestwo, koniec_porazka
};

stan_gry stan = stan_gry::gra_otwarta;
pole tablica[N][N];
vector<koordynaty> przeciwnicy;
koordynaty bohater;
koordynaty cel;

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

void uzupelnienie(int ilosc_przeciwnikow)
{
    srand(time(NULL));

    vector<koordynaty> puste_pola;
    koordynaty nowy;

    for(int i = 0; i < N ; i++)
    {
        for(int j = 0; j < N; j++)
        {
            if(i == 0 || i == N - 1 || j == 0 || j == N - 1)
            {
                tablica[i][j] = pole::mur;
                continue;
            }
            if(i % 2 == 0 && j % 2 == 0)
                tablica[i][j] = pole::mur;
            else
            {
                tablica[i][j] = pole::puste;
                nowy.x = j;
                nowy.y = i;
                puste_pola.push_back(nowy);
            }
        }
    }

    int liczba_pustych = puste_pola.size();
    int numer = rand() % liczba_pustych;
    nowy = puste_pola[numer];
    cel = nowy;
    tablica[nowy.y][nowy.x] = pole::skarb;
    puste_pola.erase(puste_pola.begin() + numer);

    liczba_pustych = puste_pola.size();
    numer = rand() % liczba_pustych;
    nowy = puste_pola[numer];
    bohater = nowy;
    tablica[nowy.y][nowy.x] = pole::poszukiwacz;
    puste_pola.erase(puste_pola.begin() + numer);

    while(ilosc_przeciwnikow >= 0)
    {
        liczba_pustych = puste_pola.size();
        numer = rand() % liczba_pustych;
        nowy = puste_pola[numer];
        przeciwnicy.push_back(nowy);
        tablica[nowy.y][nowy.x] = pole::przeciwnik;
        puste_pola.erase(puste_pola.begin() + numer);

        ilosc_przeciwnikow--;
    }

}

vector<koordynaty> dostepne_pola_przeciwnika(koordynaty przeciwnik)
{
    vector<koordynaty> wynik;
    wynik.clear();
    koordynaty nowy;

    // sprawdzenie czy przeciwnik może wejść na pole z poszukiwaczem:
    // w lewo i w górę
    if(tablica[przeciwnik.y - 1][przeciwnik.x - 1] == pole::poszukiwacz)
    {
        nowy.y = przeciwnik.y - 1;
        nowy.x = przeciwnik.x - 1;
        wynik.push_back(nowy);
        return wynik;
    }
    // w górę
    if(tablica[przeciwnik.y - 1][przeciwnik.x] == pole::poszukiwacz)
    {
        nowy.y = przeciwnik.y - 1;
        nowy.x = przeciwnik.x;
        wynik.push_back(nowy);
        return wynik;
    }
    // w prawo i w górę
    if(tablica[przeciwnik.y - 1][przeciwnik.x + 1] == pole::poszukiwacz)
    {
        nowy.y = przeciwnik.y - 1;
        nowy.x = przeciwnik.x + 1;
        wynik.push_back(nowy);
        return wynik;
    }
    // w prawo
    if(tablica[przeciwnik.y][przeciwnik.x + 1] == pole::poszukiwacz)
    {
        nowy.y = przeciwnik.y;
        nowy.x = przeciwnik.x + 1;
        wynik.push_back(nowy);
        return wynik;
    }
    // w prawo i w dół
    if(tablica[przeciwnik.y + 1][przeciwnik.x + 1] == pole::poszukiwacz)
    {
        nowy.y = przeciwnik.y + 1;
        nowy.x = przeciwnik.x + 1;
        wynik.push_back(nowy);
        return wynik;
    }
    // w dół
    if(tablica[przeciwnik.y + 1][przeciwnik.x] == pole::poszukiwacz)
    {
        nowy.y = przeciwnik.y + 1;
        nowy.x = przeciwnik.x;
        wynik.push_back(nowy);
        return wynik;
    }
    // w lewo i w dół
    if(tablica[przeciwnik.y + 1][przeciwnik.x - 1] == pole::poszukiwacz)
    {
        nowy.y = przeciwnik.y + 1;
        nowy.x = przeciwnik.x - 1;
        wynik.push_back(nowy);
        return wynik;
    }
    // w lewo
    if(tablica[przeciwnik.y][przeciwnik.x - 1] == pole::poszukiwacz)
    {
        nowy.y = przeciwnik.y;
        nowy.x = przeciwnik.x - 1;
        wynik.push_back(nowy);
        return wynik;
    }

    // poszukiwanie pustych pól:
    // w lewo i w górę
    if(tablica[przeciwnik.y - 1][przeciwnik.x - 1] == pole::puste)
    {
        nowy.y = przeciwnik.y - 1;
        nowy.x = przeciwnik.x - 1;
        wynik.push_back(nowy);
    }
    // w górę
    if(tablica[przeciwnik.y - 1][przeciwnik.x] == pole::puste)
    {
        nowy.y = przeciwnik.y - 1;
        nowy.x = przeciwnik.x;
        wynik.push_back(nowy);
    }
    // w prawo i w górę
    if(tablica[przeciwnik.y - 1][przeciwnik.x + 1] == pole::puste)
    {
        nowy.y = przeciwnik.y - 1;
        nowy.x = przeciwnik.x + 1;
        wynik.push_back(nowy);
    }
    // w prawo
    if(tablica[przeciwnik.y][przeciwnik.x + 1] == pole::puste)
    {
        nowy.y = przeciwnik.y;
        nowy.x = przeciwnik.x + 1;
        wynik.push_back(nowy);
    }
    // w prawo i w dół
    if(tablica[przeciwnik.y + 1][przeciwnik.x + 1] == pole::puste)
    {
        nowy.y = przeciwnik.y + 1;
        nowy.x = przeciwnik.x + 1;
        wynik.push_back(nowy);
    }
    // w dół
    if(tablica[przeciwnik.y + 1][przeciwnik.x] == pole::puste)
    {
        nowy.y = przeciwnik.y + 1;
        nowy.x = przeciwnik.x;
        wynik.push_back(nowy);
    }
    // w lewo i w dół
    if(tablica[przeciwnik.y + 1][przeciwnik.x - 1] == pole::puste)
    {
        nowy.y = przeciwnik.y + 1;
        nowy.x = przeciwnik.x - 1;
        wynik.push_back(nowy);
    }
    // w lewo
    if(tablica[przeciwnik.y][przeciwnik.x - 1] == pole::puste)
    {
        nowy.y = przeciwnik.y;
        nowy.x = przeciwnik.x - 1;
        wynik.push_back(nowy);
    }
    return wynik;
}

void poruszanie_przeciwnikiem(unsigned nr)  // nr - nr przeciwnika
{
    vector<koordynaty> kierunki = dostepne_pola_przeciwnika(przeciwnicy[nr]);
    unsigned ile_mozliwosci = kierunki.size();

    if(ile_mozliwosci == 0)
        return;

    koordynaty ruch = przeciwnicy[nr];
    if(ile_mozliwosci == 1)
    {
        // poruszamy się na jedyne dostępne pole:
        // czyścimy pole na którym znajduje się obecnie:
        tablica[ruch.y][ruch.x] = pole::puste;
        // wykonujemy ruch:
        ruch = kierunki[0];

        // sprawdzamy czy nie jest to ruch na pole z poszukiwaczem:
        if(tablica[ruch.y][ruch.x] == pole::poszukiwacz)
            stan = stan_gry::koniec_porazka;
        tablica[ruch.y][ruch.x] = pole::przeciwnik;
        // aktualizujemy położenie:
        przeciwnicy[nr] = ruch;
        return;
    }

    // więcej niż 1 możliwość:
    srand(time(nullptr));
    int numer = rand() % ile_mozliwosci;
    tablica[ruch.y][ruch.x] = pole::puste;
    // wykonujemy ruch:
    ruch = kierunki[numer];
    tablica[ruch.y][ruch.x] = pole::przeciwnik;
    // aktualizujemy położenie:
    przeciwnicy[nr] = ruch;
}

void poruszanie_poszukiwaczem()
{
    char direction;
    bool flaga;

    do
    {
        flaga = true;

        do
        {
            direction = getch();
            direction = toupper(direction);

        }
        while(direction != 'J' && direction != 'K' && direction != 'L' && direction != 'I');

        switch(direction)
        {
        case 'J':
            // w lewo
            if(bohater.x > 1 && tablica[bohater.y][bohater.x - 1] != pole::mur && tablica[bohater.y][bohater.x - 1] != pole::przeciwnik)
            {
                tablica[bohater.y][bohater.x] = pole::mur;
                --bohater.x;
                tablica[bohater.y][bohater.x] = pole::poszukiwacz;
                flaga = false;
            }
            break;
        case 'I':
            // w górę
            if(bohater.y > 1 && tablica[bohater.y - 1][bohater.x] != pole::mur && tablica[bohater.y - 1][bohater.x] != pole::przeciwnik)
            {
                tablica[bohater.y][bohater.x] = pole::mur;
                --bohater.y;
                tablica[bohater.y][bohater.x] = pole::poszukiwacz;
                flaga = false;
            }
            break;
        case 'L':
        // w prawo
        if(bohater.x < 31 && tablica[bohater.y][bohater.x + 1] != pole::mur && tablica[bohater.y][bohater.x + 1] != pole::przeciwnik)
            {
                tablica[bohater.y][bohater.x] = pole::mur;
                ++bohater.x;
                tablica[bohater.y][bohater.x] = pole::poszukiwacz;
                flaga = false;
            }
            break;
        case 'K':
            // w dół
            if(bohater.y < 31 && tablica[bohater.y + 1][bohater.x] != pole::mur && tablica[bohater.y + 1][bohater.x] != pole::przeciwnik)
            {
                tablica[bohater.y][bohater.x] = pole::mur;
                ++bohater.y;
                tablica[bohater.y][bohater.x] = pole::poszukiwacz;
                flaga = false;
            }
        }

    }
    while(flaga);

    if(bohater == cel)
        stan = stan_gry::koniec_zwyciestwo;
}

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

    cout << endl;
    cout << bohater.x << '\t' << bohater.y << endl;
}

void ruch_przeciwnikami()
{
    unsigned ile = przeciwnicy.size();
    for(unsigned i = 0; i < ile; ++i)
        poruszanie_przeciwnikiem(i);
}

int main()
{
    int ilosc_przeciwnikow;

    cout << "Podaj ilosc przeciwnikow: " << endl;
    cin >> ilosc_przeciwnikow;

    uzupelnienie(ilosc_przeciwnikow);

    do
    {
        system("cls");          // odświeżenie konsoli
        wypisz_plansze();
        poruszanie_poszukiwaczem();
        ruch_przeciwnikami();
    }
    while(stan == stan_gry::gra_otwarta);

    return 0;
}