Game of life

I have written a erronous game of life.
the game of life is as follows:

neighboring cells are defined as:
* = cell
# = possible neighbor

###
#*#
###

every empty cell with three living neighbors will come to life next generation

any cell with two or three neighbors will live into the next generation, cells with less or more will die

births and deaths occur simultaneouslya

program must be run for 5 generations
_________________________________

i tested my program and some bacteria seem to work and others appear to be random, please help me get an idea of what im doing wrong.

Quote:

---

My program of Life:

life.cpp

---

thanks,
Josh

Interesting. What does the input file look like?

first integer is total number of bacteria, followed by coordinates.

Quote:

---

Life100.txt

---

yep quite interesting.
Instead of this

Code:

---

void fill (char table[ MAX ][ MAX ])
//fill the table with blank spaces
{
  for (int row = 0; row < MAX; row++)
      for (int col = 0; col < MAX; col++)
        table[ row ][ col ] = ' ';
}

---

You could just do this

Code:

---

void fill(char *table)
{

  memset(table, ' ', sizeof(table));
}

---

Be carefull in your alive check routine, it looks like you check all ajacent cells even if you're at the edge of the grid.

i see where your going, but i havent quite learned that stuff yet lol thats why im doing that obscene looking fill. hehe. thanks for the advice though

Quote:

---

Be carefull in your alive check routine, it looks like you check all ajacent cells even if you're at the edge of the grid.

---

i see what you mean, but when i enlarge the grid to ensure that cells arent on the edge, i still get the same output.

please does anyone have any suggestions, im stumped

Wait I don't understand, is this program actually a game?

lol its called the game of life, the computer plays the game basically. its a computer simulation of the life and death of a population of organisms. It determines the life and death of organisms from one generation to the next.

Quote:

---

Originally Posted by homeyg

Wait I don't understand, is this program actually a game?

---

It's a branch of cellular automata. Not strictly a game, but that's what it was called.

Like Quantum1024 said, check your alive logic. Your overstepping your array bounds in your alive function. Remember that x-1 and x+1 aren't necessarily inside your array. That's a bug.

Also, take a look at this:

Code:

---

void cycle (char table[ MAX ][ MAX ], int &total)
//calculate each generation and assign new locations
{
  char temp[ MAX ][ MAX ];
  bool life;
 
  fill (temp);
  for (int generation = 0; generation < 5; generation++)
  {
      for (int row = 0; row < MAX; row++)
        for (int col = 0; col < MAX; col++)
        { 
            life = alive(table, row, col);
            if (life)
              temp[ row ][ col ] = '*';
        }
      table = temp;
  }
  print (table);
}

---

You can't assign arrays like that. You either need to do a member-wise copy, or just use memcpy.

Code:

---

//member-wise copy
  for (int row = 0; row < MAX; row++)
      for (int col = 0; col < MAX; col++)
        table[ row ][ col ] = temp[ row ][ col ];
//memcpy
  memcpy(table,temp,sizeof(char)*100*100);

---

It would help if you told us exactly what kind of errors you were getting.

well the only error is that its not giving me the answer it should be, instead of the correct output:

Code:

---

      12345678901234567890

 1          **           
 2          * *           
 3          *        ** 
 4                  **  * 
 5                  ** ** 
 6                * * ** 
 7              * **     
 8              *       
 9            ***  **     
10          ** ** ** **   
11          ******       
12          ** **** **   
13            *  **  *** 
14          *  * *** ** 
15            **    ** * 
16          **      **  *
17          * *    **    *
18          * *  ***    *
19          *    *  * ** 
20

---

i get this:

Code:

---

      12345678901234567890

 1
 2          *
 3
 4
 5                  *
 6
 7
 8                  **
 9                  **
10                  **
11
12              *
13
14    *
15            *
16                    *
17      *
18      *
19                ***
20          *    ***

---

eh forget posting that, lol it took away my spaces

Yup, use code tags instead.

This is what it starts off as:

Code:

---

      12345678901234567890

 1      *  **  **    *
 2    *  *  *
 3          *    *  *  *
 4    *  *        * **
 5    *      *  * **
 6    * * *  *    *  *
 7              *  **  *
 8        *    *  **
 9          *    ** *  * *
10          * *    **
11      *      *        *
12          ** **      *
13    * *        *
14    **    **    **
15          * *  **  * *
16    * *  * * **    **
17      **              *
18      *    *  * *    *
19    *    **    ****
20      ** * *  *    **

