implemement the game.cpp by the header file given. And create main.cpp to make t
ID: 3787258 • Letter: I
Question
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 <iostream> // Provides ostream
#include <string> // String operations
#include <cstdlib> // 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);
}
Explanation / Answer
Answer:
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
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] +
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)
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 << ' ';
}
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;
}
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)
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;
}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.