Моделирование процессов на карте

///----------------------------------------------------------------------------|
/// WildWorld version 0.0.1
/// Задача смоделировать процесс жизни зайцев и волков на карте.
///----------------------------------------------------------------------------:
#include <iostream>
#include <list>
#include <ctime>
#include <cstdio>
#include <conio.h>
 
#include "test_list.h"
 
#define FORi(n)  for (int i = 0; i < n; ++i)
#define FORj(n)  for (int j = 0; j < n; ++j)
#define LOG(v)   Log (#v, v)
#define ENDL(v)  FORi(v)std::cout << "\n"
#define DEBUG(v) Log ("DEBUG: signal!", v); _getch();
#define ERRORPRINT_IF(iff) if(iff)\
{   std::cout << "ERROR: " << __FUNCTION__ << ": " << #iff << "\n"; _getch();\
}
#define BEEP std::cout << "\a"
 
struct smystart
{   smystart()
    {   setlocale(0, "");
        srand((unsigned int)time(NULL));
    }
}mystart;
 
#include <windows.h>
///----------------------------------------------------------------------------|
/// Класс для ускорения вывода в консоль.
///----------------------------------------------------------------------------:
class cConsole
{   HANDLE hout;
public:
    cConsole()
    {   hout = GetStdHandle(STD_OUTPUT_HANDLE);
        system("mode 80,70");
    }
 
    void setcursor(short x, short y)///-----------------------------:setcursor()
    {   COORD coord = {x, y};
            SetConsoleCursorPosition(hout, coord);
    }
 
    int cls()///----------------------------------------------------------:cls()
    {   char c = ' ';
        DWORD dwLength;  // количество заполняемых клеток
        DWORD dwWritten; // для количества заполенных клеток
 
        CONSOLE_SCREEN_BUFFER_INFO csbi; // для параметров буфера экрана
        // читаем параметры выходного буфера
        if (!GetConsoleScreenBufferInfo(hout, &csbi))
        {   std::cout << "ERROR: Console screen buffer info failed.\n";
            return GetLastError();
        }
 
        // вычисляем размер буфера экрана в символах
      //dwLength = csbi.dwSize.X * csbi.dwSize.Y;
        dwLength = csbi.dwSize.X * 40;
 
        COORD coord;     // координаты первой клетки
        coord.X = 0;
        coord.Y = 43;
 
        // заполняем буфер экрана символом-заполнителем
        if (!FillConsoleOutputCharacter(
                hout,        // стандартный дескриптор вывода
                c,           // символ заполнения
                dwLength,    // длина буфера в символах
                coord,       // индекс первой клетки
                &dwWritten)) // количество заполненных клеток
        {   std::cout << "ERROR: Fill console output character failed.\n";
            return GetLastError();
        }
        return 0;
    }
 
    void set_buffer_size()///---------------------------------:set_buffer_size()
    {   std::cout << "set_buffer_size()\n";
        getchar();
        COORD  size;
        size.X =  90;   // кол-во символов на строку
        size.Y =  1001; // увеличиваем до 1000 - строк, можно хоть 2000
        SetConsoleScreenBufferSize(hout,  size);
        //getchar();
    }
 
    int print(char* buffer, std::size_t size_buffer, short x, short y)
    {   COORD dwWriteCoord = {x, y};
        DWORD nNumberOfCharsWritten;
 
        if (!WriteConsoleOutputCharacter(
                hout,
                buffer,
                size_buffer,
                dwWriteCoord,
                &nNumberOfCharsWritten))
        {   std::cout << "ERROR: Read console output character failed.\n";
            return GetLastError();
        }
    }
 
}console;
 
template<class T1, class T2>
void Log(T1 s, T2 v)
{   std::cout << s << " = " << v << "\n";
}
template<class T>
void Log(T v)
{   std::cout << v << "\n";
}
 
int rrand(int max, int min = 0)
{   return rand() % (max - min + 1) + min;
}
 
struct sCoord
{   int x, y;
    bool operator==(const sCoord& c)
    {   return (c.x == x)&&(c.x == y);
    }
};
 
///----------------------------------------------------------------------------|
/// Над диким миром зверей всегда(образно) светит солнце.
///----------------------------------------------------------------------------:
namespace Sun
{
    static const unsigned AM_WOLF_START    = 5;
    static const unsigned AM_RABBIT_START  = 15;
    static const unsigned AM_ANIMALS_START = AM_WOLF_START + AM_RABBIT_START;
 
    int amount_all    = AM_ANIMALS_START,
        amount_rabbit = AM_RABBIT_START,
        amount_wolf   = AM_WOLF_START;
 
    unsigned tic_tac  = 0; // Время истории...
};
 
///----------------------------------------------------------------------------|
/// Карта.
///----------------------------------------------------------------------------:
class cMap
{
public:
    cMap()
    {   clear();
    }
 
