GAME VIRUS CROSSSPLATFORM-RELEASE!

#include <cassert>
#include <random>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <clocale>
#ifdef _WIN32
    #include <windows.h>
#endif
using namespace std;

const string space = ".";       /// It should be given in templates...

typedef long long ll;
#define read                cin
#define eol                 '\n'
#define endln               cout << eol
#define all(x)              begin(x), end(x)
template <class A>              inline void print   (A a)           { cout << a << ' '; }
template <class A>              inline void println (A a)           { cout << a << eol; }
template <class A, class... B>  inline void println (A a, B... b)   { print(a); println(b...); }
template <class A>              inline void err     (A a)         { cerr << a << ' '; }
template <class A>              inline void errln   (A a)         { cerr << a << eol; }
template <class A, class... B>  inline void errln   (A a, B... b) { err(a); errln(b...); }



////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////



template <
ostream &out,
size_t hSize = 10,
size_t wSize = 10,
size_t sparse = 1
>

class MatrixPrinter
{
    private:

    string M[hSize][wSize];

    public:

    void print (size_t iS = 0, size_t iF = hSize,
                size_t jS = 0, size_t jF = wSize)
    {
        out << string(8*(jF - jS + 1)+1, '-') << eol;

        out << "№\t";
        for (size_t j = jS; j < jF; ++ j)
        if (j % sparse == 0)
            out << '\t' << j;
        else
            out << "        ";
        out << eol;
        out << " \t+-------";
        for (size_t j = jS + 1; j < jF; ++ j)
            out << "+-------";
        out << "+" << eol;

        for (size_t i = iS; i < iF; ++ i)
        {
            out << i << "\t|";
            for (size_t j = jS; j < jF; ++ j)
                out << '\t' << M[i][j];
            out << eol;
        }
        out << string(8*(jF - jS + 1)+1, '-') << eol;
    }

    void setPoint (size_t i, size_t j, string c)
    {   M[i][j] = c;    }

    string getPoint (size_t i, size_t j)
    {
        if (i < hSize && j < wSize)
            return M[i][j];
        return "";
    }

    MatrixPrinter ()
    {
        for (size_t i = 0; i < hSize; ++ i)
            for (size_t j = 0; j < wSize; ++ j)
                M[i][j] = space;
    }
};



////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////



const bool  LOG_TO_FILE     = false;
const  size_t   I           = 80,   /// Field size
                J           = 50,
                K           = 3;    /// Points per turn

const string    a   =   "м",
                b   =   "ж",
                A   =   "М",
                B   =   "Ж";
MatrixPrinter<cout, I, J> mp;

size_t  dView = 10,
        iView = 10,
        jView = 10;


//  #define DEBUG_INFO
#ifdef      DEBUG_INFO
    #define addLog(...) errln("[ log ]   ", __VA_ARGS__)
#else
    #define addLog(...) (void(0))
#endif


bool        FIRST_PLAYER    = false;
void initialize ()
{
    #ifdef DEBUG_INFO
        if (LOG_TO_FILE)
            freopen("log.txt", "w", stderr);
    #endif

    println("Привет!");
    println("Будете играть за првого игрока? (1 = да, 0 = нет)");
    read >> FIRST_PLAYER;
    println("Вы ответили:", FIRST_PLAYER);


    mp.setPoint(0, 0, a);
    mp.setPoint(I - 1, J - 1, b);
    mp.print(iView - dView, iView + dView, jView - dView, jView + dView);
}

struct crypto_t
{
    mt19937 getRand;
    const ll MUL = 10;

    crypto_t (ll s) :   getRand(s)      {}
    crypto_t ()     :   crypto_t(19)    {}

    inline size_t zip (size_t i, size_t j)
    {
        size_t result = MUL*i + j;
        return result;
    }
    void unzip (size_t n, size_t &i, size_t &j)
    {
        i = n / MUL;
        j = n % MUL;
    }
}; crypto_t crypto;


bool checkPoint (size_t i, size_t j, string c)
{
    return mp.getPoint(i, j + 1) == c
        || mp.getPoint(i, j - 1) == c
        || mp.getPoint(i + 1, j) == c
        || mp.getPoint(i - 1, j) == c;
}


bool canGo (ll i, ll j)
{
    if (    mp.getPoint(i, j) == a
        ||  mp.getPoint(i, j) == A )
    {
        println("[ X ] Клетка уже принадлежит вам.");
        return false;
    }
    if ( checkPoint(i, j, a) )
    {
        if ( mp.getPoint(i,j) == B )
        {
            println("[ X ] Там вражеская крепость (её нельзя съесть). ");
            return false;
        }
        println("[ V ] Можно ходить.");
        return true;
    } else
    {
        if ( checkPoint(i, j, A) )
        {
            println("[ ? ] Проверьте 'живую связь' крепости.");
            println("Крепость соединена?");
            string ans; read >> ans;
            return (ans == "yes" || ans == "Yes" || ans == "YES" || ans == "1");
        }
        println("[ X ] Эта точка не соединена с живыми вирусами.");
        return false;
    }
}


bool usrGo (ll i, ll j)
{
    if (canGo(i, j))
    {
        if (mp.getPoint(i,j) == space)  mp.setPoint(i, j, a);
        if (mp.getPoint(i,j) == b)      mp.setPoint(i, j, A);
        mp.print(   iView - dView, iView + dView,
                    jView - dView, jView + dView);
        return true;

    } else
    {
        println("Попробуйте ещё раз...");
        return false;
    }
}


ll usrTurn ()
{
    ll i, j;
    do { read >> i >> j; }
    while (! usrGo(i, j));
    return crypto.zip(i, j);
}


void netTurn (size_t net)
{
    size_t i, j;
    crypto.unzip(net, i, j);
    i = I-1 - i;            /// reversing
    j = J-1 - j;            /// reversing
    println("Противник ходит", i, j);
    if (mp.getPoint(i, j) == a)     mp.setPoint(i, j, B);
    if (mp.getPoint(i, j) == space) mp.setPoint(i, j, b);
}


void letMove ()
{
    println("Если хотите сдвинуть миникарту, наберите непустую строку.");
    string moving;
    getline(cin, moving);
    getline(cin, moving);
    if (moving > "") {
        println("Движение ведётся до набора 'end'.");
        println("Используйте w, a, s, d и число (длину прыжка).");
        size_t len;
        read >> moving >> len;
        while (moving != "end") {
            if (moving == "w") {
                iView = max(ll(dView), ll(iView - len));
            } else if (moving == "a") {
                jView = max(ll(dView), ll(jView - len));
            } else if (moving == "s") {
                iView = min(ll(I-dView), ll(iView + len));
            } else if (moving == "d") {
                jView = min(ll(J-dView), ll(jView + len));
            }
            mp.print(   iView - dView, iView + dView,
                        jView - dView, jView + dView);
            read >> moving >> len;
        }
    }
}
int main ()
{
    #ifdef _WIN32
        SetConsoleCP(1251);
        SetConsoleOutputCP(1251);
        cout << "Кажется это Windows." << endl;
    #else
        setlocale(0, "");
        cout << "Кажется это Linux." << endl;
    #endif
    initialize();

    for (ll turns = 1; turns <= 1024; )
    {
        if (FIRST_PLAYER) {
            letMove();
            println("\n\n\nХод #", turns ++);
            for (ll i=K;i--;) println("\t\t\t\t\tКод этого хода:", usrTurn());
        }
            println("\n\n\nХод #", turns ++); ll n;
            println("Ожидание хода противиника.");
            letMove();
            for (ll i=K;i--;) read >> n, netTurn(n);
            mp.print(   iView - dView, iView + dView,
                        jView - dView, jView + dView);

        if ( ! FIRST_PLAYER) {
            letMove();
            println("\n\n\nХод #", turns ++);
            for (ll i=K;i--;) println("\t\t\t\t\tКод этого хода:", usrTurn());
        }
    }

    return 0;
}