---

Neither look right to me. Using the 2:3 rules, you should end up with a lot of familiar shapes:

Code:

---

**
**

 **
*  *
 **

***

    *
    *
    *

***  ***
 
    *
    *
    *

---

...and some others I can't be arsed to draw in ASCII.

well it doesnt necessarily come up with those patterns, depending on the rules, and given coordinates they differ.

here is what i came up with to make sure its not out of boundaries, but it still does not work properly...any suggestions?

Code:

---

/***************************
Made by: Joshua R
Date Created:
Date Finished:
Lesson 18, LAB EXERCISE LIFE
***************************/
#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;

//array max needs to be one more
//row and column 0 won't be used
const int MAX = 20 + 1;
         
void fill (char [ MAX ][ MAX ]);
void getBacteria (char [ MAX ][ MAX ], int &);
void oneGeneration (char [ MAX ][ MAX ], int &);
bool alive (const char [ MAX ][ MAX ], int &, int &);
void neighbor (const char [ MAX ][ MAX ], int &, int &, int &);
void copy (char [ MAX ][ MAX ], char [ MAX ][ MAX ]);
void print (const char [ MAX ][ MAX ]);

main()
{
  char table[ MAX ][ MAX ];
  int total;
 
  fill (table);
  getBacteria (table, total);
 
  print (table);
 
  for (int generation = 4; generation < 5; generation++)
      oneGeneration (table, total);
 
  print (table);
 
  cout<< endl << "Total Bacteria = " << total;
  return 0;
}

/**** ARRAY MANIPULATION ****/
void fill (char table[ MAX ][ MAX ])
//fill the table with blank spaces
{
  for (int row = 0; row < MAX; row++)
      for (int col = 0; col < MAX; col++)
        table[ row ][ col ] = ' ';
}

/**** ARRAY MANIPULATION ****/
void getBacteria (char table[ MAX ][ MAX ], int &total)
//get coordinates for bacteria from an external file
{
  int num, x, y;
  ifstream infile("Life100.txt");
 
  //get total number of bacteria, the first integer
  infile >> num;
  total = num;
  //get coordinates and fill location with "*"
  while (!infile.eof())
  {
      infile >> x;
      infile >> y;
      table[ x ][ y ] = '*';
  }
}

/**** ARRAY MANIPULATION ****/
void oneGeneration (char table[ MAX ][ MAX ], int &total)
//calculate each generation and assign new locations
{
  char temp[ MAX ][ MAX ];
  bool life;
 
  fill (temp);
  for (int row = 0; row < MAX; row++)
      for (int col = 0; col < MAX; col++)
      { 
        life = alive(table, row, col);
        if (life)
            temp[ row ][ col ] = '*';
      }
  copy (table, temp);
}

/**** BOOLEAN EVALUATION ****/
bool alive (const char table[ MAX ][ MAX ], int &x, int &y)
//calculate if the cell will live
{
  int living = 0;
  //get number of neighbors
  neighbor (table, x, y, living);
  //determine if current cell will live
  if (table[ x ][ y ] == '*')
  { 
      if ((living == 2) || (living == 3))
        return true;
      else
        return false;
  }
  else
  { 
      if (living == 3)
        return true;
      else
        return false;
  }
}

/****** INTEGER COUNT ******/
void neighbor (const char table[ MAX ][ MAX ], int &x, int &y, int &a)
//count number of surrounding neighbors
{
  if ((x - 1) >= 0))
      for (int row = y - 1; row <= y + 1; row++)
        if ((row >= 0) && (row < MAX))
        if (table[ row ][ x - 1 ] == '*')
          a += 1;

  if ((x + 1) < MAX)
      for (int row = y - 1; row <= y + 1; row++)
        if ((row >= 0) && (row < MAX))
        if (table[ MAX ][ x + 1 ] == '*')
          a += 1;

  if ((y - 1) >= 0)
      if (table[ y - 1 ][ x ] == '*')
        a += 1;

  if ((y + 1) < MAX)
      if (table[ y + 1 ][ x ] == '*')
        a += 1;
}

/******* COPY ARRAY ********/
void copy (char table[ MAX ][ MAX ], char temp[ MAX ][ MAX ])
//copy new "temp" table to old "table"
{
  for (int row = 0; row < MAX; row++)
      for (int col = 0; col < MAX; col++)
        table[ row ][ col ] = temp[ row ][ col ];
}