    static const unsigned XMAX = 70,
                          YMAX = 40;
    char m[YMAX][XMAX+1];
    void show()
    {   system("cls");
        std::cout << "show()\n ";
        FORi(XMAX)std::cout << '-'; std::cout << "\n";
        char buffer[XMAX+1];
        buffer[XMAX] = 0; ///<<<---|
        FORi(YMAX)
        {   std::cout << "|";
            FORj(XMAX)
            {   buffer[j] = m[i][j]; ///<<<------------------------------------|
                //std::cout << m[i][j];
            }
            console.print(buffer, XMAX, 1 , i + 2 );
            //std::cout << buffer;
            console.setcursor(XMAX+1, i + 2); std::cout << "|\n";
        }
        std::cout << " ";
        FORi(70)std::cout << '-';
    }
 
    void show_optima()
    {
        char buffer[XMAX+1];
        buffer[XMAX] = 0; ///<<<---|
        FORi(YMAX)
        {   FORj(XMAX)
            {   buffer[j] = m[i][j]; ///<<<------------------------------------|
                //std::cout << m[i][j];
            }
            console.print(buffer, XMAX, 1 , i + 2 );
            //std::cout << buffer;
            console.setcursor(XMAX+1, i + 2);
        }
    }
 
    void set(const sCoord& c, char s)
    {   m[c.y][c.x] = s;
    }
 
    void clear()
    {   FORi(YMAX)
        {   FORj(XMAX)
            {   m[i][j] = ' ';
            }
        }
    }
 
    sCoord get_step(sCoord& c)
    {   set(c, ' ');
        int step = rrand(7);
        switch(step)
        {   case 0: if(c.x < XMAX-1) c.x++; break;
            case 1: if(c.x > 0     ) c.x--; break;
            case 2: if(c.y < YMAX-1) c.y++; break;
            case 3: if(c.y > 0     ) c.y--; break;
 
            case 4: if(c.x < XMAX-1 && c.y < YMAX-1) { c.x++; c.y++; } break;
            case 5: if(c.x < XMAX-1 && c.y > 0     ) { c.x++; c.y--; } break;
            case 6: if(c.y < YMAX-1 && c.x > 0     ) { c.x--; c.y++; } break;
            case 7: if(c.y > 0      && c.x > 0     ) { c.x--; c.y--; } break;
        }
        /// TODO ?
        ERRORPRINT_IF((c.x == XMAX || c.y == YMAX || c.y < 0 || c.x < 0));
        return c;
    }
}
/// TODO: убрать из глобала.
mapa;
 
///----------------------------------------------------------------------------|
/// Движение.
///----------------------------------------------------------------------------:
class cMoved
{       /// Пока неиспользуются:
        float alfa;
        int   step;
        static const unsigned STEPMAX = 10;
public:
    sCoord coord;
 
    cMoved()
    {   coord.x   = rrand(cMap::XMAX - 2);
        coord.y   = rrand(cMap::YMAX - 1);
    }
 
    void let_move(char s)
    {   coord = mapa.get_step(coord);
        mapa.set(coord, s);
    }
};
 
///----------------------------------------------------------------------------|
/// Animal
///----------------------------------------------------------------------------:
class cAnimal
{
public:
    enum eVID
    {   VID_WOLF = 1,
        VID_RABBIT
    }VID;
 
    cAnimal() : age(0)
    {
    }
    virtual  ~cAnimal() {};
    virtual void info()
    {  std::cout << "Animal.";
    }
    virtual void let_move(){  std::cout << "virtual void let_move()\n";}
 
    int age;
    cMoved moved;
 
