Bonus Project: Conway's Game of Life

What This Is

Four rules, and then things start happening that nobody wrote. A grid of squares. Each one lives or dies based only on how many of its eight neighbors are alive. Out of that come shapes that hold still, shapes that blink, and shapes that walk across the screen — none of which appear anywhere in the code.

This is the hardest project on the list, and it is the only one that is not a game. It is also the one that most looks like computer science, which is why it is worth ten points.

This is extra credit and it is optional. Nothing later in the course depends on it.

Before You Start

You need everything through session 20. Tables, nested loops, and conditions joined with and and or. All of it, all at once — this project uses more of Quarter 1 than anything else on the list.

One idea here is new, and it is not a new function. The grid is two-dimensional and a table is a single list, so you flatten it:

grid[(row - 1) * COLS + col]

Row 1 takes slots 1 to COLS, row 2 takes the next COLS, and so on. Write that line on paper with real numbers before you use it — row 3, column 5, with 40 columns, is slot 85. If you cannot get 85 by hand, the rest of this project will not go well.

Copy template-game and rename it bp-game-of-life. No new files, no libraries, nothing to install.

Build It

Five stages, and the whole file is printed at the end of every one. Run it after each stage — this project is much easier to debug in pieces than in one go, and much harder than average to debug at the end.

Type it rather than pasting it. The reading you do on the way is the whole point, and pasting skips all of it. When something breaks, the listing at the end of the stage is what your file should look like.

1. A grid you can see

Constants for COLS, ROWS and CELL — 40, 30 and 20 fill an 800 by 600 window exactly. Fill grid with COLS * ROWS zeros, then set a handful of them to 1 by hand and draw the live ones.

Nothing changes yet. If the squares you set by hand are in the places you expected, your index arithmetic is right and the hard part is behind you.

The whole file after stage 1:

1
math.randomseed(os.time())
2

3
local COLS = 40
4
local ROWS = 30
5
local CELL = 20
6

7
local grid = {}
8

9
for i = 1, COLS * ROWS do
10
    if math.random(1, 100) <= 25 then
11
        grid[i] = 1
12
    else
13
        grid[i] = 0
14
    end
15
end
16

17
function love.draw()
18
    for row = 1, ROWS do
19
        for col = 1, COLS do
20
            if grid[(row - 1) * COLS + col] == 1 then
21
                love.graphics.setColor(0.4, 0.95, 0.6)
22
                love.graphics.rectangle(
23
                    "fill",
24
                    (col - 1) * CELL + 1,
25
                    (row - 1) * CELL + 1,
26
                    CELL - 2,
27
                    CELL - 2
28
                )
29
            end
30
        end
31
    end
32
end
33

34
function love.keypressed(key)
35
    if key == "escape" then
36
        love.event.quit()
37
    end
38
end

2. A clock

Life runs in generations, not frames. Sixty a second is far too fast to watch:

timer = timer + dt

if timer < STEP then
    return
end

timer = 0

STEP = 0.12 is about eight generations a second, which is fast enough to feel alive and slow enough to follow.

The whole file after stage 2:

1
math.randomseed(os.time())
2

3
local COLS = 40
4
local ROWS = 30
5
local CELL = 20
6
local STEP = 0.12
7

8
local grid = {}
9
local timer = 0
10
local steps = 0
11

12
for i = 1, COLS * ROWS do
13
    if math.random(1, 100) <= 25 then
14
        grid[i] = 1
15
    else
16
        grid[i] = 0
17
    end
18
end
19

20
function love.update(dt)
21
    timer = timer + dt
22

23
    if timer < STEP then
24
        return
25
    end
26

27
    timer = 0
28
    steps = steps + 1
29
end
30

31
function love.draw()
32
    for row = 1, ROWS do
33
        for col = 1, COLS do
34
            if grid[(row - 1) * COLS + col] == 1 then
35
                love.graphics.setColor(0.4, 0.95, 0.6)
36
                love.graphics.rectangle(
37
                    "fill",
38
                    (col - 1) * CELL + 1,
39
                    (row - 1) * CELL + 1,
40
                    CELL - 2,
41
                    CELL - 2
42
                )
43
            end
44
        end
45
    end
46

47
    love.graphics.setColor(1, 1, 1)
48
    love.graphics.print("steps: " .. steps, 10, 10)
49
end
50

51
function love.keypressed(key)
52
    if key == "escape" then
53
        love.event.quit()
54
    end
55
end

3. Count the neighbors

Two more loops inside the two you already have, going from −1 to 1 in each direction. That is nine squares, one of which is the cell itself:

local neighbors = 0

