How to check the conditions for neighbours? - c

Question

I am stubborn about trying to solve as much as I can myself. However I think that I've reached an impasse.
I have to write code for a simple version for game of life on a 20x20 grid. The conditions are:
A cell which has 0 or 1 living neighbours dies next generation.
A cell which has 2 or 3 living neighbours lives next generation.
A cell which has 4 or more living neighbours dies next generation.
A empty cell which has exactly 3 living neighbours becomes a live
cell next generation.
My particular problem is how to write the algoritm that performs the above said operations.
I have not tried much since I'm out of ideas. I did hope to get some ideas which might give me a extra push into finishing my function that updates the world/field.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* Constants, representation of states */
#define ALIVE 'X'
#define DEAD '.'
/* Declaration of data structure */
typedef struct{
char current;
char next;
} cell;
/* Declaration of functions */
void initField(const int rows, const int cols, cell field[rows][cols]);
void loadGlider(const int rows, const int cols, cell field[rows][cols]);
void loadSemaphore(const int rows, const int cols, cell field[rows][cols]);
void loadRandom(const int rows, const int cols, cell field[rows][cols]);
void loadCustom(const int rows, const int cols, cell field[rows][cols]);
void printWorld(const int rows, const int cols, cell field[rows][cols]);
void evolve(const int rows,const int cols,cell field[rows][cols]);
/* Function: main
* Description: Start and run games, interact with the user.
* Input: About what initial structure and whether to step or exit.
* Output: Information to the user, and the game field in each step.
*/
int main(void) {
const int rows = 20;
const int cols = 20;
cell field[rows][cols];
initField(rows,cols, field);
printWorld(rows,cols,field);
return 0;
}
/* Function: initField
* Description: Initialize all the cells to dead, then asks the user about
* which structure to load, and finally load the structure.
* Input: The field array and its size.
* Output: The field array is updated.
*/
void initField(const int rows, const int cols, cell field[rows][cols]) {
for (int r = 0 ; r < rows ; r++) {
for (int c = 0 ; c < cols ; c++) {
field[r][c].current = DEAD;
}
}
printf("Select field spec to load ([G]lider, [S]emaphore, [R]andom ");
printf("or [C]ustom): ");
int ch = getchar();
/* Ignore following newline */
if (ch != '\n') {
getchar();
}
switch (ch) {
case 'g':
case 'G':
loadGlider(rows, cols, field);
break;
case 's':
case 'S':
loadSemaphore(rows, cols, field);
break;
case 'r':
case 'R':
loadRandom(rows, cols, field);
break;
case 'c':
case 'C':
default:
loadCustom(rows, cols, field);
break;
}
}
/* Function: loadGlider
* Description: Inserts a glider into the field.
* Input: The field array and its size.
* Output: The field array is updated.
*/
void loadGlider(const int rows, const int cols, cell field[rows][cols]) {
field[0][1].current = ALIVE;
field[1][2].current = ALIVE;
field[2][0].current = ALIVE;
field[2][1].current = ALIVE;
field[2][2].current = ALIVE;
}
/* Function: loadSemaphore
* Description: Inserts a semaphore into the field.
* Input: The field array and its size.
* Output: The field array is updated.
*/
void loadSemaphore(const int rows, const int cols, cell field[rows][cols]) {
field[8][1].current = ALIVE;
field[8][2].current = ALIVE;
field[8][3].current = ALIVE;
}
/* Function: loadRandom
* Description: Inserts a random structure into the field.
* Input: The field array and its size.
* Output: The field array is updated. There is a 50 % chance that a cell
* is alive.
*/
void loadRandom(const int rows, const int cols, cell field[rows][cols]) {
}
/* Function: loadCustom
* Description: Lets the user specify a structure that then is inserted into
* the field.
* Input: The field array and its size.
* Output: The field array is updated.
*/
void loadCustom(const int rows, const int cols, cell field[rows][cols]) {
printf("Give custom format string: ");
do {
int r, c;
scanf("%d,%d", &r, &c);
field[r][c].current = ALIVE;
} while (getchar() != '\n');
}
/* Function: printWorld
* Description: Prints the current field
* Input: The field array and its size.
* Output: The field array is updated.
*/
void printWorld(const int rows, const int cols, cell field[rows][cols]){
char c = '\n';
while(c == '\n'){
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
printf("%c ", field[i][j].current);
}
printf("\n");
}
c = getchar();
if(c != '\n'){
break;
}
}
void evolve(const int rows,const int cols,cell field[rows][cols]){
for(int i = 0;i<rows;i++){
for(int j =0;j<cols;j++){
if()
}
}
}
You can see above all current progress. All the functions except for
printWorld() and evolve() are pre-made and should remain as they are.
This is my current progress for evolve, it is not much.
void evolve(const int rows,const int cols,cell field[rows][cols]){
for(int i = 0;i<rows;i++){
for(int j =0;j<cols;j++){
if()
}
}
}
All I have done is to write two nested for-loops which makes sure to check every cell.
But I am not sure however how to proceed and implement the conditions above. Any ideas on how to check neighbours for each cell?
English is not my first language. So I apologise in advance for any grammatical error. And if you have trouble understanding what I want, ask, and I'll clarify.
I would also add a disclaimer that the function: printWorld is not finished since it still requires the function evolve.

Answer 1

All I have done is to write two nested for-loops which makes sure to check every cell.
Well that's a start.
But I am not sure however how to proceed and implement the conditions above. Any ideas on how to check neighbours for each cell?
The evolve() function receives the field, apparently describinbg the current state of the board and the next state. It would appear that the data for a cell with indices i, j would be in field[i][j]. So the main question is: which cells are the neighbors of that one? But that shouldn't be hard. They are the eight cells other than (i, j) each of whose indices differs by at most 1 from i or j, respectively. That is, (i - 1, j - 1), (i - 1, j), (i - 1, j + 1), (i, j - 1), etc.. Work out an example if you need to do, with actual cell indices, for one cell.
So it seems you would count the live population of all the neighbor cells, and use that in combination with whether the current cell is alive, to determine and record how that cell will evolve.
Do note that the edges and corners are special cases: they do not have neighbors on at least one side, and you must not try to examine the neighbors that do not exist. You should be able to accomplish that by checking whether the neighbor cell indices are in bounds before trying to access them.