wasp-os/wasp/apps/gameoflife.py

# SPDX-License-Identifier: LGPL-3.0-or-later
# Copyright (C) 2020 Daniel Thompson
"""Conway's Game of Life.

On 11 April 2020 John H. Conway who, among many, many other
achievements, devised the rule set for his Game of Life, died of
complications from a COVID-19 infection.

The Game of Life is the first "toy" program I ever recall seeing on a
computer (running in a mid 1980s Apple Macintosh). It sparked something
even if "toy" is perhaps an underwhelming description of the Game of Life.
Either way it occupies a special place in my childhood. For that, this
application is dedicated to Professor Conway.
"""

import array
import machine
import micropython
import wasp

@micropython.viper
def xorshift12(v: int) -> int:
    """12-bit xorshift pseudo random number generator.

    With only 12-bits of state this PRNG is another toy! It appears
    here because it allows us to visit every possible 12-bit value
    (except zero) whilst taking an interesting route. This allows us to
    make the redraw (which is too slow to fully conceal) visually
    engaging.
    """
    v ^= v << 1
    v ^= (v >> 3) & 0x1ff
    v ^= (v << 7)

    return v & 0xfff

@micropython.viper
def get_color(v: int) -> int:
    r = v >> 10
    g = (v >> 8) & 7
    b = (v >> 5) & 3

    return (r << 13) | (g << 7) | (b << 1) | 0x9c73

@micropython.viper
def get_cell(board, stride: int, x: int, y: int) -> bool:
    b = ptr32(board)
    xw = x >> 5
    xb = x & 0x1f
    yw = y * (stride >> 5)

    return bool(b[yw + xw] & (1 << xb))

@micropython.viper
def set_cell(board, stride: int, x: int, y: int, v: bool):
    b = ptr32(board)
    xw = x >> 5
    xb = x & 0x1f
    yw = y * (stride >> 5)
    m = 1 << xb
    c = b[yw + xw]

    # viper doesn't implement bitwise not so we are having
    # to clear bits using xor...
    if v:
        b[yw + xw] = c | m
    elif c & m:
        b[yw + xw] = c ^ m

@micropython.viper
def game_of_life(b, xmax: int, ymax: int, nb):
    """Run a single generation of Conway's Game of Life

    1. Death by isolation: a cell dies if has fewer than two live neighbours.

    2. Death by overcrowding: a cell dies if it has more than three live
       neighbours.

    3. Survival: a living cell continues to survive if it has two or three
       neighbours.

    4. Reproduction: a dead cell comes alive if it has exactly three
       neighbours.

    In the code below we have simplified the above rules to "a cell is
    alive it has three live neighbours or if it was previously alive
    and has two neighbours, otherwise it is dead.".
    """
    board = ptr32(b)
    next_board = ptr32(nb)

    for y in range(1, ymax-1):
        tm = int(get_cell(board, xmax, 0, y-1))
        tr = int(get_cell(board, xmax, 1, y-1))
        cm = int(get_cell(board, xmax, 0, y))
        cr = int(get_cell(board, xmax, 1, y))
        bm = int(get_cell(board, xmax, 0, y+1))
        br = int(get_cell(board, xmax, 1, y+1))

        for x in range(1, xmax-1):
            tl = tm
            tm = tr
            tr = int(get_cell(board, xmax, x+1, y-1))
            cl = cm
            cm = cr
            cr = int(get_cell(board, xmax, x+1, y))
            bl = bm
            bm = br
            br = int(get_cell(board, xmax, x+1, y+1))

            c = tl + tm + tr + cl + cr + bl + bm + br

            set_cell(next_board, xmax, x, y, c == 3 or (cm and c == 2))

