Exploring the World of Conway‘s Game of Life: A Journey Into Cellular Automata

Abstract:
In this article, we will embark on a fascinating journey into the world of cellular automata by delving into one of the most famous examples: Conway's Game of Life. We will analyze and understand the provided code, which simulates the evolution of life forms on a two-dimensional grid. Through the enhancement and extension of the original code, we will witness the emergence of intricate patterns and observe the captivating dynamics of this virtual world.

Conway's Game of Life has intrigued programmers, mathematicians, and curious minds for decades. It is a cellular automaton—a self-contained universe governed by a set of simple rules. The code provided showcases a classic implementation of this compelling simulation, allowing us to observe the evolution of cells over multiple generations.
The code begins with the initialization of a 2D grid, representing the initial state. Each cell can either be alive (1) or dead (0). The ExtendBoard function is responsible for extending the boundaries of the original board and fulfilling the requirements of the game's rules. It adds a layer of dead cells around the existing board, ensuring proper computation of neighbors for the cells at the edges.
Next, the PrintExtendedBoard function presents a visual representation of the extended board. Each alive cell is symbolized by an asterisk (*), providing an easy-to-understand visualization of the evolving patterns. This function adds a touch of visual appeal to our exploration of cellular automata.
The heart of the simulation lies in the GenerateNewBoard function. It iterates over each cell of the board, calculating the number of alive neighbors for each cell in order to determine its fate in the next generation. The algorithm adheres to predetermined rules: any live cell with fewer than two or more than three live neighbors will die, while a dead cell with exactly three live neighbors will come to life.
To understand the code on a deeper level, we examine the processes involved in each generation's computation. By copying the newly generated board back to the original board and repeating the process for a specified number of rounds, we witness how complex patterns emerge from the simplest rules. This demonstration truly accentuates the fascinating nature of cellular automata.
To enhance our experience with the simulation, we have also incorporated a SleepAndClear function. This function ensures that each generation is displayed for a certain period, creating a visually appealing progression and allowing us to observe the dynamic evolution of the system over time.
In conclusion, this article has provided an insightful journey into the world of Conway's Game of Life. By analyzing and understanding the code, we have witnessed the intriguing dynamics of cellular automata. We have explored the steps behind each generation's computation and witnessed the formation of mesmerizing patterns—a testament to the emergent complexity that arises from simple rules.
So, grab your virtual magnifying glass, hop on the cellular automata bandwagon, and let's dive headfirst into the captivating world of Conway's Game of Life!

Note: The above article demonstrates writing a summary of the code provided using Markdown language, as requested. If you have any specific requirements or any particular sections you would like to expand upon, please let me know, and I'll be happy to assist you further.

Codes are as follows:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define SIZE 6
void ExtendBoard(const int origin_board[][SIZE],
                 int extended_board[][SIZE + 2]);
void PrintExtendedBoard(const int extended_board[][SIZE + 2]);
void GenerateNewBoard(const int old_board[][SIZE + 2],
                      int new_board[][SIZE + 2]);
void CopyExtendedBoard(const int src_board[][SIZE + 2],
                       int dest_board[][SIZE + 2]);
void SleepAndClear(int sec);
int main() {
  const int board[SIZE][SIZE] = {
      {0},
      {0, 1, 1, 0, 0, 0},
      {0, 1, 1, 0, 0, 0},
      {0, 0, 0, 1, 1, 0},
      {0, 0, 0, 1, 1, 0},
      {0}
  };
  int old_board[SIZE + 2][SIZE + 2] = {0};
  ExtendBoard(board, old_board);
  PrintExtendedBoard(old_board);
  int new_board[SIZE + 2][SIZE + 2] = {0};
  for (int round = 0; round < 10; round++) {
    GenerateNewBoard(old_board, new_board);
    SleepAndClear(1);
    PrintExtendedBoard(new_board);
    CopyExtendedBoard(new_board, old_board);
  }
  return 0;
}
void ExtendBoard(const int origin_board[][SIZE],
                 int extended_board[][SIZE + 2]) {
  for (int row = 0; row < SIZE + 2; row++) {
    for (int col = 0; col < SIZE + 2; col++) {
      if (row == 0 || row == SIZE + 1 || col == 0 || col == SIZE + 1) {
        extended_board[row][col] = 0;
      } else {
        extended_board[row][col] = origin_board[row - 1][col - 1];
      }
    }
  }
}
void PrintExtendedBoard(const int extended_board[][SIZE + 2]) {
  for (int row = 1; row <= SIZE; row++) {
    for (int col = 1; col <= SIZE; col++) {
      printf("%c ", extended_board[row][col] ? '*' : ' ');
    }
    printf("\n");
  }
}
void GenerateNewBoard(const int old_board[][SIZE + 2],
                      int new_board[][SIZE + 2]) {
  for (int row = 1; row <= SIZE; row++) {
    for (int col = 1; col <= SIZE; col++) {
      int neighbours =
          old_board[row - 1][col - 1] +
              old_board[row - 1][col] +
              old_board[row - 1][col + 1] +
              old_board[row][col - 1] +
              old_board[row][col + 1] +
              old_board[row + 1][col - 1] +
              old_board[row + 1][col] +
              old_board[row + 1][col + 1];
      if (old_board[row][col]) {
        new_board[row][col] = (neighbours == 2 || neighbours == 3);
      } else {
        new_board[row][col] = (neighbours == 3);
      }
    }
  }
}
void CopyExtendedBoard(const int src_board[][SIZE + 2],
                       int dest_board[][SIZE + 2]) {
  for (int row = 1; row <= SIZE; row++) {
    for (int col = 1; col <= SIZE; col++) {
      dest_board[row][col] = src_board[row][col];
    }
  }
}
void SleepAndClear(int sec) {
  sleep(sec);
  system("clear");
}