Making a «Known Error» app for Tildagon

import app
from events.input import Buttons, BUTTON_TYPES


# This is a list of text strings available for display.
TEXTS = [
    "Known Error",
    "Unknown Error",
]


class KnownErrorApp(app.App):
    def __init__(self):
        self.button_states = Buttons(self)

        # This field tracks which text from the list
        # is supposed to be displayed.
        self.text_index = 0

   def update(self, delta):
        if self.button_states.get(BUTTON_TYPES["CANCEL"]):
            self.button_states.clear()
            self.minimise()

        # The following 2 `if` statements check if "UP" or "DOWN"
        # buttons have been pressed and update which text should
        # be displayed.

        if self.button_states.get(BUTTON_TYPES["UP"]):
            self.button_states.clear()

            self.text_index += 1
            self.text_index %= len(TEXTS)

        if self.button_states.get(BUTTON_TYPES["DOWN"]):
            self.button_states.clear()

            self.text_index -= 1
            self.text_index %= len(TEXTS)

    def draw(self, ctx):
        ctx.save()
        self.clear_background(ctx)
        # We now select the text to display based on the app state.
        ctx.rgb(1, 1, 1).move_to(-80, 0).text(TEXTS[self.text_index])
        ctx.restore()

    def clear_background(self, ctx):
        ctx.rgb(0, 0, 0).rectangle(-120, -120, 240, 240).fill()

import math
from random import random, randint

# More stuff provided by the Tildagon developers is now exported.
# Specifically, `tildagonos` will be used to control LED colors,
# and event stuff will enable or disable the default LED animation.

import app
from tildagonos import tildagonos
from events.input import Buttons, BUTTON_TYPES
from system.eventbus import eventbus
from system.patterndisplay.events import PatternDisable, PatternEnable


# This is some info about the display, extracted into variables
# for readability.

MIN = -120
MAX = 120
SIDE = MAX - MIN

CENTER = (MIN + MAX) / 2


# This is a list of LED colors to be used in RGB format.
# The values in each of the tuples can range from 0 to 255.
# However, 255 is extremely bright, and just 15 is already good enough.

LED_COLORS = [
    (0, 0, 0),
    (0, 0, 15),
    (0, 15, 0),
    (0, 15, 15),
    (15, 0, 0),
    (15, 0, 15),
    (15, 15, 0),
    (15, 15, 15),
]


TEXTS = [
    "Known Error",
    "Unknown Error",
]


class KnownErrorApp(app.App):
    def __init__(self):
        self.button_states = Buttons(self)

        self.text_index = 0

        # The following are some settings and state
        # of the glitch effect being implemented.

        # Whether glitch is enabled at all
        self.glitch_enabled = False
        # How long has it been since we updated the glitch
        self.glitch_timing = 0
        # How often the glitch should be updated
        self.glitch_period_ms = 2000
        # What are the current glitch stripes to be displayed
        self.glitch_stripes = []
        # What are the current glitch LED values to be displayed
        self.glitch_leds = []

    #############
    # Overrides #
    #############

    def update(self, delta):
        if self.glitch_enabled:
            # Track how much time it's been since we updated the glitch effect
            self.glitch_timing += delta
            # If we reached the threshold when we should update, update the effect
            if self.glitch_timing > self.glitch_period_ms:
                self.glitch_timing = 0
                self.update_glitch()

        if self.button_states.get(BUTTON_TYPES["CANCEL"]):
            self.button_states.clear()
            print("Closing")
            # Restart the default LED animation when exiting the app
            eventbus.emit(PatternEnable())
            self.minimise()

        # "CONFIRM" is the button to toggle the glitch effect on and off
        elif self.button_states.get(BUTTON_TYPES["CONFIRM"]):
            self.button_states.clear()
            # Toggle glitch effect
            self.glitch_enabled = not self.glitch_enabled
            print(f"Glitch enabled: {self.glitch_enabled}")
            if self.glitch_enabled:
                # Stop the default LED animation when enabling glitch effect
                eventbus.emit(PatternDisable())
            else:
                # Restart the default LED animation when disabling glitch effect
                eventbus.emit(PatternEnable())

        elif self.button_states.get(BUTTON_TYPES["UP"]):
            self.button_states.clear()
            self.text_index += 1
            self.text_index %= len(TEXTS)

        elif self.button_states.get(BUTTON_TYPES["DOWN"]):
            self.button_states.clear()
            self.text_index -= 1
            self.text_index %= len(TEXTS)

    # To keep `draw()` nice and simple, the actual drawing is
    # "outsourced" to `clear()`, `text()` and `glitch()`

    def draw(self, ctx):
        ctx.save()
        self.clear(ctx)
        self.text(ctx, TEXTS[self.text_index])
        if self.glitch_enabled:
            self.glitch(ctx)
        ctx.restore()

    ###########
    # Updates #
    ###########

    # To keep the original `update()` simple, glitch updating logic
    # is extracted here.
    #
    # `update_glitch()` fills `glitch_stripes` and `glitch_leds`
    # fields with the content that should be displayed.
    # Later on, `glitch()` will draw stuff based on those fields.

    def update_glitch(self):
        self.glitch_stripes = []
        # Generates from 0 to 31 stripes.
        for _ in range(randint(0, 32)):
            # Choses a random x position and a random RGB color for the stripe.
            x = MIN + random() * SIDE
            r, g, b = random(), random(), random()
            self.glitch_stripes.append((x, r, g, b))

        self.glitch_leds = []
        for _ in range(12):
            # Chooses a random item from the LED_COLORS list
            i = randint(0, len(LED_COLORS) - 1)
            self.glitch_leds.append(LED_COLORS[i])

    ###########
    # Display #
    ###########

    def clear(self, ctx):
        ctx.rgb(0, 0, 0).rectangle(MIN, MIN, SIDE, SIDE).fill()

    # Text rendering function now includes a call to `ctx.text_width()`.
    # It calculates the width of the text in pixels without actually displaying it.
    # This way the text can be positioned dynamically, based on how much space
    # it actually takes. So the text is now properly centered.

    def text(self, ctx, text):
        width = ctx.text_width(text)
        left_edge = CENTER - width / 2
        ctx.rgb(1, 1, 1).move_to(left_edge, 0).text(text)

    # The `glitch()` function just draws 1px-wide and 100%-tall rectangles
    # of specified color at specified X positions, and then updates the
    # LEDs with the selected colors.

    def glitch(self, ctx):
        for (x, r, g, b) in self.glitch_stripes:
            ctx.rgb(r, g, b).rectangle(x, MIN, 1, SIDE).fill()
        for (i, color) in enumerate(self.glitch_leds):
            tildagonos.leds[i + 1] = color