/******* PRINT ARRAY *******/ 
void print (const char table[ MAX ][ MAX ])
//print full table with reference numbers
{
  int horizontal = 1;
 
  cout<< setw(10);
  //prints horizontal reference numbers, x-axis
  for (int ref = 1; ref < MAX; ref++)
  { 
      cout<< horizontal;
      horizontal++;
      if (horizontal == 10) horizontal = 0;
  }
      cout<< endl << endl;
  //prints verticle reference numbers, y-axis
  for (int row = 1; row < MAX; row++)
  { 
      cout<< setw(5) << row << setw(5);
      for (int col = 1; col < MAX; col++)
        cout<< table[ row ][ col ];
      cout<< endl;
  }
}

---

i'm piecing through this. One random style suggestion, is that you should really use 0-indexed lists. If you don't stick with the idiom, it gets confusing, as you always have to keep track of if code is using 1 or 0 based indexes.

Why not have the getBacteria function return the amount of cells, instead of using the reference?

because the assignment says to initialize a max array of 20 by 20, i used 21 so that i didnt have to use row and column 0.

Quote:

---

Originally Posted by AH_Tze

i'm piecing through this. One random style suggestion, is that you should really use 0-indexed lists. If you don't stick with the idiom, it gets confusing, as you always have to keep track of if code is using 1 or 0 based indexes.

---

but the file contains coordinates, none are 0.

does anyone have any suggestions??? i know there is something wrong with my code i just cant pinpoint it.

Not seeing it immediately. The alive() and neighbor() functions look error-prone.
If you want to find the error, I'd probably write a seperate driver program so you can test those two individually. You could write a test driver which has each function on a small array, with none of the other program logic obscuring things, and make it easy to watch as it steps through so you can spot the trouble spot.

Easiest way to spot the error is to render one frame and wait for a key. Then render another and so on. This way you can tell exactly what is going in inside of your code. I would say it is your alive and neighbor functions as well.

You must remember that just because you might 'get away' with overstepping your array bounds, does not mean it won't adversely affect your data, code, etc. You will frag the heap and/or stack depending on how you are allocating the array. This will result in perfectly good code executing incorrectly due to messed up memory.

So if you are getting weird stuff then that is probably what is happening.

To stop the overrun, just clamp on x and y.

Code:

---

int x1=x-1
int y1=y-1
int x2=x+1
int y2=y+1

if (x1<0) x1=maxX;
if (y1<0) y1=maxY;
if (x2>maxX) x2=0;
if (y2>maxY) y2=0;

char n0,n1,n2,n3,n4,n5,n6,n7;
n0=n1=n2=n3=n4=n5=n6=n7=0;

n0=array[y1][x1];
n1=array[y1][x];
n2=array[y1][x2];

n3=array[y][x1];
n4=array[y][x2];

n5=array[y2][x1];
n6=array[y2][x];
n7=array[y2][x2];

...

---

This picks up all 8 neighbors and will wrap the effect at the boundaries of the array.

But you would want something like that to count the number of alive and dead instead of retrieving the value. What I showed is more useful for filtering images. But it should get you on the right track.

Given any one location this is what that code will give:

Code:

---

n0,n1,n2
n3,**,n4
n5,n6,n7

---

Where ** is the current location you are checking.

Quote:

---

Code:

---

if (x1<0) x1=maxX;
if (y1<0) y1=maxY;
if (x2>maxX) x2=0;
if (y2>maxY) y2=0;

---

---

if x1 or y1 is less than 0 it should yield 0 not max.
this is the code i used, it works inside but not on the edges so for that im having dificulties.

Code:

---

/**** BOOLEAN EVALUATION ****/
bool life (const char table[ MAX ][ MAX ], int &x, int &y)
//count number of surrounding neighbors
{
  int x1=x-1; int y1=y-1;
  int x2=x+1; int y2=y+1;
  int a = 0;

  if (x1<0) x1=0;
  if (y1<0) y1=0;
  if (x2>MAX) x2=MAX;
  if (y2>MAX) y2=MAX;

  char n0,n1,n2,n3,n4,n5,n6,n7;
  n0=n1=n2=n3=n4=n5=n6=n7=0;

  n0=table[y1][x1]; n1=table[y1][x]; n2=table[y1][x2];
  n3=table[y][x1]; n4=table[y][x2]; n5=table[y2][x1];
  n6=table[y2][x]; n7=table[y2][x2];

  if (n0 == '*') a++; if (n1 == '*') a++; if (n2 == '*') a++;
  if (n3 == '*') a++; if (n4 == '*') a++; if (n5 == '*') a++;
  if (n6 == '*') a++; if (n7 == '*') a++;

  if (table[ x ][ y ] == ' ')
  {
      if (a == 3)
        return true;
      else
        return false;
  }
  if (table[ x ][ y ] == '*')
  {
      if ((a == 3) || (a == 2))
        return true;
      else
        return false;
  }
}