for dr = -1, 1 do
    for dc = -1, 1 do
        local r = row + dr
        local c = col + dc
        local skip = (dr == 0 and dc == 0)

        if not skip and r >= 1 and r <= ROWS and c >= 1 and c <= COLS then
            neighbors = neighbors + grid[(r - 1) * COLS + c]
        end
    end
end

The edge check is not optional. A cell in row 1 has neighbors in row 0, which does not exist. In Lua that is not an error — grid[0] is nil, and adding nil to a number crashes three lines later with a message about the wrong thing. This is session 19, and it is the bug that will find you.

The whole file after stage 3:

1
math.randomseed(os.time())
2

3
local COLS = 40
4
local ROWS = 30
5
local CELL = 20
6

7
local grid = {}
8
local counts = {}
9

10
for i = 1, COLS * ROWS do
11
    if math.random(1, 100) <= 25 then
12
        grid[i] = 1
13
    else
14
        grid[i] = 0
15
    end
16
end
17

18
function love.update(dt)
19
    for row = 1, ROWS do
20
        for col = 1, COLS do
21
            local neighbors = 0
22

23
            for dr = -1, 1 do
24
                for dc = -1, 1 do
25
                    local r = row + dr
26
                    local c = col + dc
27
                    local skip = (dr == 0 and dc == 0)
28

29
                    if not skip and r >= 1 and r <= ROWS and c >= 1 and c <= COLS then
30
                        neighbors = neighbors + grid[(r - 1) * COLS + c]
31
                    end
32
                end
33
            end
34

35
            counts[(row - 1) * COLS + col] = neighbors
36
        end
37
    end
38
end
39

40
function love.draw()
41
    for row = 1, ROWS do
42
        for col = 1, COLS do
43
            local i = (row - 1) * COLS + col
44

45
            if grid[i] == 1 then
46
                love.graphics.setColor(0.4, 0.95, 0.6)
47
                love.graphics.rectangle(
48
                    "fill",
49
                    (col - 1) * CELL + 1,
50
                    (row - 1) * CELL + 1,
51
                    CELL - 2,
52
                    CELL - 2
53
                )
54
            end
55

56
            if counts[i] > 0 then
57
                love.graphics.setColor(1, 1, 1, 0.7)
58
                love.graphics.print(
59
                    counts[i], (col - 1) * CELL + 6, (row - 1) * CELL + 3
60
                )
61
            end
62
        end
63
    end
64
end
65

66
function love.keypressed(key)
67
    if key == "escape" then
68
        love.event.quit()
69
    end
70
end

4. The four rules, as two conditions

The rules everybody quotes are four sentences. Written down they collapse into two:

local here = grid[(row - 1) * COLS + col]
local alive = 0

if here == 1 and (neighbors == 2 or neighbors == 3) then
    alive = 1
end

if here == 0 and neighbors == 3 then
    alive = 1
end

A live cell with 2 or 3 neighbors stays alive. A dead cell with exactly 3 comes alive. Everything else dies or stays dead, and that is what alive = 0 at the top already says.

The whole file after stage 4:

1
math.randomseed(os.time())
2

3
local COLS = 40
4
local ROWS = 30
5
local CELL = 20
6
local STEP = 0.12
7

8
local grid = {}
9
local timer = 0
10

11
for i = 1, COLS * ROWS do
12
    if math.random(1, 100) <= 25 then
13
        grid[i] = 1
14
    else
15
        grid[i] = 0
16
    end
17
end
18

19
function love.update(dt)
20
    timer = timer + dt
21

22
    if timer < STEP then
23
        return
24
    end
25

26
    timer = 0
27

28
    for row = 1, ROWS do
29
        for col = 1, COLS do
30
            local neighbors = 0
31

32
            for dr = -1, 1 do
33
                for dc = -1, 1 do
34
                    local r = row + dr
35
                    local c = col + dc
36
                    local skip = (dr == 0 and dc == 0)
37

38
                    if not skip and r >= 1 and r <= ROWS and c >= 1 and c <= COLS then
39
                        neighbors = neighbors + grid[(r - 1) * COLS + c]
40
                    end
41
                end
42
            end
43

44
            local here = grid[(row - 1) * COLS + col]
45
            local alive = 0
46

47
            if here == 1 and (neighbors == 2 or neighbors == 3) then
48
                alive = 1
49
            end
50

51
            if here == 0 and neighbors == 3 then
52
                alive = 1
53
            end
54

55
            grid[(row - 1) * COLS + col] = alive
56
        end
57
    end
58
end
59

60
function love.draw()
61
    for row = 1, ROWS do
62
        for col = 1, COLS do
63
            if grid[(row - 1) * COLS + col] == 1 then
