LIFEGOOD.PAS program created by Alexander Larkin.
E-mail:               larkin@titov.msk.ru
Internet address:     http://www.geocities.com/SiliconValley/6235/


                     MANUAL (someone wrote it for me)

The Game of Life

Consider a two dimensional array with M rows and N columns.
This represents the world in which some organisms live. Each of
the M by N cells in this array is either occupied (if an organism
lives there) or is vacant.  No more than one organism can live
in any one cell at any time. Each cell, except those on the boundaries
(the edge of the world), has exactly eight neighboring cells (above,
below, left, right, and four diagonals).  The cells on the boundaries
have less than eight neighboring cells. Initially, there is a given
population of organisms occupying certain of the cells.  At each
succeeding generation, the organisms reproduce and die as follows:

     Each organism of the current generation survives to the next 
     generation if, and only if, it has 2 or 3 neighbors (a neighbor is
     an organism that lives in a neighboring cell).  Otherwise, it dies
     and its cell becomes empty in the next generation.  Note: it dies
     if it is  `lonely' or `overcrowded'.

     Each vacant cell in the current generation becomes occupied by a
     new organism in the next generation if, and only if, it has exactly
     3 neighbors.  Otherwise, it remains vacant in the next generation.
     
Write a program to play this Game of Life.  Your program should read
the initial world from a file (see below) and repeatedly generate new
generations, prompting the user each time to see if he or she wants to
see the next generation or terminate the program.  Also, the program
should terminate automatically if the world becomes empty, displaying
a message accordingly. Use two-dimensional arrays (either type Boolean
or type char) to store the old and new gene rations respectively. To
keep things simple, assume that M=20 and N=75, i.e. the world has 20
rows and 75 columns, and define these in a const statement before
declaring your array variables.

Empty cells are represented with blanks and occupied cells with X.
Read the data using two nested while loops, testing for EOLN and EOF.
Do not assume that the lines of the file are `padded' with blanks.
The lines may be only long enough to contain the last X on the line.
Likewise, there may be less than 20 lines in the file; if the last
lines of the world are empty, they may not be given in the file.
You need to ensure that the cells in the world not explicitly given
in the file are initialized to be empty.

Programming Details:
      You need two 2-dimensional arrays---the new generation should
      be created based on information from the old generation.
      If you use only one array, you will find that your old generation is
      overwritten by the new one before you have finished using all the
      information you need from it.
 
      You should create a `border' of cells that always stay empty
      by declaring your arrays from 0 to M+1 and from 0 to N+1.
      This way, the cells on the edge will also have eight neighboring
      cells and won't need special treatment. Include at least two
      functions.  One should take a world and the coordinates of a
      cell and return the number of neighbors (organisms in neighboring
      cells) that the cell has.  The other should take a generation array
      and return a Boolean value that tells whether or not the world
      represented by the array is empty. Write all generations to the
      screen (don't forget the generation numbers), with a prompt to the
      user to type a key when ready to see the next one.
