Доработка кода игры "Жизнь"

std::system("clear");

<cstdlib>

sleep(время задержки в сек);

<unistd.h>

#include <iostream>
#include <fstream>
#include <thread>
 
 
 
#define FILL_CHAR 219
#define EMPTY_CHAR 255
 
void print(unsigned int generation, char* print_arr) {
    printf("Generation:%i\n%s\n", generation, print_arr);
}
 
bool equals(bool* array1, bool* array2, unsigned int n, unsigned int m) {
    for (unsigned int i = 0; i < n; i++)
        for (unsigned int j = 0; j < m; j++)
            if (array1[i * m + j] != array2[i * m + j])
                return false;
    return true;
}
unsigned short inline get(bool* array, unsigned int n, unsigned int m, unsigned int x, unsigned int y) {
    if (x < 1 || y < 1 || x > m || y > n) return 0;
    return array[(y - 1) * m + (x - 1)];
}
 
void process_output(bool* array1, bool* array2, char* print_arr, unsigned int n, unsigned int m) {
#pragma omp parallel for
    for (__int64 i = 0; i < (__int64)n; i++)
    {
        for (unsigned int j = 0; j < m; j++) {
            unsigned short alive_near = get(array1, n, m, j, i) +
                get(array1, n, m, j, i + 1) +
                get(array1, n, m, j, i + 2) +
                get(array1, n, m, j + 1, i) +
                get(array1, n, m, j + 1, i + 2) +
                get(array1, n, m, j + 2, i) +
                get(array1, n, m, j + 2, i + 1) +
                get(array1, n, m, j + 2, i + 2);
 
            if (alive_near > 3)
            {
                array2[i * m + j] = false;
                print_arr[i * (m + 1) + j] = EMPTY_CHAR;
            }
            else if (alive_near > 2)
            {
                array2[i * m + j] = true;
                print_arr[i * (m + 1) + j] = FILL_CHAR;
            }
            else if (alive_near > 1)
            {
                array2[i * m + j] = array1[i * m + j];
                print_arr[i * (m + 1) + j] = array1[i * m + j] ? FILL_CHAR : EMPTY_CHAR;
            }
            else {
                array2[i * m + j] = false;
                print_arr[i * (m + 1) + j] = EMPTY_CHAR;
            }
        }
        print_arr[m + i * (m + 1)] = '\n';
    }
    print_arr[n * (m + 1) - 1] = '\0';
}
 
void process_no_output(bool* array1, bool* array2, unsigned int n, unsigned int m) {
#pragma omp parallel for
    for (__int64 i = 0; i < (__int64)n; i++)
    {
        for (unsigned int j = 0; j < m; j++) {
            unsigned short alive_near = get(array1, n, m, j, i) +
                get(array1, n, m, j, i + 1) +
                get(array1, n, m, j, i + 2) +
                get(array1, n, m, j + 1, i) +
                get(array1, n, m, j + 1, i + 2) +
                get(array1, n, m, j + 2, i) +
                get(array1, n, m, j + 2, i + 1) +
                get(array1, n, m, j + 2, i + 2);
 
            if (alive_near > 3)
            {
                array2[i * m + j] = false;
            }
            else if (alive_near > 2)
            {
                array2[i * m + j] = true;
            }
            else if (alive_near > 1)
            {
                array2[i * m + j] = array1[i * m + j];
            }
            else {
                array2[i * m + j] = false;
            }
        }
    }
}
 
