The document describes the implementation details of Conway's Game of Life in C++, outlining the key classes such as 'cell' and 'gameoflife' along with their methods. It includes code snippets for the game logic, cell state management, and input/output operations. The main function facilitates the interactive simulation of the game, allowing users to select configurations and run multiple iterations.

1. implemement the game.cpp by the header file given. And create main.cpp to make the program
work.
The game is called the game of life, https://en.wikipedia.org/wiki/Conway's_Game_of_Life
game.h:
#include // Provides ostream
#include // String operations
#include // Randomizer
namespace csci2312
{
using std::string;
using std::ostream;
using std::istream;
class Cell
{
friend class GameOfLife;
public:
static const char alive ='o'; // alive image
static const char dead = '-'; // dead image
// Default constructor sets the cell's state to false
Cell();
// Custom constructor sets the cell's state as per argument
Cell(bool state);
// Empty destructor
~Cell();
// Accessors have no intention to modify the object, so it is a good practice to make them
'const' functions
bool getState() const;
// Mutator to change cell's state
void setState(bool newState);
// Accessor to see the 'face'
char getFace() const;
private:
bool state;

2. char face;
};
class GameOfLife
{
public:
static const unsigned int MAX_BOARD = 30;
GameOfLife();
GameOfLife(size_t boardSize);
~GameOfLife();
int seedBoard(string fileName);
void seedBoard(size_t seeds);
void run();
void run(unsigned int numberOfIterations);
// ADVANCED
// A const(!) accessor method that returns a handle to the private currentLife array.
// The return type must also be 'const' because we return a pointer to a static array, and
these are fixed
// It is just an example. It is not needed if we have a friend operator.
const Cell(*getCurrentLife() const )[MAX_BOARD+2] { return currentLife; };
///////////////////////////////////////////////////////
// friend operator can access private members of GameOfLife
friend ostream& operator << (ostream& out, const GameOfLife& board);
friend istream& operator >> (istream& in, const GameOfLife& board);
private:
bool executeRules(unsigned int countAlive, bool currentState);
// With "Halo" approach we need a bigger board
Cell currentLife[MAX_BOARD + 2][MAX_BOARD + 2];
Cell nextLife[MAX_BOARD + 2][MAX_BOARD + 2];
// ADVANCED
// Example how to declare variable cl as a pointer/handle to our array of Cells of size
HALO_BOARD

3. // The accessor method getCurrentLife() above uses the same syntax for the return type
const Cell(*cl)[MAX_BOARD + 2] = currentLife;
////////////////////////////////////////////////////////
size_t boardSize; // Board size requested in the constructor
};
// NON-MEMBER OUTPUT FUNCTIONS
// Display cell's state with alive/dead face
ostream& operator << (ostream& out, const Cell& cell);
}
Solution
Answer:
#include
#include
#include
#include
using namespace std;
void copy(int input1[52][102], int input2[52][102])
{
for(int j = 0; j < 52; j++)
{
for(int i = 0; i < 102; i++)
input2[j][i] = input1[j][i];
}
}
void lifegame(int input[52][102], char option)
{
int support[52][102];
copy(input, support);
for(int j = 1; j < 51; j++)

4. {
for(int i = 1; i < 101; i++)
{
if(option == 'm')
{
int increment = 0;
increment = input[j-1][i] +
input[j-1][i-1] +
input[j][i-1] +
input[j+1][i-1] +
input[j+1][i] +
input[j+1][i+1] +
input[j][i+1] +
input[j-1][i+1];
if(increment < 2 || increment > 3)
support[j][i] = 0;
if(increment == 2)
support[j][i] = input[j][i];
if(increment == 3)
support[j][i] = 1;
}
else if(option == 'v')
{
int increment = 0;
increment = input[j-1][i] +
input[j][i-1] +
input[j+1][i] +
input[j][i+1];
if(increment < 2 || increment > 3)
support[j][i] = 0;
if(increment == 2)

5. support[j][i] = input[j][i];
if(increment == 3)
support[j][i] = 1;
}
}
}
copy(support, input);
}
bool differentiate(int input1[52][102], int input2[52][102])
{
int increment = 0;
for(int j = 0; j < 52; j++)
{
for(int i = 0; i < 102; i++)
{
if(input1[j][i]==input2[j][i])
increment++;
}
}
if(increment == 52*102)
return true;
else
return false;
}
void print(int input[52][102])
{
for(int j = 1; j < 51; j++)
{
for(int i = 1; i < 101; i++)
{
if(input[j][i] == 1)
cout << '*';
else
cout << ' ';

6. }
cout << endl;
}
}
int main()
{
int generate[52][102];
int perform[52][102];
int storage[52][102];
char adjacent;
char repeat;
char cont;
bool difference;
string value;
do
{
do
{
cout << "Which adjacent would you like to use (m or v): ";
cin >> adjacent;
}while(adjacent != 'm' && adjacent != 'v');
system("clear");
int i = 0;
do
{
srand(time(NULL));
for(int j = 1; j < 51; j++)
{
for (int i = 1; i < 101; i++)
generate[j][i] = rand() % 2;
}

7. if(i < 10)
value = "#############";
else if(i >= 10 && i < 100)
value = "##############";
else if(i >= 100 && i < 1000)
value = "###############";
else if(i >= 1000 && i < 10000)
value = "################";
else
value = "#################";
cout << value << endl << "Generation " << i
<< ":" << endl << value << endl << endl;
if(i == 0)
copy(generate, perform);
copy(perform, storage);
print(perform);
lifegame(perform, adjacent);
i++;
if(i % 100 == 1 && i != 1)
{
cout << endl;
do
{
cout << "If you want to continue the lifegame press y for yes or n for discontinue: ";
cin >> cont;
}while(cont != 'y' && cont != 'n');
if(cont == 'n')
break;
}
difference = differentiate(perform, storage);
if(difference == false)
system("clear");
if(difference == true)

8. cout << endl;
}while(difference == false);
do
{
cout << "Would you like to run another simulation? (y/n): ";
cin >> repeat;
}while(repeat != 'y' && repeat != 'n');
}while(repeat == 'y');
return 0;
}