Refactor cellular automata screensavers

1) They now extend a base class: CellularAutomaton. Subclasses thus far as GameOfLife and CyclicAutomaton
2) Adds various configuration settings to sample_config.json for CyclicAutomaton
3) Creates a screensaver_manager process that the queue starts to manage screensaver playback.

Author: dasl-

bin/cyclic_automaton

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+
+# This is necessary for the imports below to work
+root_dir = os.path.abspath(os.path.dirname(__file__) + '/..')
+sys.path.append(root_dir)
+
+import argparse
+from pifi.config import Config
+from pifi.games.cellularautomata.cyclicautomaton import CyclicAutomaton
+from pifi.logger import Logger
+
+def parseArgs():
+    parser = argparse.ArgumentParser(
+        description=("Cyclic automaton: https://en.wikipedia.org/wiki/Cyclic_cellular_automaton ."),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument('--log-uuid', dest='log_uuid', action='store', help='Logger UUID')
+
+    args = parser.parse_args()
+    return args
+
+
+args = parseArgs()
+if args.log_uuid:
+    Logger.set_uuid(args.log_uuid)
+Config.load_config_if_not_loaded()
+
+CyclicAutomaton().play()

bin/game_of_life

@@ -9,31 +9,15 @@ sys.path.append(root_dir)
 
 import argparse
 from pifi.config import Config
-from pifi.games.gameoflife import GameOfLife
-from pifi.games.gamecolorhelper import GameColorHelper
+from pifi.games.cellularautomata.gameoflife import GameOfLife
 from pifi.logger import Logger
 
 def parseArgs():
     parser = argparse.ArgumentParser(
-        description=("Conway's game of life. Arguments that are not specified will get values from your " +
-            "config file, if you have one."),
+        description=("Conway's game of life."),
         formatter_class=argparse.ArgumentDefaultsHelpFormatter
     )
     parser.add_argument('--log-uuid', dest='log_uuid', action='store', help='Logger UUID')
-    parser.add_argument('--brightness', dest='brightness', action='store', type=int,
-        metavar='N', help='Global brightness value. Max of 31.')
-    parser.add_argument('--loop', dest='should_loop', action='store_true', default=False,
-        help='Whether to start a new game after game over.')
-    parser.add_argument('--seed-liveness-probability', dest='seed_liveness_probability', action='store', type=float,
-        metavar='N', help='Probability that each pixel is live when seeding.')
-    parser.add_argument('--tick-sleep', dest='tick_sleep', action='store', type=float,
-        metavar='N', help='Amount to sleep after each tick.')
-    parser.add_argument('--game-over-detection-lookback', dest='game_over_detection_lookback', action='store', type=int,
-        metavar='N', help='Number of turns to look back to see if game has not changed (i.e. it is over).')
-    parser.add_argument('--fade', dest='fade', action='store_true', help='fade between each tick', default=None)
-    parser.add_argument('--game-color-mode', dest='game_color_mode', action='store',
-        help=(GameColorHelper().get_help_string()))
-    parser.add_argument('--variant', dest='variant', action='store', help=f'One of {GameOfLife.VARIANTS}.')
 
     args = parser.parse_args()
     return args
@@ -44,19 +28,4 @@ if args.log_uuid:
     Logger.set_uuid(args.log_uuid)
 Config.load_config_if_not_loaded()
 
-if args.brightness is not None:
-    Config.set('leds.brightness', args.brightness)
-if args.seed_liveness_probability is not None:
-    Config.set('game_of_life.seed_liveness_probability', args.seed_liveness_probability)
-if args.tick_sleep is not None:
-    Config.set('game_of_life.tick_sleep', args.tick_sleep)
-if args.game_over_detection_lookback is not None:
-    Config.set('game_of_life.game_over_detection_lookback', args.game_over_detection_lookback)
-if args.game_color_mode is not None:
-    Config.set('game_of_life.game_color_mode', args.game_color_mode)
-if args.fade is not None:
-    Config.set('game_of_life.fade', args.fade)
-if args.variant is not None:
-    Config.set('game_of_life.variant', args.variant)
-
-GameOfLife().play(should_loop = args.should_loop)
+GameOfLife().play()

bin/screensaver_manager

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+
+# This is necessary for the imports below to work
+root_dir = os.path.abspath(os.path.dirname(__file__) + '/..')
+sys.path.append(root_dir)
+
+import argparse
+from pifi.config import Config
+from pifi.logger import Logger
+from pifi.screensavermanager import ScreensaverManager
+
+def parseArgs():
+    parser = argparse.ArgumentParser(
+        description=("Plays screensavers that play while nothing is in the playlist queue."),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument('--log-uuid', dest='log_uuid', action='store', help='Logger UUID')
+
+    args = parser.parse_args()
+    return args
+
+
+args = parseArgs()
+if args.log_uuid:
+    Logger.set_uuid(args.log_uuid)
+Config.load_config_if_not_loaded()
+
+ScreensaverManager().run()

pifi/games/cellularautomata/cellularautomaton.py

@@ -0,0 +1,137 @@
+from abc import ABC, abstractmethod
+import hashlib
+import time
+
+from pifi.logger import Logger
+from pifi.led.ledframeplayer import LedFramePlayer
+from pifi.datastructure.limitedsizedict import LimitedSizeDict
+
+# Base class for cellular automaton games
+class CellularAutomaton(ABC):
+
+    _DEFAULT_MAX_GAME_LENGTH_SECONDS = 0 # unlimited
+    _DEFAULT_MAX_STATE_REPETITIONS_FOR_GAME_OVER = 10
+    _DEFAULT_TICK_SLEEP_SECONDS = 0.07
+    _DEFAULT_GAME_OVER_LOOKBACK_DETECTION_AMOUNT = 16
+    _DEFAULT_SHOULD_FADE_TO_FRAME = False
+
+    def __init__(self, led_frame_player = None):
+        self._logger = Logger().set_namespace(self.__class__.__name__)
+        self._board = None
+        if led_frame_player is None:
+            self.__led_frame_player = LedFramePlayer()
+        else:
+            self.__led_frame_player = led_frame_player
+
+    def play(self, should_loop = False):
+        if should_loop:
+            while True:
+                self.tick(should_loop = should_loop)
+        else:
+            self.__reset()
+            while True:
+                if not self.tick():
+                    break
+
+    # return False when the game is over, True otherwise.
+    def tick(self, should_loop = False, force_reset = False):
+        is_game_in_progress = True
+        if self._board is None or force_reset:
+            # start the game
+            self.__reset()
+        else:
+            self.__tick_internal()
+
+        self.__do_tick_bookkeeping()
+
+        if self.__is_game_over():
+            if should_loop:
+                self.__reset()
+                self.__do_tick_bookkeeping()
+                is_game_in_progress = True
+            else:
+                is_game_in_progress = False
+
+        time.sleep(self._get_tick_sleep_seconds())
+
+        return is_game_in_progress
+
+    def __tick_internal(self):
+        self._update_board()
+        self.__show_board()
+
+    def __do_tick_bookkeeping(self):
+        self._num_ticks += 1
+        board_hash = self.__get_board_hash()
+        if board_hash in self.__prev_board_state_counts:
+            self.__prev_board_state_counts[board_hash] += 1
+        else:
+            self.__prev_board_state_counts[board_hash] = 1
+
+    def __show_board(self):
+        frame = self._board_to_frame()
+
+        if self._should_fade_to_frame():
+            self.__led_frame_player.fade_to_frame(frame)
+        else:
+            self.__led_frame_player.play_frame(frame)
+
+    def __get_board_hash(self):
+        return hashlib.md5(self._board).hexdigest()
+
+    def __is_game_over(self):
+        if self._get_max_game_length_seconds() > 0 and (time.time() - self.__start_time) > self._get_max_game_length_seconds():
+            self._logger.info("Game over due to timeout expiration.")
+            return True
+
+        if self.__prev_board_state_counts[self.__get_board_hash()] > self._get_max_state_repetitions_for_game_over():
+            self._logger.info("Game over detected. Current board state has repeated at least " +
+                f"{self._get_max_state_repetitions_for_game_over()} times.")
+            return True
+        return False
+
+    def __reset(self):
+        self._logger.info("Starting new game.")
+        self.__start_time = time.time()
+        self._num_ticks = 0
+        self.__prev_board_state_counts = LimitedSizeDict(capacity = self._get_game_over_detection_lookback_amount())
+
+        self._reset_hook()
+
+        self.__seed()
+
+    def __seed(self):
+        self._seed_hook()
+        self.__show_board()
+
+    @abstractmethod
+    def _reset_hook(self):
+        pass
+
+    @abstractmethod
+    def _seed_hook(self):
+        pass
+
+    @abstractmethod
+    def _board_to_frame(self):
+        pass
+
+    @abstractmethod
+    def _update_board(self):
+        pass
+
+    def _get_tick_sleep_seconds(self):
+        return self._DEFAULT_TICK_SLEEP_SECONDS
+
+    def _get_game_over_detection_lookback_amount(self):
+        return self._DEFAULT_GAME_OVER_LOOKBACK_DETECTION_AMOUNT
+
+    def _should_fade_to_frame(self):
+        return self._DEFAULT_SHOULD_FADE_TO_FRAME
+
+    def _get_max_state_repetitions_for_game_over(self):
+        return self._DEFAULT_MAX_STATE_REPETITIONS_FOR_GAME_OVER
+
+    # 0 means unlimited
+    def _get_max_game_length_seconds(self):
+        return self._DEFAULT_MAX_GAME_LENGTH_SECONDS

pifi/games/cellularautomata/cyclicautomaton.py

@@ -0,0 +1,61 @@
+import numpy as np
+import random
+
+from pifi.config import Config
+from pifi.games.cellularautomata.palette import palettes
+from pifi.games.cellularautomata.cellularautomaton import CellularAutomaton
+
+# https://en.wikipedia.org/wiki/Cyclic_cellular_automaton
+class CyclicAutomaton(CellularAutomaton):
+
+    def _get_tick_sleep_seconds(self):
+        return Config.get('cyclic_automaton.tick_sleep', self._DEFAULT_TICK_SLEEP_SECONDS)
+
+    def _get_game_over_detection_lookback_amount(self):
+        return Config.get('cyclic_automaton.game_over_detection_lookback', self._DEFAULT_GAME_OVER_LOOKBACK_DETECTION_AMOUNT)
+
+    def _should_fade_to_frame(self):
+        return Config.get('cyclic_automaton.fade', self._DEFAULT_SHOULD_FADE_TO_FRAME)
+
+    def _get_max_game_length_seconds(self):
+        return 60
+
+    def _reset_hook(self):
+        self.__num_states = random.randint(5, 16)
+        self.__palette = np.array(random.choice(palettes))
+
+    def _seed_hook(self):
+        # Create the board with an extra edge cell on all sides to simplify the
+        # neighborhood calculation and avoid edge checks.
+        shape = [Config.get_or_throw('leds.display_height') + 2, Config.get_or_throw('leds.display_width') + 2]
+        self._board = np.random.randint(0, self.__num_states, shape)
+
+    def _board_to_frame(self):
+        board_shape = self._board.shape + (3,)
+        foo = self.__palette[self._board.ravel()].reshape(board_shape)
+        return foo[1:-1, 1:-1]
+
+    def _update_board(self):
+        b = self._board
+
+        slices = [((0,-2), (0,-2)), 
+                  ((0,-2), (1,-1)),
+                  ((0,-2), (2,None)),
+                  ((1,-1), (0,-2)),
+                  ((1,-1), (2,None)),
+                  ((2,None), (0,-2)),
+                  ((2,None), (1,-1)),
+                  ((2,None), (2,None))]
+
+        succ = None
+        bpad = b[1:-1, 1:-1]
+        for indices in slices:
+            s = tuple(slice(*x) for x in indices)
+            if succ is None:
+                succ = (b[s] == ((bpad + 1) % self.__num_states))
+            else:
+                succ |= (b[s] == ((bpad + 1) % self.__num_states))
+
+        b[1:-1, 1:-1][succ] = ((bpad[succ] + 1) % self.__num_states)
+
+        self._board = b