Given an array of integers.

For row = r and column = c, 
  If array(r, c) is equal to zero, we say that position is "dead"
  If array(r, c) is equal to one,  we say that position is "alive"

It is assumed that a function is available to count the
number of "live" neighbors of any position, as follows

    In general, the function will investigate the eight cells
    in the range defined by
    (r-1 <= row <= r+1), (c-1 <= col <= c+1), row not equal to col

    The return value is the count of the number of live cells in this range.

    Assuming a finite grid, special care must be taken at the 
    borders, to make sure you don't go out of the grid.

Anyhow, with that function correctly implemented, each move
is calculated as follows:

Copy the existing array into a new array: next_array

Here's the move:

FOR r in the range of rows
BEGIN LOOP
    FOR c in the range of columns
    BEGIN LOOP
        count = number of live neighbors of array(r, c)
        IF (array(r, c) is equal to zero)      <== it's now dead
        THEN
            IF (count is equal to 3)
            THEN
                set next_array(r, c) to one    <== it comes to life
            END IF
        ELSE                                   <== it's now alive
           IF (count is less than 2) or (count is greater than 3)
           THEN
               set next_array(r, c) to zero    <== it dies
           END IF
        END IF
    END LOOP <== columns
END LOOP     <== rows

Then copy next_array into array to show the results of the move
and to get ready for the next move

    (r-1 <= row <= r+1), (c-1 <= col <= c+1), (row,col) not equal to (r,c)

Here is a function to count the number of live neighbors of the 
element array(r, c), assuming the index values go from 0 through
R-1 and 0 through C-1, respectively:


BEGIN Integer FUNCTION CountLiveNeighbors(array, r, c)
  
  Declare a local integer variable "count", and set "count" to zero.
  Declare two local integer variables: "rr", and "cc"
  
  First Loop: let rr go from -1 to 1 in steps of 1
  BEGIN LOOP1
      Second loop: let cc go from -1 to 1 in steps of 1
      BEGIN LOOP2
          IF (((rr is not equal to zero) OR (cc is not equal to zero)) <-- self
              AND (r + rr) is greater than or equal to zero <-- check low  row
              AND (c + cc) is greater than or equal to zero <-- check low  col
              AND (r + rr) is less than R                   <-- check high row
              AND (c + cc) is less than C                   <-- check high col
             )
          THEN
              SET count = count + array(r+rr, c+cc); <-- increment count if alive
          END IF
      END LOOP2
  END LOOP1
  
  RETURN count
  
END FUNCTION CountLiveNeighbors

CLS
RANDOMIZE TIMER
SCREEN 12




COLOR 10
PRINT "Game of life."
INPUT "First coordinate of grid: ", co1
INPUT "Enter second coordinate of grid: ", co2
INPUT "Set color (0 to 15) : ", col
DIM oldgen(co2 - co1, co2 - co1) AS INTEGER 'declaring  old gen array
DIM newgen(co2 - co1, co2 - co1) AS INTEGER 'declaring new generation array


CLS
LINE (co1, co1 - 1)-(co2 + 1, co2 + 1), 15, B  'the frame of the whole autotmate
oldgen(75, 75) = 1 ' the following are the coordinates for a glider
oldgen(75, 76) = 1
oldgen(75, 77) = 1
oldgen(74, 77) = 1
oldgen(73, 76) = 1


 FOR i = 1 TO (co2 - co1) 'displaying the old generation array (glider...)
    FOR j = 1 TO (co2 - co1)
   IF oldgen(i, j) > 0 THEN
    PSET(j + co1,i + co1),col
   END IF
    NEXT
 NEXT

DO WHILE  true     'infinite outer loop repeating the whole algorithm  
 counter = 0   'initializing counter
FOR i = 1 TO (co2 - co1)
    FOR j = 1 TO (co2 - co1)
     IF ((j + 1) < (co2 - co1)) AND ((i + 1) < (co2 - co1)) THEN 'see if cell is not on border, and if not       
       IF oldgen(i - 1, j - 1) > 0 THEN    'checking neighbours and incrementing 
       counter = counter + 1  'counter for each "living" cell       
      END IF

       IF oldgen(i - 1, j) > 0 THEN
       counter = counter + 1
       END IF

       IF oldgen(i - 1, j + 1) > 0 THEN
       counter = counter + 1
       END IF

       IF oldgen(i, j - 1) > 0 THEN
       counter = counter + 1
       END IF

       IF oldgen(i, j + 1) > 0 THEN
       counter = counter + 1
       END IF

       IF oldgen(i + 1, j - 1) > 0 THEN
       counter = counter + 1
       END IF

       IF oldgen(i + 1, j) > 0 THEN
       counter = counter + 1
       END IF

       IF oldgen(i + 1, j + 1) > 0 THEN
       counter = counter + 1
       END IF
    END IF

    IF (oldgen(i, j) > 0) AND ((counter = 2) OR (counter = 3)) THEN 'if the cell 
    newgen(i, j) = 1 ' is alive and has 2 or 3 neighbours it will be alive in the 
    END IF 'next step too. so fill newgen array with a 1.
    IF (oldgen(i, j) = 0) AND (counter = 3) THEN 'if the cell is dead and has 3
    newgen(i, j) = 1 'neighbours, it will be alive in the next step.fill newgen 
    END IF ' with a 1.
   NEXT
NEXT

 FOR i = 1 TO (co2 - co1) ' display the new generation
    FOR j = 1 TO (co2 - co1)
   IF newgen(i, j) > 0 THEN
    PSET(j + co1,i + co1),col
   END IF
    NEXT
 NEXT

 FOR i = 1 TO (co2 - co1) 
    FOR j = 1 TO (co2 - co1)
    oldgen(i, j) = newgen(i, j)'set oldgen array to newgen array
    newgen(i, j) = 0 'reinitialize newgen to 0
    NEXT
 NEXT

LOOP

DO WHILE  true     'infinite outer loop repeating the whole algorithm  
 counter = 0   'initializing counter <--- Huh?
FOR i = 1 TO (co2 - co1)
    FOR j = 1 TO (co2 - co1)
.
.
.
       'increment counter for each live neighbor of oldgen(i, j)
       'update newgen(i,j), depending on value of counter
.
.
.
    NEXT 'j
NEXT 'i
.
.
.

DO WHILE  true     'infinite outer loop repeating the whole algorithm  

FOR i = 1 TO (co2 - co1)
    FOR j = 1 TO (co2 - co1)
        counter = 0   'initializing counter
.
.
.
        'increment counter for each live neighbor of oldgen(i, j)
        'update newgen(i,j), depending on value of counter
.
.
.
    NEXT 'j
NEXT 'i
.
.
.