# 2-bit RLE, generated from res/gameoflife.png, 404 bytes
# The icon is a carefully selected generation of an "acorn", I wanted
# to avoid using a glider, they are overused to the point of cliche!
icon = (
    b'\x02'
    b'`@'
    b'?\xff\xff\xee@\xd7B\x02B\x02B?\x16L?\x15'
    b'L?\x16B\x02B\x02B?\x1bB?\x1eD?\x1d'
    b'D?\x1eB?\x17\x80\xbe\x82\x02\x82\x06\x82\x02\x82?'
    b'\x0e\x88\x04\x88?\r\x88\x04\x88?\x0e\x82\x02\x82\x06B'
    b'\x02\x82?\x03\xc0\x97\xc2\x02\xc2\x02\xc2\x02\xc2\x02\xc2\x02'
    b'\xc2\x02\xc2\x02\xc2\x02\xc2\x02\xc2\x02\xc25\xec4\xec5'
    b'\xc2\x02\xc2\x02\xc2\x02\xc2\x02\xc2\x02\xc2\x02\xc2\x02\xc2\x02'
    b'\xc2\x02\xc2\x02\xc2*B\x02B\x12\xc2\x06B\x06\xc2\x12'
    b'B\x02B\x1dH\x10\xc4\x04D\x04\xc4\x10H\x1cH\x10'
    b'\xc4\x04D\x04\xc4\x10H\x1dB\x02B\x12\xc2\x06B\x06'
    b'\xc2\x12B\x02B\x1eB\x16\xc2\x0e\xc2\x16B\x1dD\x14'
    b'\xc4\x0c\xc4\x14D\x1cD\x14\xc4\x0c\xc4\x14D\x1dB\x16'
    b'\xc2\x0e\xc2\x16B\x1eB>B\x1dD<D\x1cD<'
    b'D\x1dB>B"B\x02B\x06B\x02B\x02B\x0e'
    b'B\x02B\x02B\x06B\x02B%H\x04L\x0cL\x04'
    b'H$H\x04L\x0cL\x04H%B\x02B\x06B\x02'
    b'B\x02B\x0eB\x02B\x02B\x06B\x02B2B\n'
    b'B\x06B\nB=D\x08D\x04D\x08D<D\x08'
    b'D\x04D\x08D=B\nB\x06B\nB>B\x02'
    b'B\x06\x82\x06\x82\x06B\x02B=H\x04\x84\x04\x84\x04'
    b'H<H\x04\x84\x04\x84\x04H=B\x02B\x06\x82\x06'
    b'\x82\x06B\x02B>\x82\x02\x82\x16\x82\x02\x82=\x88\x14'
    b'\x88<\x88\x14\x88=\x82\x02\x82\x16\x82\x02\x82>\x82\x02'
    b'\x82\x02\x82\x0e\x82\x02\x82\x02\x82=\x8c\x0c\x8c<\x8c\x0c'
    b'\x8c=\x82\x02\x82\x02\x82\x0e\x82\x02\x82\x02\x82?\xff\xff'
    b'\xe2'
)

class GameOfLifeApp():
    """Application implementing Conway's Game of Life.
    """
    NAME = 'Life'
    ICON = icon

    def __init__(self):
        """Initialize the application."""
        self._board = array.array('I', [0] * (64*64//32))
        self._next_board = array.array('I', self._board)
        self._color = 1
        self.touch(None)

    def foreground(self):
        """Activate the application."""
        self._draw()
        wasp.system.request_event(wasp.EventMask.TOUCH)
        wasp.system.request_tick(1000)

    def tick(self, ticks):
        """Notify the application that its periodic tick is due."""
        wasp.system.keep_awake()

        #t = machine.Timer(id=1, period=8000000)
        #t.start()

        game_of_life(self._board, 64, 64, self._next_board)
        #t1 = t.time()
        self._update()

        #t2 = t.time()
        #t.stop()
        #del t
        #wasp.watch.drawable.string('{:4.2f}s {:4.2f}s'.format(t1 / 1000000,
        #                                                    t2 / 1000000), 6, 210)

    def touch(self, event):
        """Notify the application of a touchscreen touch event."""
        board = self._next_board
        for i in range(len(board)):
            board[i] = 0
        board[62] = 32 << 16
        board[64] = 8 << 16
        board[66] = 103 << 16

        if None != event:
            self._update()

    def _draw(self):
        """Draw the display from scratch."""
        wasp.watch.drawable.fill()
        board = self._board
        for i in range(len(board)):
            board[i] = 0
        self._update()

    def _update(self):
        """Update the dynamic parts of the application display."""
        b = self._board
        nb = self._next_board
        self._board = nb
        self._next_board = b

        display = wasp.watch.display
        lb = display.linebuffer
        alive = memoryview(lb)[0:2*16]
        self._color = xorshift12(self._color)
        rgbhi = get_color(self._color)
        rgblo = rgbhi & 0xff
        rgbhi >>= 8
        for i in range(0, len(alive), 2):
            alive[i] = rgbhi
            alive[i+1] = rgblo
        for i in (0, 3,  12, 15):
            alive[i*2] = 0
            alive[i*2+1] = 0
        dead = memoryview(lb)[2*16:4*16]
        for i in range(len(dead)):
            dead[i] = 0

        def draw_cell(cell, display, px):
            x = ((cell & 0x3f) - 2) * 4
            y = ((cell >> 6) -2) * 4
            if x < 0 or x >= 240 or y < 0 or y >= 240:
                return

            display.set_window(x, y, 4, 4)
            display.write_data(px)

        draw_cell(1, display, alive if b[1//32] & (1 << (1 & 0x1f)) else dead)
        v = xorshift12(1)
        while 1 != v:
            me = b[v//32] & (1 << (v & 0x1f))
            nx = nb[v//32] & (1 << (v & 0x1f))
            if me != nx:
                draw_cell(v, display, alive if nx else dead)
            v = xorshift12(v)
        draw_cell(0, display, alive if b[0//32] & (1 << (0 & 0x1f)) else dead)