less_retarded_wiki/game_of_life.md

# Game Of Life

*--> Reveal the secret of life with these four simple rules! <--*

Game of Life (sometimes just *Life*) is probably the most famous [cellular automaton](cellular_automaton.md) (mathematical simulation set on a grid of cells), which with only four simple rules gives rise to a world with patterns that seem to behave similarly to simple biological [life](life.md). It was invented in 1970 by [John Conway](john_conway.md), a famous mathematician who researched games, and has since gained popularity among programmers, mathematicians and other nerds as it's not only scientifically valuable, it is also [awesome](beauty.md) and [fun](fun.md) to play around with as a kind of [sandbox](sandbox.md) toy; it is very easy to program, play around with, modify and can be explored to great depth. The word *game* is used because what we have here is really a zero-player mathematical [game](game.md), which is furthermore completely [deterministic](determinism.md) (there is no randomness), so we only choose some starting state of the world and then watch the game "play itself". Game of Life is similar systems such as [rule 110](rule110.md) and [Langton's ant](langtons_ant.md).

```
. [][]. . . . . . . . []. []. . . . . .        . [][][]. . . . . . . []. []. . . . . .
[]. . [][]. . . . . . . []. . . . . . .        []. . . []. . . . . . . []. . . . . . .
[][]. [][]. . . . . . . . . . . . . . .        . . . . . []. . . . . . . . . . . . . []
[][]. . []. . . . . . . . . . . . []. .        []. . . []. . . . . . . . . . . . []. []
. . [][]. . . . . . . . . . . . []. [].        . [][][]. . . . . . . . . . . . []. [].
. . . . . . . . . . . []. . . . . []. .        . . . . . . . . . . . []. . . . . []. .
. . . . . . . . . . []. []. . . . . . .        . . . . . . . . . . []. []. . . . . . .
. . . . . . . . . . []. []. . . . . . .        . . . . . . . . . . []. []. . . . . . .
. . . . . . . . . . . []. . . . . . . .        . . . . . . . . . . . []. . . . . . . .
. . . . . . . . . . . . . . [][]. . . .  ___\  . . . . . . . . . . . . . . [][]. . . .
. . . . . . . . . . . . . . [][]. . . .     /  . . . . . . . . . . . . . . [][]. . . .
. . . . . . . . . . . . . . . . . . . .        . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .        . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .        . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .        . . . . . . . . . . . . . . . . . . . .
. . . . . . . . []. []. . . . [][]. . .        . . . . . . . . . . []. . . . [][]. . .
. . . . . . . . . [][]. . . []. . []. .        . . . . . . . . []. []. . . []. . []. .
. . . . . . . . . []. . . . . [][]. . .        . . . . . . . . . [][]. . . . [][]. . .
. . . . . . . . . . . . . . . . . . . .        . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . [][]. . . . . . .        . . . . . . . . . . . [][]. . . . . . .
```

*Two consecutive frames of the game, notice the glider at bottom middle, which keeps moving bottom right, and still life forms in the right part, which just stay still.*

Study of the game goes extremely deep, people are discovering new patterns and concepts. See e.g. LifeWiki at https://conwaylife.com/wiki/Main_Page, Catalogue at https://catagolue.hatsya.com or Life Lexicon at https://conwaylife.com/ref/lexicon/lex.htm. The Catalogue claims to have discovered 478223 distinct types of objects so far, LifeWiki has 1651 documented patterns (many with just boring numeric names, other ones with funny names like *[Cthulhu](cthulhu.md)*, *En retard*, *Meatball*, *p58 toadsucker*, *Overweight spaceship*, *Why not*, even *[Unix](unix.md)* lol).

The following is a sum up of some basic properties of the game, many of which should show why it is so significant:

- There are only four rules and they are extremely simple but at the same time they give rise to extremely complex behavior, demonstrating emergent behavior, a very important concept.
- It resembles biological [life](life.md), showing structures that come to life, move, replicate, merge, die, organize into bigger structures etc., showing that life may really arise from a few simple rules.
- It is a class 4 cellular automaton, meaning its behavior is "interesting": sometimes it behaves orderly, sometimes in chaotic ways, sometimes the state stabilizes quickly, sometimes it evolves in complex ways for very long time etc.
- It shows many other phenomena such as [chaotic behavior](chaos.md), non-chaotic behavior, self-replication, self-organization, oscillation, [self hosting](self_hosting.md) (**you can program Game of Life in Game of Life!**) etc.
- It is [Turing complete](turing_complete.md), meaning the game can be used as a universal computer, with the same computational power as any other computer.
- It is very fun to play around with. There are many creatures to discover, observe and document (making this kind of a Pokémon game lol?).

## Rules And Their Implications

We have an [infinite](infinity.md), regular two dimensional grid of cells, each of which may be in one of two states: alive or dead. Each cell considers its nearest eight cells its neighbors. The game runs in discrete steps, or rounds. Every round each cell counts its neighbors' states and will set its state for the next round according to these rules:

| current state | next state alive if    | next state dead if          |
| ------------- | ---------------------- | --------------------------- |
| alive         | 2 or 3 live neighbors  | else (under/overpopulation) |
| dead          | 3 live neighbors       | else                        |

TODO: basic structures, chaos vs order etcetc.

## Code/Programming

The following is a simple [C](c.md) implementation of a [wrapping](wrap.md) version of game of life (i.e. the world is not actually infinite):

```
#include <stdio.h>

#define WORLD_SIZE 20

unsigned char world[WORLD_SIZE * WORLD_SIZE];

unsigned char getCell(int x, int y)
{
  return world[y * WORLD_SIZE + x] & 0x01;
}

void setCell(int x, int y)
{
  world[y * WORLD_SIZE + x] |= 0x01;
}

int main(void)
{
  unsigned char random = 30;

  for (int i = 0; i < WORLD_SIZE * WORLD_SIZE; ++i)
  {
    world[i] = random > 127;
    random = random * 13 + 22;
  }

  char in = 0;
  int step = 0;

  while (in != 'q')
  {
    unsigned char *cell = world;

    for (int y = 0; y < WORLD_SIZE; ++y)
    {
      int yU = y == 0 ? (WORLD_SIZE - 1) : (y - 1),
          yD = (y + 1) % WORLD_SIZE,
          xL = WORLD_SIZE - 1,
          xR = 1;

      for (int x = 0; x < WORLD_SIZE; ++x)
      {
        int neighbors =
          getCell(xL,yU) + getCell(x,yU) + getCell(xR,yU) +
          getCell(xL,y)  +                 getCell(xR,y)  +
          getCell(xL,yD) + getCell(x,yD) + getCell(xR,yD);

        if ((*cell) & 0x01)
        {
          putchar('[');
          putchar(']');

          if (neighbors == 2 || neighbors == 3)
            *cell |= 0x02;
        }
        else
        {
          putchar('.');
          putchar(' ');

          if (neighbors == 3)
            *cell |= 0x02;
        }

        xL = x;
        xR = (x + 2) % WORLD_SIZE;

        cell++;
      }

      putchar('\n');
    }
  
    for (int i = 0; i < WORLD_SIZE * WORLD_SIZE; ++i)
      world[i] >>= 1;

    printf("\nstep %d\n",step);
    puts("press RETURN to step, Q to quit");

    step++;
    in = getchar();
  }

  return 0;
}
```

The world cells are kept in the `world` array -- each cell holds the current state in the lowest bit. We perform drawing and update of the world at the same time. Notice especially that while updating the cells, we mustn't overwrite the cell's current state until its neighbors have been updated as well! Not realizing this is a **common beginner error** and results in so called [naive](naive.md) implementation. We avoid this error by first storing each cell's next state in the second lowest bit (keeping its current state in the lowest bit), and then, after all cells have been updated, we iterate over all cells again and perform one bit shift to the left (making the computed next states into current states).

TODO: extensions, continuous, code, optimizations

## Extensions, Modifications And Generalizations

Game of Life can be extended in great number of ways, some notable are e.g.:

- **[Larger Than Life](ltl.md) (LTL)**: Extended neighborhood of cells; one variant is e.g. 9x9 neighbourhood, cell dies with 34 to 58 live neigbors, dead cell becomes live with 34 to 45 live neighbors. Produces interesting, more smooth, bubble-like patterns that can move in various angles.
- **[Smooth Life](smooth_life.md)**: Continuous generalization of Game of Life, time steps are still discrete.
- **[Lenia](lenia.md)**: A relatively recent, highly generalized continuous version of Game of Life -- unlike Smooth Life all variables are continuous here, including space, time and states. This system produces incredible patterns and great many organisms.
- **different grid geometry, more states, additional rules, ...**: Slight modifications one can make to experiment, e.g. trying out hexagonal grid, triangular grid, [hyperbolic space](hyperbolic.md), 3D and higher dimensional grids, more states (e.g. cells that remember their age) etc. Modifying the base rules is also possible, creating so called life-like automata: the basic game of life is denoted as B3/S23 (born with 3, stays alive with 2 or 3), some life-like variants include e.g. High Life which adds a rule that a dead cell with 6 live neighbors comes alive (B36/S23) -- this gives rise to a new pattern known as *replicator*.

TODO