---

does anyone have any other ideas for setting boundaries? i dont need the code, just an idea

You can use modulus arithmetic and set it up to have no boundaries, that is, the sides would be connected. I have an example from my game of life implementation if you need to see it.

i am curious, could you just give me an example of how the modulus operator could be used?

Quote:

---

Originally Posted by JoshR

i am curious, could you just give me an example of how the modulus operator could be used?

---

Highly general example:

Code:

---

#define MAX 20

int main (void)
{
  int i = 0;

  while (1)
      i++ %= MAX;
}

---

...will wrap i so that it is constantly within 20.

But you don't want to do that in the game of life (unless you want to implement a conceptual torus) - you should just ignore out of bounds values.

well i clamped down as hard as i could on the x and y values and made sure that they were only used if in parameters as follows below, but it still wont work, im lost...

Code:

---

/**** BOOLEAN EVALUATION ****/
bool life (const char table[ MAX ][ MAX ], int &x, int &y)
//count number of surrounding neighbors
{
  int x1=x-1; int y1=y-1;
  int x2=x+1; int y2=y+1;
  int a = 0;

  char n0,n1,n2,n3,n4,n5,n6,n7;
  n0=n1=n2=n3=n4=n5=n6=n7=0;

  if ((y1 > 0) && (x1 > 0))
      n0=table[y1][x1];
  if (y1 > 0)
      n1=table[y1][x];
  if ((y1 > 0) && (x2 < MAX))
      n2=table[y1][x2];
  if (x1 > 0)
      n3=table[y][x1];
  if (x2 < MAX)
      n4=table[y][x2];
  if ((x1 > 0) && (y2 < MAX))
      n5=table[y2][x1];
  if (y2 < MAX)
      n6=table[y2][x];
  if ((y2 < MAX) && (x2 < MAX))
      n7=table[y2][x2];

  if (n0 == '*') a++; if (n1 == '*') a++; if (n2 == '*') a++;
  if (n3 == '*') a++; if (n4 == '*') a++; if (n5 == '*') a++;
  if (n6 == '*') a++; if (n7 == '*') a++;

  if (table[ x ][ y ] == ' ')
  {
      if (a == 3)
        return true;
      else
        return false;
  }
  if (table[ x ][ y ] == '*')
  {
      if ((a == 3) || (a == 2))
        return true;
      else
        return false;
  }
}

---

Quote:

---

Originally Posted by JoshR

Code:

---

...
  if (table[ x ][ y ] == '*')
  {
      if ((a == 3) || (a == 2))
        return true;
      else
        return false;
  }
}

---

---

I beleve this should be

Code:

---

if(a == 3)
    return true;
else if(a == 2)
    f(table[x][y] == '*')
        return true;
    else
        return false;
else
    return false;

// or equivilently

return a == 3 || (a==2 && table[x][y] == '*');

---

That is a life cell is added for every location with exactly 3 neighbors, life cells that have exactly two neighbors survive until the next generation. I also suggest breaking the program down into smaller, yet more idiot-proof functions.

Code:

---

bool alive(const char table[MAX][MAX], int x, int y) {
    return 0 <= x && x < MAX
        && 0 <= y && y < MAX
        && table[x][y] == '*';
}
int neighbors(const char table[MAX][MAX], int x, int y) {
    int count = 0;
    if(alive(x-1,y-1)) ++count;
    if(alive(x,y-1)) ++count;
    if(alive(x+1,y-1)) ++count;
    if(alive(x-1,y)) ++count;
    if(alive(x+1,y)) ++count;
    if(alive(x-1,y+1)) ++count;
    if(alive(x,y+1)) ++count;
    if(alive(x+1,y+1)) ++count;
    return count;
}

char next_gen(const char table[MAX][MAX], int x, int y) {
    int n = neighbors(table,x,y);
    if(n==3 || (n==2 && alive(table,x,y)) return '*';
    else return ' ';
}

---