int main(int argc, char* argv[]) {
    std::ifstream in("in.txt");
    unsigned int n;
    unsigned int m;
    unsigned int delay;
    unsigned int max_iterations;
    bool output;
    in >> n >> m >> delay >> max_iterations >> output;
    //unsigned int n{ 100 };
    //unsigned int m{ 100 };
    //unsigned int delay{ 1 };
    //unsigned int max_iterations{ 915 };
    //bool output{ true };
    //in >> n >> m >> delay >> max_iterations >> output;
 
 
    bool* array1 = new bool[n * m];
    bool* array2 = new bool[n * m];
 
 
    if (output)
    {
        char* print_arr = new char[n * (m + 1)];
        for (unsigned int i = 0; i < n; i++)
        {
            for (unsigned int j = 0; j < m; j++)
            {
                in >> array1[i * m + j];
                print_arr[i * (m + 1) + j] = array1[i * m + j] ? FILL_CHAR : EMPTY_CHAR;
            }
            print_arr[m + i * (m + 1)] = '\n';
        }
        printf_s("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
        print_arr[n * (m + 1) - 1] = '\0';
 
        print(0, print_arr);
        std::this_thread::sleep_for(std::chrono::milliseconds(delay));
 
        unsigned int generation = 0;
 
        while (true) {
 
            std::chrono::steady_clock::time_point start, end;
            start = std::chrono::steady_clock::now();
 
            process_output(array1, array2, print_arr, n, m);
            print(++generation, print_arr);
 
            if (equals(array1, array2, n, m) || max_iterations != 0 && generation >= max_iterations)
                break;
 
            end = std::chrono::steady_clock::now();
 
            __int64 time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
            if (time < delay)
            {
                std::this_thread::sleep_for(
                    std::chrono::milliseconds(delay - time));
            }
            bool* temp = array1;
            array1 = array2;
            array2 = temp;
        }
    }
 
 
    else {
        std::chrono::steady_clock::time_point start, end;
        start = std::chrono::steady_clock::now();
        for (unsigned int i = 0; i < n; i++)
        {
            for (unsigned int j = 0; j < m; j++)
            {
                in >> array1[i * m + j];
            }
        }
        unsigned int generation = 0;
        while (true) {
            process_no_output(array1, array2, n, m);
            generation++;
            if (equals(array1, array2, n, m) || max_iterations != 0 && generation >= max_iterations)
                break;
 
            bool* temp = array1;
            array1 = array2;
            array2 = temp;
        }
        end = std::chrono::steady_clock::now();
        __int64 time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
        std::ofstream out("out.txt");
        out << "Time, milliseconds: " << time;
    }
    return 0;
}

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <chrono>
#include <thread>
 
const int width = 40; // параметр ширины поля
const int height = 40; // параметр высоты поля
 
using Board = int[width][height]; // сокращение для удобства
 
 
void fill_rand(Board board) {
    std::srand(std::time(nullptr));
 
    for (int i = 0; i < width; ++i) {
        for (int j = 0; j < height; ++j) {
            if (rand() % 10 == 0) {
                board[i][j] = 1;  // живая клетка
            }
            else {
                board[i][j] = 0; // мертвая клетка
            }
        }
    }
}
 
void print(Board board) {
    for (int i = 0; i < width; ++i) {
        for (int j = 0; j < height; ++j) {
            if (board[i][j] == 1) { // Проверка на жизнь
                std::cout << "*";  // Если жива, то *
            }
            else {
                std::cout << " "; // Если мертва, то пробел
            }
        }
        std::cout << std::endl;
    }
}
 
void copy(Board src, Board dst) {
    for (int i = 0; i < width; ++i) {
        for (int j = 0; j < height; ++j) {
            dst[i][j] = src[i][j];  // копия прошлого поколения 
        }
    }
}
 
int get_x(int i) {
    return(width + i) % width;
}
 
int get_y(int j) {
    return(height + j) % height;
}
 
void step(Board board) {
    Board prev;   // предыдущее состояние
    copy(board, prev);
 
    for (int i = 0; i < width; ++i) {
        for (int j = 0; j < height; ++j) {
            /*(i - 1, j - 1)    (i - 1, j)  (i - 1, j + 1)
              (i, j - 1)        (i, j)      (i, j + 1)
              (i + 1, j - 1)    (i + 1, j)  (i + 1, j + 1)*/
            int counter_neighbors = 0;
            counter_neighbors += prev[get_x(i - 1)][get_y(j - 1)];    // верхняя левая
            counter_neighbors += prev[get_x(i - 1)][get_y(j)];        // верхняя центральная
            counter_neighbors += prev[get_x(i - 1)][get_y(j + 1)];    // верхняя правая
            counter_neighbors += prev[get_x(i)][get_y(j - 1)];        // средняя левая
            counter_neighbors += prev[get_x(i)][get_y(j + 1)];        // средняя правая
            counter_neighbors += prev[get_x(i + 1)][get_y(j - 1)];    // нижняя левая
            counter_neighbors += prev[get_x(i + 1)][get_y(j)];        // нижняя центральная
            counter_neighbors += prev[get_x(i + 1)][get_y(j + 1)];    // нижняя правая
 
            if ((prev[i][j] == 0) && (counter_neighbors == 3)) {      
                board[i][j] = 1;                                                // описал условия задачи
            }
            else if ((counter_neighbors < 2) || (counter_neighbors > 3)) {
                board[i][j] = 0;
            }
        }
    }
}
 
 
 
 
 
 
int main() {
    Board board;
 
    fill_rand(board);
 
    for (int k = 0; k < 100; ++k) {
        print(board);
        step(board);
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
        std::system("cls");
    }
    return 0;
}

  // проверяем в циклах все клетки
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
    {
      // обнуляем кол-во соседей
      neighbors = 0;
      // проверяем соседей
      for (k = -1; k < 2; k++)
        for (m = -1; m < 2; m++)
          if ((i+k >= 0 && j+m >= 0) && (i+k < n && j+m < n))  // проверка на выход за границы
            if (a[i+k][j+m] == 1)  // если сосед живой
              neighbors++;  // то увеличиваем счетчик
 
      if (a[i][j] == 0 && neighbors == condition)  // если клетка пустая и кол-во соседей = 3
        b[i][j] = 1;  // клетка становится живой
      // если клетка живая и кол-во соседей < 2 и больше 3 (не забываем, что сама клетка не учитывается, поэтому neighbors-1)
      if (a[i][j] == 1 && (neighbors-1 < condition-1 || neighbors-1 > condition))
        b[i][j] = 0;  // клетка становится пустой
    }