USA: +1 725-224-8795 
Sign in
Part1.
1. Declare two global variables:
const int MAX_COL = 60;
const int MAX_ROW = 30;
2. Declare 2 two-dimensional arrays of type int using the size specified in step.
currentArray and tempArray
3. Write the definition of the function displayMenu that displays the following menu; this function doesn’t collect the user’s input; only display the following menu.
[P]lay – Press ‘P’ to play.
[Q]uit – Press ‘Q’ to exit.
4. Write the definition of the function setZeroArray that initializes any two-dimensional array of type int to 0.
5. Write the definition of the function setInitialPatternArray that creates the pattern of ‘U’ using ‘1’ in any two-dimensional array of type int (use for loops). The following shows a portion of an array. Use the predefined srand() and rand() functions to determine the row and column of the first 1 (bold).
000000000
010000010
010000010
010000010
010000010
010000010
011111110
000000000
6. Write the definition of the function copyArray that copy a two-dimensional array to another two-dimensional array.
7. Write the definition of the function displayArray that prints any two-dimensional array of type int.
8. When executing your program, the following should happen:
a. Print the menu using the displayMenu function.
b. Initialize the tempArray using the setZeroArray function.
c. Set the ‘U’ pattern in the tempArray using the setInitialPatternArray function.
d. Copy the tempArray to the currentArray using the copyArray function.
e. Print the currentArray using the displayArray function.
f. When the user presses ‘P’, you will repeat a through e only once.
When the user presses ‘Q’, it will terminate the program.
Part3.
1. Use the global variables properly:
const int MAX_COL = 60;
const int MAX_ROW = 30;
for example:
int currentArray[MAX_ROW][MAX_COL];
instead of int currentArray[30][60];
****In your program, replace ‘60‘ with MAX_COL and replace ‘30‘ with MAX_ROW.
****When declaring variables, array names, use a meaningful name; don’t just use x, y, a, b, etc. Don’t just use a single character. (-30 points)
2. Write the definition of the function setNextGenArray that creates a pattern of next generation (tempArray) based on the current generation (currentArray); modify the tempArray based on thecurrentArray by applying the rules of Game of Life.
Conway’s Game of Life Rules:
– The neighbors of a given cell are the cells that touch it vertically, horizontally, or diagonally.
– Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
– Any live cell with two or three live neighbours lives on to the next generation.
– Any live cell with more than three live neighbours dies, as if by overpopulation.
– Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.
3. Create a loop to generate and next pattern automatically.
When executing your program, the following should happen:
a. Print the menu using the displayMenu function.
b. Initialize the tempArray using the setZeroArray function.
c. Set the ‘U’ pattern in the tempArray using the setInitialPatternArray function.
d. Copy the tempArray to the currentArray using the copyArray function.
e. Print the currentArray using the displayArray function.
f. When the user presses ‘P’, (loop the following three steps)
i. Generate a next pattern using the setNextGenArray function
ii. Copy the tempArray to the currentArray using the copyArray function.
iii. Print the currentArray using the displayArray function.
g. When the user presses ‘Q’, it will terminate the program.
C++
Add code to the following
**only Part three needed.**
1. Change the size of the arrays:
const int MAX_ROW = 40;
const int MAX_COL = 80;
***Make sure that only global variables you have in your program are Max_ROW and MAX_COL. Move any global variables you declared to a function or functions.
***Make sure to update setNextGenArray(). Use the variable names, not 40 or 80.
***For testing, I will be changing the array size. Your program should work by only modifying the array size.
2. Use two-dimensional arrays (tempArray, currentArray) of type char, instead of type int.
3. Choose a character for live cells, and a character for dead cells.
4. When you start your program, it should display only dead cells.
5. Modify the menu to include the followings (you may change the menu and descriptions, but must contain all the following options):
Initial – ‘I’ to load the ‘U’ pattern.
Play – ‘P’ to play the game.
Stop – ‘S’ to stop the game.
Clear – ‘C’ to set the arrays to the dead cells.
Quit – ‘Q’ to exit the program
1) pattern1 name – ‘1’ to load the pattern1.txt file to the screen. (Replace pattern1 name with an actual pattern name you have, ex: 1) spaceship ). The location of the loaded pattern should be randomized.
2) pattern2 name – ‘2’ to load the pattern2.txt file to the screen. (Replace pattern2 name with actual pattern name you have, ex: 2) snake ). The location of the loaded pattern should be randomized.
3) pattern3 name – ‘3’ to load the pattern3.txt file to the screen. (Replace pattern3 name with actual pattern name you have, ex: 3) phython ). The location of the loaded pattern should be randomized.
Custom – ‘T’ to create a pattern from the user’s input (collect row and column numbers) and set each cell to a live cell.
Save – ‘A’ to save the current live cell pattern of the currentArray to a file; save the row and column numbers of the live cells. (You may allow the user to type a file name.)
Load – ‘L’ to load a saved file. (You may allow the user to type the file name the user wish to load.)
6. Add three more patterns except the ‘U’ pattern. See the file below (do not use block and tub), or you may create your own patterns. Present the different patterns (at least 3 using files – pattern1.txt, pattern2.txt, pattern3.txt) to the user in the menu (see 5), then allow the user to load those files; create a function to access each file (pass filename as a parameter to the function). Each file contains the row and column numbers of live cells.
Game_of_Life_Patterns.png
7. Define variables and functions as necessary.
****When declaring variables and functions, use a meaningful name; don’t just use x, y, a, b, etc. Don’t just use a single character. (-30 points)
***Do not use any pre-defined functions that were not covered in the class.
***Use only topics that were covered in the class.
***No object-oriented programming.
Expert Answer
Following is the required program for the above mentioned problem. It’s been compiled and run in Code::Blocks IDE and is a genuine piece of work.
The code BEGINS from here:
#include <iostream>
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#include <ctime>
using namespace std;
// global constants for size
const int MAX_COL = 60;
const int MAX_ROW = 30;
// Signatures for required functions
void displayMenu();
void setZeroArray(int [][MAX_COL]);
void displayArray(int [][MAX_COL]);
void copyArray(int [][MAX_COL], int[][MAX_COL]);
void setInitialPatternArray(int[][MAX_COL]);
// MAIN FUNCTION
int main()
{
int tempArray[MAX_ROW][MAX_COL]; // tempArray
int currentArray[MAX_ROW][MAX_COL]; // currentArray
char choice; // To store user’s choice for menu
displayMenu(); // call to displayMenu Function
cout << “nEnter your choice: “;
choice = getche(); // Getting user’s choice
cout << endl;
choice = tolower(choice);
if (choice == ‘p’){
cout << “nSetting the array elements to 0…”;
setZeroArray(tempArray); // call to setZeroArray Function
cout << endl;
setInitialPatternArray(tempArray); // call to setInitialPatternArray Function
copyArray(tempArray, currentArray); // call to copyArray Function
cout << “nCopied the tempArray to CurrentArray…” << endl;
cout << “nnDisplaying the currentArray:” << endl;
displayArray(currentArray); // call to displayArray Function
cout << endl;
}
else
{
if (choice == ‘q’) // Quitting the program
exit(1);
else
cout << “nInvalid Choice!” << endl;
}
return 0;
}
// Function to display Menu to the user
void displayMenu(){
cout << “[P]lay – Press ‘P’ to play.” << endl;
cout << “[Q]uit – Press ‘Q’ to exit.” << endl;
}
// Function to assign zero to every element of an array
void setZeroArray(int arr[][MAX_COL]){
int i, j;
for(i = 0; i < MAX_ROW; i++)
for(j = 0; j < MAX_COL; j++)
arr[i][j] = 0;
}
// Function to display the passed array
void displayArray(int arr[][MAX_COL]){
int i, j;
for(i = 0; i < MAX_ROW; i++){
for(j = 0; j < MAX_COL; j++){
cout << arr[i][j];
}
cout << endl;
}
}
// Function to copy the elements of one array to another
void copyArray(int arr1[][MAX_COL], int arr2[][MAX_COL]){
int i, j;
for(i = 0; i < MAX_ROW; i++){
for(j = 0; j < MAX_COL; j++){
arr2[i][j] = arr1[i][j];
}
}
}
// Function to create U pattern Using 1’s with the help of rand and srand methods
void setInitialPatternArray(int arr[MAX_ROW][MAX_COL]){
int row;
int col;
srand(time(NULL));
row = rand() % 15;
col = rand() % 30;
srand(1);
int i;
int j;
j = col;
for(i = row; i < MAX_ROW – row; i++){
arr[i][col] = 1;
arr[i][MAX_COL – col – 1] = 1;
}
i = MAX_ROW – row – 1;
for(j = col + 1; j < MAX_COL – col – 1; j++)
arr[i][j] = 1;
}
The code ENDS here!
Screenshots:
