Life Of Cells Simulation (Conway’s Game of Life) A Fascinating World of Cellular Automata

Hello Guys! Today, we’re going to dive into the world of programming and explore a fascinating concept called Conway’s Game of Life. Don’t worry if you’re new to programming; I’ll explain everything in a way that anyone can understand.

What is Conway’s Game of Life?

Imagine a grid, kind of like a chessboard, but without any pieces. This grid is made up of tiny squares, and each square can either be alive (filled) or dead (empty). Conway’s Game of Life is like a magical world where these squares come to life, and their fate is decided by some simple rules.

The Rules of Life

In this magical world, there are just four simple rules that every square follows:

1. Birth: If a dead square (empty) has exactly three live neighbors (filled squares), it comes to life in the next generation.
2. Survival: If a live square has either two or three live neighbors, it stays alive in the next generation.
3. Death by Loneliness: If a live square has fewer than two live neighbors, it dies of loneliness and becomes empty.
4. Death by Overcrowding: If a live square has more than three live neighbors, it dies because of overcrowding and becomes empty.

Let’s Play the Game

Now that we know the rules, let’s see them in action. We’ll use Python, a popular programming language, to create this magical world.

Setting Up Our Grid

First, we create a grid with squares. Each square can be alive (filled) or dead (empty). We decide how big our grid is and how fast it updates. Think of it like setting up the game board.

Managing the Grid

We need to check which squares are alive and which ones are dead in each generation. We have a function that looks at each square and decides if it should live, die, or come to life based on our four rules.

Drawing the Grid

To see what’s happening, we need to draw the grid on our computer screen. We use another function to show the squares and their colors.

Interacting with the Game

We make it easy for people to play with our magical world. You can click on the squares to make them alive or dead, and you can even pause or restart the game.

What’s the Magic?

The magic happens when you let the game run. Squares come to life, die, and create interesting patterns on the grid. Some patterns stay the same, some oscillate, and others keep growing forever. It’s like a living, breathing puzzle!

Alright now we know the concept and rules in a simple and understandable way. Now, let’s take a closer look at the Python code that brings this magical world to life.

Setting Up the Game

First, let’s set up our gaming environment. We’ll use Python with the pygame library to create a graphical interface for our simulation. Pygame is a popular choice for creating 2D games and graphical applications.

Python Libraries

import pygame
import random

We start by importing two essential libraries: `pygame` and `random`. `pygame` helps us create the game’s graphical interface, while `random` allows us to generate randomness for initial cell placement and colors.

Here, we initialize the Pygame library and set up some constants. We define the screen’s size, the size of each cell (`TILE_SIZE`), and the grid dimensions (`GRID_WIDTH` and `GRID_HEIGHT`). The `FPS` constant controls how fast the game update.

pygame.init()

BLACK = (0, 0, 0)

WIDTH, HEIGHT = 600, 600
TILE_SIZE = 20
GRID_WIDTH = WIDTH // TILE_SIZE
GRID_HEIGHT = HEIGHT // TILE_SIZE
FPS = 60

screen = pygame.display.set_mode((WIDTH, HEIGHT))

Managing the Grid

The heart of our code lies in managing the grid and applying the rules of Conway’s Game of Life.

def adjust_grid(positions, colors):
    all_neighbors = set()
    new_positions = set()
    new_colors = colors.copy()

    for position in positions:
        neighbors = get_neighbors(position)
        all_neighbors.update(neighbors)

        neighbors = list(filter(lambda x: x in positions, neighbors))

        if len(neighbors) in [2, 3]:
            new_positions.add(position)

In the `adjust_grid` function, we calculate the next generation of cells. We look at each live cell’s neighbors, count them, and decide whether they should stay alive or die based on the rules. This function is where the magic happens.

Drawing the Grid

A visual representation of the grid is essential for observing the simulation. The draw_grid() function is responsible for rendering the grid and cells on the screen.

def draw_grid(positions, colors):
    for position in positions:
        col, row = position
        top_left = (col * TILE_SIZE, row * TILE_SIZE)
        cell_color = colors[position]
        pygame.draw.rect(screen, cell_color, (*top_left, TILE_SIZE, TILE_SIZE))

    for row in range(GRID_HEIGHT):
        pygame.draw.line(screen, BLACK, (0, row * TILE_SIZE), (WIDTH, row * TILE_SIZE))

    for col in range(GRID_WIDTH):
        pygame.draw.line(screen, BLACK, (col * TILE_SIZE, 0), (col * TILE_SIZE, HEIGHT))

This function paints the cells on the screen according to their positions and colors. It also draws grid lines for a better visual representation.

Interacting with the Game

Our implementation allows for user interaction. You can click on cells to toggle their state (alive or dead) and use key commands to control the simulation. The space bar pauses and resumes the simulation, ‘c’ clears the grid, and ‘g’ generates a random pattern of cells.

# ...

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        running = False

    if event.type == pygame.MOUSEBUTTONDOWN:
        # ...
    if event.type == pygame.KEYDOWN:
        if event.key == pygame.K_SPACE:
            playing = not playing
        if event.key == pygame.K_c:
            # ...
        if event.key == pygame.K_g:
            # ...

Here, we listen for mouse clicks to toggle cells and key presses to control the game’s state, such as pausing, clearing the grid, or generating random patterns.

Acknowledgments

I was inspired by TechWithTim’s YouTube channel, particularly his tutorial on Conway’s Game of Life, for this project.

Feel free to explore the code further, modify it, and use it as a stepping stone to delve deeper into the mesmerizing world of cellular automata. If you’re eager to dive right in and get the complete program, you can find it on my GitHub.

Happy coding, and may your journey through the intricate patterns of Conway’s Game of Life be as captivating as the rules that govern it.