## The Tinusaur Plays Conway’s Game of Life

UPDATE 2022: The MAX7219LED8x8 library, now renamed to MAX7219tiny has now a new home at tinusaur.com/libraries/max7219tiny. Check also this MAX7219 & ATtiny85 tutorial to learn how the library works.

I was playing with the MAX7219LED8x8 library and writing some code for how to use a simple scheduler to automate the task of outputting the buffer to the LED 8×8 matrix. So I was thinking … may be writing a simple game will illustrate the use of those libraries very well. Because just few days earlier I was looking at some Arduino projects implementing the Conway’s Game of Life I decided to write it for ATtiny85 and MAX7219/LED 8×8.

The Game of Life is a classical computer game and a cellular automaton created by the British mathematician John Horton Conway in 1970. This is a zero-player game which means that once it starts no input from user is required to play the game’s turns – it goes by itself.

Its simple rules (outlined below) allow to be implemented on very simple microprocessor systems and Tinusaur (and ATtiny systems in general) could be perfect platform for that.

# Hardware

One Tinusaur Board connected to LED matrix 8×8 controlled by MAX7219.

# Drivers

The MAX7219Led8x8 library is used to output the pixels to the LED 8×8 matrix.

# The Rules

The universe of the Game of Life is an infinite two-dimensional orthogonal grid of square cells, each of which is in one of two possible states, alive or dead. Every cell interacts with its eight neighbours, which are the cells that are horizontally, vertically, or diagonally adjacent. At each step in time, the following transitions occur:

1. Any live cell with fewer than two live neighbours dies, as if caused by under-population.
2. Any live cell with two or three live neighbours lives on to the next generation.
3. Any live cell with more than three live neighbours dies, as if by overcrowding.
4. Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

The initial pattern constitutes the seed of the system. The first generation is created by applying the above rules simultaneously to every cell in the seed—births and deaths occur simultaneously, and the discrete moment at which this happens is sometimes called atick (in other words, each generation is a pure function of the preceding one). The rules continue to be applied repeatedly to create further generations.

# The Program

The board is defined as a short byte array:

```typedef uint8_t life_board[8];
```

An initial board is specified by the bits in that array:

```life_board life_oscillators_blinkers = {
0b00000000,
0b00000000,
0b01110000,
0b00000000,
0b00000100,
0b00000100,
0b00000100,
0b00000000
};
```

Here are the most important functions that are implemented:

```void life_board_init(life_board buffer);
void life_board_out(void);
uint8_t life_cell_count(uint8_t cx, uint8_t cy);
void life_board_turn(void);
void life_board2_copy(void);
```

The life_board_init function initializes the board with preset values and life_board_out outputs the content of the boards to the LED 8×8 matrix.

The life_cell_count function counts how many neighbors the specified cell has.

The life_board_turn performs one turn of the game based on the rules described above. It reads the data from the main buffer life_board_buffer array and stores the result in the life_board_buffer2 array. After that life_board2_copy copies the new data to the main buffer which then is outputted to the LED 8×8 matrix.

Here is the source code of the most important function – life_board_turn:

```void life_board_turn(void) {
for (uint8_t y = 0; y = 7; y++) {
for (uint8_t x = 0; x <= 7; x++) {
uint8_t count = life_cell_count(x, y);
if (LIFE_CELL_ISSET(x, y)) {
if (count < 2)
LIFE_CELL_CLR(x, y);
else if (count == 2 || count == 3)
LIFE_CELL_SET(x, y);
else if (count > 3)
LIFE_CELL_CLR(x, y);
} else {
if (count == 3)
LIFE_CELL_SET(x, y);
else
LIFE_CELL_CLR(x, y);
}
}
}
}
```

This function implements the rules of the Game of Life.

That’s it.

In the program, there is some more code that shows about 10 well know and interesting shapes such as blinker, toad, beacon, glider, etc.

The source code is part of the MAX7219LED8x8 library and it is available at https://bitbucket.org/tinusaur/max7219led8x8.