Graphics / Glider Gun

Use the graphics API to play Conway's Game of Life - Gosper's Glider Gun https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life

import time
from copy import deepcopy
from h2o_wave import site, ui, graphics as g


def get_neighbors(row, col):
    neighbors = [
        (r, c) for r in range(row - 1, row + 2) for c in range(col - 1, col + 2)
    ]
    neighbors.remove((row, col))
    return neighbors


def get_num_living(grid_state, neighbors):
    return sum([grid_state.get(x, 0) for x in neighbors])


def evaluate_grid(grid_state):
    new_grid_state = deepcopy(grid_state)
    for cell, state in grid_state.items():
        neighbors = get_neighbors(*cell)
        n_living = get_num_living(grid_state, neighbors)
        if state == 0 and n_living == 3:
            new_grid_state[cell] = 1
        elif state == 1:
            if not 1 < n_living < 4:
                new_grid_state[cell] = 0
    return new_grid_state


def get_empty_state(n_rows, n_cols):
    return {(r, c): 0 for r in range(n_rows) for c in range(n_cols)}


def apply_start_state(grid_state, pattern):
    for x in pattern:
        grid_state[x] = 1
    return grid_state


def update_grid(page, grid_state, n_rows, n_cols, background):
    scene = page['game'].scene
    for row in range(n_rows):
        for col in range(n_cols):
            if grid_state[(row, col)] == 1:
                g.draw(scene[f'cell_{row}_{col}'], fill='black')
            else:
                g.draw(scene[f'cell_{row}_{col}'], fill=background)
    page.save()


def create_grid(n_rows, n_cols, fill, width, height, stroke, stroke_width):
    grid = {}
    for row in range(n_rows):
        for col in range(n_cols):
            grid[f'cell_{row}_{col}'] = g.rect(
                x=col * width,
                y=row * height,
                width=width,
                height=height,
                fill=fill,
                stroke=stroke,
                stroke_width=stroke_width,
            )
    return grid


def render(pattern):
    page = site['/demo']

    page_cols = 4
    page_rows = 5

    box_width = 134
    box_height = 76
    gap = 15

    max_width = box_width * page_cols + (page_cols - 1) * gap
    max_height = box_height * page_rows + (page_rows - 1) * gap

    width = 10
    height = 10

    grid_cols = max_width // width
    grid_rows = max_height // height

    background = 'whitesmoke'
    stroke = 'gainsboro'
    stroke_width = 1

    grid = create_grid(
        grid_rows, grid_cols, background, width, height, stroke, stroke_width
    )
    page['game'] = ui.graphics_card(
        box=f'1 1 {page_cols} {page_rows}',
        view_box=f'0 0 {max_width} {max_height}',
        width='100%',
        height='100%',
        scene=g.scene(**grid),
    )

    grid_state = get_empty_state(grid_rows, grid_cols)
    update_grid(page, grid_state, grid_rows, grid_cols, background)

    grid_state = apply_start_state(grid_state, pattern)

    update_grid(page, grid_state, grid_rows, grid_cols, background)

    while True:
        time.sleep(0.1)
        new_grid_state = evaluate_grid(grid_state)
        update_grid(page, new_grid_state, grid_rows, grid_cols, background)
        grid_state = new_grid_state


def make_glider_gun(r, c):
    return [
        (r, c + 24),
        (r + 1, c + 22),
        (r + 1, c + 24),
        (r + 2, c + 12),
        (r + 2, c + 13),
        (r + 2, c + 20),
        (r + 2, c + 21),
        (r + 2, c + 34),
        (r + 2, c + 35),
        (r + 3, c + 11),
        (r + 3, c + 15),
        (r + 3, c + 20),
        (r + 3, c + 21),
        (r + 3, c + 34),
        (r + 3, c + 35),
        (r + 4, c + 0),
        (r + 4, c + 1),
        (r + 4, c + 10),
        (r + 4, c + 16),
        (r + 4, c + 20),
        (r + 4, c + 21),
        (r + 5, c + 0),
        (r + 5, c + 1),
        (r + 5, c + 10),
        (r + 5, c + 14),
        (r + 5, c + 16),
        (r + 5, c + 17),
        (r + 5, c + 22),
        (r + 5, c + 24),
        (r + 6, c + 10),
        (r + 6, c + 16),
        (r + 6, c + 24),
        (r + 7, c + 11),
        (r + 7, c + 15),
        (r + 8, c + 12),
        (r + 8, c + 13),
    ]


render(make_glider_gun(2, 2))

Tags:  graphics