64
                love.graphics.setColor(0.4, 0.95, 0.6)
65
                love.graphics.rectangle(
66
                    "fill",
67
                    (col - 1) * CELL + 1,
68
                    (row - 1) * CELL + 1,
69
                    CELL - 2,
70
                    CELL - 2
71
                )
72
            end
73
        end
74
    end
75
end
76

77
function love.keypressed(key)
78
    if key == "escape" then
79
        love.event.quit()
80
    end
81
end

5. The trap: build a second grid

Do not write the answers back into grid while you are reading it. Every generation has to be computed from the previous one all at once. Write results into a new table, and replace grid with it only when every cell is done.

Get this wrong deliberately, once. Update in place and watch: everything smears down and to the right, because the cells you have already changed are being counted as neighbors by the cells you have not reached yet. It is a beautiful bug and it looks nothing like Life.

Then seed the grid randomly — about a quarter of the cells alive is a good soup — and watch it settle.

The Whole Program

Every stage above, finished and in one piece. This is the exact file the picture below came from — nothing is left out and nothing is abbreviated.

1
math.randomseed(os.time())
2

3
local COLS = 40
4
local ROWS = 30
5
local CELL = 20
6
local STEP = 0.12
7

8
local grid = {}
9
local timer = 0
10

11
for i = 1, COLS * ROWS do
12
    if math.random(1, 100) <= 25 then
13
        grid[i] = 1
14
    else
15
        grid[i] = 0
16
    end
17
end
18

19
function love.update(dt)
20
    timer = timer + dt
21

22
    if timer < STEP then
23
        return
24
    end
25

26
    timer = 0
27

28
    local nextGrid = {}
29

30
    for row = 1, ROWS do
31
        for col = 1, COLS do
32
            local neighbors = 0
33

34
            for dr = -1, 1 do
35
                for dc = -1, 1 do
36
                    local r = row + dr
37
                    local c = col + dc
38
                    local skip = (dr == 0 and dc == 0)
39

40
                    if not skip and r >= 1 and r <= ROWS and c >= 1 and c <= COLS then
41
                        neighbors = neighbors + grid[(r - 1) * COLS + c]
42
                    end
43
                end
44
            end
45

46
            local here = grid[(row - 1) * COLS + col]
47
            local alive = 0
48

49
            if here == 1 and (neighbors == 2 or neighbors == 3) then
50
                alive = 1
51
            end
52

53
            if here == 0 and neighbors == 3 then
54
                alive = 1
55
            end
56

57
            nextGrid[(row - 1) * COLS + col] = alive
58
        end
59
    end
60

61
    grid = nextGrid
62
end
63

64
function love.draw()
65
    for row = 1, ROWS do
66
        for col = 1, COLS do
67
            if grid[(row - 1) * COLS + col] == 1 then
68
                love.graphics.setColor(0.4, 0.95, 0.6)
69
                love.graphics.rectangle(
70
                    "fill",
71
                    (col - 1) * CELL + 1,
72
                    (row - 1) * CELL + 1,
73
                    CELL - 2,
74
                    CELL - 2
75
                )
76
            end
77
        end
78
    end
79
end
80

81
function love.keypressed(key)
82
    if key == "escape" then
83
        love.event.quit()
84
    end
85
end

What Success Looks Like

A black 800 by 600 window with clusters of green squares on a 40 by 30 grid, including several rings, blocks and diagonal chains

A random soup, a few seconds in. The 2 by 2 blocks and the rings are stable and will sit there forever. The loose diagonal chains are still resolving. None of those shapes are in the code — they are what two conditions do when you leave them running.

Then Make It Yours

Draw with the mouse. Click a cell to toggle it. Turning screen coordinates into a row and a column is the index arithmetic from stage 1, backwards.
Pause and step. Space to freeze, and a key that advances exactly one generation. This is worth more than any other item on this list, because it is the difference between watching Life and being able to check whether your rules are right.
Build a glider. Five cells in the right arrangement walk diagonally across the grid forever. Look up the shape, place it by hand, and watch it leave.
Wrap the edges. Make row 30's neighbors include row 1. The grid becomes a doughnut and gliders never fall off. This replaces your edge check with arithmetic, and MOD is how.
Age the cells. Color each live cell by how long it has been alive. Another table the same size as the grid.
After session 21, refactor it. The neighbor count wants to be a function that takes a row and a column and hands back a number. Doing that to code you already have is the clearest possible demonstration of what functions are for.

The walkthrough is not the submission. Getting the program running earns the credit; what you change afterward is what makes it worth reading. Hand in the folder and a sentence saying what you added, or what broke and what you did about it.