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; 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 // 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++) { 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] .

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;
}