    void infoo()
    {   std::cout << ((VID == VID_WOLF) ? "Волк" : "Заяц");
        std::cout << ":    x = " << moved.coord.x
                  << ", \ty = "  << moved.coord.y << "\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Волк
///----------------------------------------------------------------------------:
class cWolf: public cAnimal
{   int id;
public:
    cWolf()
    {   VID = VID_WOLF;
        mapa.set(moved.coord, 'F');
    }
    void info()
    {   std::cout << "Wolf.";
    }
    void let_move()
    {   moved.let_move('F');
    }
};
 
///----------------------------------------------------------------------------|
/// Заяц
///----------------------------------------------------------------------------:
class cRabbit : public cAnimal
{   int id;
public:
    cRabbit()
    {   VID = VID_RABBIT;
        mapa.set(moved.coord, 'o');
    }
 
    void info()
    {   std::cout << "Rabbit.";
    }
 
    void let_move()
    {   moved.let_move('o');
    }
};
 
///----------------------------------------------------------------------------|
/// Хранилище зверей.
///----------------------------------------------------------------------------:
class cSalvatory
{
    std::list<cAnimal*> mylist;
public:
    cSalvatory()
    {   std::cout << __FUNCTION__ << "\n";
        for(int i = 0; i < Sun::AM_WOLF_START; ++i)
        {   cAnimal* p = new cRabbit();
            mylist.push_back(p);
                     p = new cWolf();
            mylist.push_back(p);
        }
        for(int i = 0; i < Sun::AM_RABBIT_START - Sun::AM_WOLF_START; ++i)
        {   cAnimal* p = new cRabbit();
            mylist.push_back(p);
        }
        //show();
    }
 
    bool make_behavior()
    {   let_move();
 
        std::list<cAnimal*>::iterator temp;
 
        auto e1 = --mylist.end();
        auto s2 = ++mylist.begin();
        for     (auto it1 = mylist.begin(); it1 != e1;           it1++)
        {   for (auto it2 = s2;             it2 != mylist.end(); it2++)
            {
                if((*it1)->moved.coord == (*it2)->moved.coord)
                {   ///--------------------------------------|
                    /// TODO: Добавить все проверки тут!     |
                    ///--------------------------------------:
                    ///...
                    int who = (*it1)->VID & (*it2)->VID;
                    switch(who)
                    {   case 0:
                        {   std::cout << "Волк встретил Зайца! ";
                            ///------------------------------|
                            /// Ху из ху?                    |
                            ///------------------------------|
                            cAnimal* p;
                            BEEP;
                            if((*it1)->VID == cAnimal::VID_RABBIT)
                            {   p = *it1;
                                mylist.erase(it1);
                            }
                            else
                            {   p = *it2;
                                mylist.erase(it2);
                            }
                            std::cout << " ... ... ... зайца СЪЕЛИ!!!\n";
                            delete p;
                            Sun::amount_rabbit--;
                            return true;
                        }
 
                        case cAnimal::VID_WOLF:
                        {
                            std::cout << "Два волка встретились! ";
                            cAnimal* p = new cWolf();
                            mylist.insert(it1, p);
                            Sun::amount_wolf++;
                            std::cout << "... волк родился.\n";
                            return true;
                        }
 
                        case cAnimal::VID_RABBIT:
                        {
                            std::cout << "Два зайца встретились! ";
                            cAnimal* p = new cRabbit();
                            mylist.insert(it1, p);
                            Sun::amount_rabbit++;
                            std::cout << "... заяц родился!.\n";
                            return true;
                        }
 
                        default:
                            std::cout << "\nERROR: мутанты?\n";
                    }
                }
            }
        }
        return false;
    }
 
    std::size_t get_amount()
    {   return mylist.size();
    }
 
    void show()
    {   ///-------------------------|
        ///Ограничить показ кол-ом. |
        ///-------------------------:
        int border = 15;
 
        int i = 1;
        for (auto it = mylist.begin(); it != mylist.end(); it++)
        {   //std::cout << it->VID << " ";
            std::cout << i << "\t"; //(*it)->info();
            (*it)->infoo();
            i++;
            if(border-- == 0) break;
        }
        std::cout << "\n";
    }
 
private:
    void let_move()
    {   for (auto it = mylist.begin(); it != mylist.end(); it++)
        {   //cAnimal* p = &(*it);
            (*it)->let_move();
        }
    }
};
 
///----------------------------------------------------------------------------|
/// Мир
///----------------------------------------------------------------------------:
class cWorld
{   cSalvatory salvatory;
public:
    cWorld()
    {   init();
        mapa.show();
        while(true)
        {   mapa.show_optima();
            //mapa.show();
 
            console.setcursor(0,43);
            std::cout << "\nВремя истории. День: " << Sun::tic_tac << "\n"
                      << "Общая численность зверей: "
                      << salvatory.get_amount()          << "\n"
                      << "Волки: " << Sun::amount_wolf   << "\n"
                      << "Зайцы: " << Sun::amount_rabbit << "\n";
            //salvatory.show();
 
            ///--------------------------------|
            /// Пока кто-то кого-то встретил.  |
            ///--------------------------------:
            bool b = true;
            while(salvatory.make_behavior())
            {   b = false;
            }
            if(b) std::cout << "\nТихо в лесу!\n";
            Sun::amount_all = Sun::amount_wolf + Sun::amount_rabbit;
 
            if(Sun::amount_all > 100)
            {   std::cout << "\nАХТУНГ: Перенаселение!";
                _getch();
            }
            Sleep(200);
 
            ///------------------------|
            /// Тик времени истории.   |
            ///------------------------:
            Sun::tic_tac++;
            console.cls();
        }
    }
 
    void foo()
    {   std::cout << "World\n";
    }
    void init(){}
};
 
///----------------------------------------------------------------------------|
/// Start
///----------------------------------------------------------------------------:
int main()
{
    cWorld world;
 
    std::cin.get();
    return 0;
}