except OSError:

                self.dev = None

__all__ = ['rainbow', 'paint', 'snake', 'pong', 'tetris', 'clouds']

### clouds.py

### Author: Matthew Reed

### Random noise generated colors

### Adapted from https://github.com/scanlime/fadecandy/blob/master/examples/processing/grid24x8z_clouds/grid24x8z_clouds.pde

import sys

import time

import signal

import logging

import configparser

from enum import Enum

import math

import matrix

import noise

import color_utils

import random

class Clouds:

    def __init__(self, config, parent, matrix, controller):

        self.logger = logging.getLogger('paint')

        self.config = config

        self.parent = parent

        self.matrix = matrix

        self.controller = controller

    def reset(self):

        pass

    def splash(self):

        r = matrix.Colors.RED.value

        o = matrix.Colors.ORANGE.value

        y = matrix.Colors.YELLOW.value

        g = matrix.Colors.GREEN.value

        b = matrix.Colors.BLUE.value

        p = matrix.Colors.PURPLE.value

        w = matrix.Colors.WHITE.value

        v = matrix.Colors.VIOLET.value

        l = matrix.Colors.LIGHT_BLUE.value

        m = matrix.Colors.MAGENTA.value

        q = matrix.Colors.OFF.value

        splash = [

            [q, q, q, q, q, q, q, q],

            [q, q, q, q, q, q, q, q],

            [q, q, r, w, p, v, q, q],

            [q, q, b, g, o, m, q, q],

            [q, q, r, p, y, l, q, q],

            [q, q, q, q, q, q, q, q],

            [q, q, q, q, q, q, q, q],

            [q, q, q, q, q, q, q, q],

        ]

        for x in range(0, self.matrix.WIDTH):

            for y in range(0, self.matrix.HEIGHT):

                self.matrix.set_pixel(x, y, splash[y][x])

        self.matrix.update()

    def hsv_to_rgb(self, h, s, v):

        if s == 0.0: return (v, v, v)

        i = int(h*6.) # XXX assume int() truncates!

        f = (h*6.)-i; p,q,t = v*(1.-s), v*(1.-s*f), v*(1.-s*(1.-f)); i%=6

        if i == 0: return (v, t, p)

        if i == 1: return (q, v, p)

        if i == 2: return (p, v, t)

        if i == 3: return (p, q, v)

        if i == 4: return (t, p, v)

        if i == 5: return (v, p, q)

    def fractalNoise(self, x, y, z):

      r = 0

      amp = 1.0

      for octave in range(4):

        r += noise.pnoise3(x, y, z) * amp;

        amp /= 2;

        x *= 2;

        y *= 2;

        z *= 2;

      return r;

    def constrain(self, val, min_val, max_val):

        return min(max_val, max(min_val, val))

    def run(self):

        dx = 0.0

        dy = 0.0

        #start timers and counters

        self.start_time = time.time()

        last_time = time.time()

        led_iteration_count = 0

        frame_count = 0

        keep_going = True

        while keep_going:

            for event in self.controller.read_input():

                if event.code == 313 and event.value == 1:

                    keep_going = False

            if time.time() > last_time + 1:

                last_time = time.time()

                now = time.time()

                speed = 0.002

                angle = math.sin(now)

                z = now * 0.08

                hue = now * 10

                scale = 0.005;

                dx += math.cos(angle) * speed

                dy += math.sin(angle) * speed

                for x in range(self.matrix.WIDTH):

                    for y in range(self.matrix.HEIGHT):

                        n = self.fractalNoise(dx + x*scale, dy + y*scale, z) - 0.75

                        m = self.fractalNoise(dx + x*scale, dy + y*scale, z + 10.0) - 0.75

                        color = self.hsv_to_rgb(

                            (hue + 80.0 * m) % 256.0, 

                            256 - 256 * self.constrain(pow(3.0 * abs(n), 3.5), 0, 0.9), 

                            256 * self.constrain(pow(3.0 * abs(n), 1.5), 0, 0.9)

                        )

                        self.matrix.set_pixel(x, y, color)

                self.matrix.update()

                led_iteration_count = (led_iteration_count + 1) % self.matrix.NUM_LEDS

                frame_count = frame_count + 1

            time.sleep(0.01)

        w = matrix.Colors.WHITE.value

        r = matrix.Colors.RED.value

        g = matrix.Colors.GREEN.value

        b = matrix.Colors.BLUE.value

        l = matrix.Colors.LIGHT_BLUE.value

        p = matrix.Colors.PURPLE.value

        O = matrix.Colors.ORANGE.value

        y = matrix.Colors.YELLOW.value

        v = matrix.Colors.VIOLET.value

        m = matrix.Colors.MAGENTA.value

        o = matrix.Colors.OFF.value

        splash = [

            [o, o, o, o, o, o, o, o],

            [o, o, w, w, w, o, o, o],

            [o, o, w, o, w, o, o, o],

            [o, o, w, w, w, o, o, o],

            [o, o, w, o, o, r, O, y],

            [o, o, w, o, o, m, w, g],

            [o, o, w, o, o, v, b, l],

            [o, o, o, o, o, o, o, o],

        ]

        for x in range(0, self.matrix.WIDTH):

            for y in range(0, self.matrix.HEIGHT):

                self.matrix.set_pixel(x, y, splash[y][x])

### pong.py

### Author: Matthew Reed

### Game of pong, uses the D-Pad 

### Adapted from http://trevorappleton.blogspot.com/2014/04/writing-pong-using-python-and-pygame.html

import sys

import time

import signal

import logging

import configparser

from enum import Enum

import math

from random import randint

import matrix

class Pong:

    class Ball:

        def __init__(self, x, y):

            self.x = x

            self.y = y

            self.dir_x = -1 # -1=left 1=right

            self.dir_y = -1 # -1=up 1=down

        def move(self):

            self.x += self.dir_x

            self.y += self.dir_y

            #check for collision with wall and bounce

            if self.y <= 0:

                self.y = 0

                self.dir_y = 1

            elif self.y >= 7:

                self.y = 7

                self.dir_y = -1

        def draw(self, display):

            display.set_pixel(self.x, self.y, matrix.Colors.RED.value)

    class Paddle:

        class DIRECTION(Enum):

            NONE = 0

            UP = 1

            DOWN = 2

            LEFT = 3

            RIGHT = 4

        def __init__(self, x, y):

            self.size = 3

            self.x = x

            self.position = y

            self.direction = self.DIRECTION.NONE

        def move(self):

            if self.direction == self.DIRECTION.UP:

                self.position = self.position - 1

                if self.position < 0:

                    self.position = 0

            elif self.direction == self.DIRECTION.DOWN:

                self.position = self.position + 1

                if self.position + self.size > 8:

                    self.position = 8 - self.size

        def auto_move(self, ball):

            #If ball is moving away from paddle, center

            if ball.dir_x == -1:

                if self.position < 3:

                    self.position += 1

                elif self.position > 3:

                    self.position -= 1

            #if ball moving towards paddle, track its movement

            elif ball.dir_x == 1:

                if self.position + 1 - ball.dir_y < ball.y:

                    self.position += 1

                elif self.position + 1 - ball.dir_y > ball.y:

                    self.position -= 1

            if self.position < 0:

                self.position = 0

            elif self.position + self.size > 8:

                self.position = 8 - self.size

        def draw(self, display):

            for i in range(0, self.size):

                display.set_pixel(self.x, self.position + i, matrix.Colors.BLUE.value)

    def __init__(self, config, parent, matrix, controller):

        self.logger = logging.getLogger('snake')

        self.config = config

        self.parent = parent

        self.matrix = matrix

        self.controller = controller

    def reset(self):

        pass

    def splash(self):

        w = matrix.Colors.WHITE.value

        l = matrix.Colors.WHITE_LOW.value

        r = matrix.Colors.RED.value

        b = matrix.Colors.BLUE.value

        o = matrix.Colors.OFF.value

        splash = [

            [l, l, l, l, l, l, l, l],

            [l, o, o, o, o, o, o, l],

            [b, o, o, o, o, o, o, l],

            [b, o, o, o, r, o, o, b],

            [b, o, o, o, o, o, o, b],

            [l, o, o, o, o, o, o, b],

            [l, o, o, o, o, o, o, l],

            [l, l, l, l, l, l, l, l],

        ]

        for x in range(0, self.matrix.WIDTH):

            for y in range(0, self.matrix.HEIGHT):

                self.matrix.set_pixel(x, y, splash[y][x])

        self.matrix.update()

    def run(self):

        #start timers and counters

        self.start_time = time.time()

        last_time = time.time()

        delay_time = 0.1

        led_iteration_count = 0

        frame_count = 0

        self.updateBallCountMax = 5

        self.updateBallCount = 0

        self.updateCompCountMax = 10

        self.updateCompCount = 0

        ball = self.Ball(4, 3)

        paddle1 = self.Paddle(0, 3)

        paddle2 = self.Paddle(7, 3)

        score = 0

        #draw display

        self.matrix.set_matrix(matrix.Colors.OFF.value)

        for x in range(0, 8):

            self.matrix.set_pixel(x, 0, matrix.Colors.WHITE_LOW.value)

            self.matrix.set_pixel(x, 7, matrix.Colors.WHITE_LOW.value)

        for y in range(0, 8):

            self.matrix.set_pixel(0, y, matrix.Colors.WHITE_LOW.value)

            self.matrix.set_pixel(3, y, matrix.Colors.WHITE_LOW.value)

            self.matrix.set_pixel(4, y, matrix.Colors.WHITE_LOW.value)

            self.matrix.set_pixel(7, y, matrix.Colors.WHITE_LOW.value)

        paddle1.draw(self.matrix)

        paddle2.draw(self.matrix)

        ball.draw(self.matrix)

        self.matrix.update()

        keep_going = True

        while keep_going:

            for event in self.controller.read_input():

                if event.code == 313 and event.value == 1:

                    keep_going = False

                elif event.code == 17:

                    if event.value == 1:

                        #dpad down

                        paddle1.direction = self.Paddle.DIRECTION.DOWN

                    if event.value == 0:

                        #dpad none

                        paddle1.direction = self.Paddle.DIRECTION.NONE

                        pass

                    if event.value == -1:

                        #dpad up

                        paddle1.direction = self.Paddle.DIRECTION.UP

            if time.time() > last_time + delay_time:

                last_time = time.time()

                paddle1.move()

                self.updateBallCount = self.updateBallCount + 1

                if self.updateBallCount >= self.updateBallCountMax:

                    ball.move()

                    self.updateBallCount = 0

                self.updateCompCount = self.updateCompCount + 1

                if self.updateCompCount >= self.updateCompCountMax:

                    paddle2.auto_move(ball)

                    self.updateCompCount = 0

                #ball hits paddle 1

                if ball.dir_x == -1 and ball.x == 1:

                    ball.dir_x = ball.dir_x *  -1

                    # if the ball bounces off the corner of the paddle, it goes back in the same direction it came from

                    if (ball.dir_y == 1 and ball.y == paddle1.position) or (ball.dir_y == -1 and ball.y == paddle1.position + 2):

                        ball.dir_y = ball.dir_y *  -1

                    # if the paddle is in motion, give the ball some translation

                    if paddle1.direction == self.Paddle.DIRECTION.DOWN:

                        if ball.y < 7:

                            ball.y = ball.y + 1

                            if ball.y >= 7:

                                ball.y = 7

                                ball.dir_y = -1

                    elif paddle1.direction == self.Paddle.DIRECTION.UP:

                        if ball.y > 0:

                            ball.y = ball.y - 1

                            if ball.y <= 0:

                                ball.y = 0

                                ball.dir_y = 1

                elif ball.dir_x == -1 and ball.x == 0:

                    if paddle1.position <= ball.y and (paddle1.position + paddle1.size) > ball.y:

                        #1 point for hitting the ball

                        score += 1

                        print("Hit!")

                    else:

                        #game over if left wall is hit

                        print("Miss!")

                        keep_going = False

                elif ball.dir_x == 1 and ball.x == 6:

                    ball.dir_x = ball.dir_x *  -1

                    if paddle2.position <= ball.y and (paddle2.position + paddle2.size) > ball.y:

                        #ball hits paddle2

                        pass

                elif ball.dir_x == 1 and ball.x == 7:

                    #5 points for beating paddle2

                    score += 5

                    print("Score!")

                #update display

                self.matrix.set_matrix(matrix.Colors.OFF.value)

                #draw game background

                for x in range(0, 8):

                    self.matrix.set_pixel(x, 0, matrix.Colors.WHITE_LOW.value)

                    self.matrix.set_pixel(x, 7, matrix.Colors.WHITE_LOW.value)

                for y in range(0, 8):

                    self.matrix.set_pixel(0, y, matrix.Colors.WHITE_LOW.value)

                    self.matrix.set_pixel(3, y, matrix.Colors.WHITE_LOW.value)

                    self.matrix.set_pixel(4, y, matrix.Colors.WHITE_LOW.value)

                    self.matrix.set_pixel(7, y, matrix.Colors.WHITE_LOW.value)

                paddle1.draw(self.matrix)

                paddle2.draw(self.matrix)

                ball.draw(self.matrix)

                self.matrix.update()

                led_iteration_count = (led_iteration_count + 1) % self.matrix.NUM_LEDS

                frame_count = frame_count + 1

            time.sleep(0.01)

        #display score before exiting

        self.matrix.set_matrix(matrix.Colors.OFF.value)

        if score > 750:

            for i in range(0, 64):

                self.matrix.set_pixel(i % self.matrix.WIDTH, math.floor(i / self.matrix.HEIGHT), matrix.Colors.YELLOW.value)

        else:

            multiples = math.floor(score / 50)

            score = score % 50

            for i in range(0, multiples):

                self.matrix.set_pixel(i % self.matrix.WIDTH, math.floor(i / self.matrix.HEIGHT), matrix.Colors.YELLOW.value)

            for i in range(multiples, score):

                self.matrix.set_pixel(i % self.matrix.WIDTH, math.floor(i / self.matrix.HEIGHT), matrix.Colors.WHITE.value)

        self.matrix.update()

        time.sleep(2)

### Inspired by https://krazydad.com/tutorials/makecolors.php

import matrix

    class MODES(Enum):

        TWO_D = 0

        LINEAR = 1

        SOLID = 2

        r = matrix.Colors.RED.value

        o = matrix.Colors.ORANGE.value

        y = matrix.Colors.YELLOW.value

        g = matrix.Colors.GREEN.value

        b = matrix.Colors.BLUE.value

        p = matrix.Colors.PURPLE.value

        q = matrix.Colors.OFF.value

        splash = [

            [q, q, q, q, q, q, q, q],

            [q, q, q, q, q, q, q, q],

            [q, q, q, q, q, q, q, q],

            [q, r, o, y, g, b, p, q],

            [q, r, o, y, g, b, p, q],

            [q, q, q, q, q, q, q, q],

            [q, q, q, q, q, q, q, q],

            [q, q, q, q, q, q, q, q],

        ]

        for x in range(0, self.matrix.WIDTH):

            for y in range(0, self.matrix.HEIGHT):

                self.matrix.set_pixel(x, y, splash[y][x])

        width = 127;

        mode = self.MODES.TWO_D

                elif event.code == 305 and event.value == 1:

                    mode = self.MODES((mode.value + 1) % len(self.MODES))

                elif event.code == 16:

                    if event.value == 1:

                        #dpad right

                        pass

                    if event.value == -1:

                        #dpad left

                        pass

                elif event.code == 17:

                    if event.value == 1:

                        #dpad down

                        frequency = frequency - 0.05

                        if frequency <= 0.05:

                            frequency = 0.05

                        print(frequency)

                    if event.value == -1:

                        #dpad up

                        frequency = frequency + 0.05

                        if frequency >= 1:

                            frequency = 1

                        print(frequency)

                    if mode == self.MODES.TWO_D:

                        phaseShift = 2*math.pi - y*(math.pi/(self.matrix.HEIGHT-1))

                    else:

                        phaseShift = 4

                        if mode == self.MODES.SOLID:

                            i = frame_count % 128

                        else:

                            i = (x + frame_count) % 128

            time.sleep(0.01)

### Adapted from https://pythonspot.com/snake-with-pygame/

        w = matrix.Colors.WHITE.value

        l = matrix.Colors.WHITE_LOW.value

        r = matrix.Colors.RED.value

        g = matrix.Colors.GREEN.value

        b = matrix.Colors.BLUE.value

        o = matrix.Colors.OFF.value

        splash = [

            [o, o, o, o, o, o, o, o],

            [o, o, b, b, b, o, g, o],

            [o, o, b, o, o, o, o, o],

            [o, o, b, b, b, o, o, o],

            [o, o, o, o, b, o, o, o],

            [o, o, b, b, b, o, o, o],

            [o, o, o, o, o, o, o, o],

            [o, o, o, o, o, o, o, o],

        ]

        for x in range(0, self.matrix.WIDTH):

            for y in range(0, self.matrix.HEIGHT):

                self.matrix.set_pixel(x, y, splash[y][x])

### tetris.py

### Author: Matthew Reed

### Game of tetris, uses the D-Pad

### Adapted from https://gist.github.com/silvasur/565419/d9de6a84e7da000797ac681976442073045c74a4

import sys

import time

import signal

import logging

import configparser

from enum import Enum

import math

from random import randrange as rand

import matrix

class Tetris:

    # Define the shapes of the single parts

    tetris_shapes = [

        [[1, 1, 1],

         [0, 1, 0]],

        [[0, 2, 2],

         [2, 2, 0]],

        [[3, 3, 0],

         [0, 3, 3]],

        [[4, 0, 0],

         [4, 4, 4]],

        [[0, 0, 5],

         [5, 5, 5]],

        [[6, 6, 6, 6]],

        [[7, 7],

         [7, 7]]

    ]

    colors = [

        matrix.Colors.OFF.value,

        matrix.Colors.RED.value,

        matrix.Colors.GREEN.value,

        matrix.Colors.BLUE.value,

        matrix.Colors.ORANGE.value,

        matrix.Colors.YELLOW.value,

        matrix.Colors.MAGENTA.value,

        matrix.Colors.LIGHT_BLUE.value

    ]

    def rotate_clockwise(self, shape):

        return [[ shape[y][x] for y in range(len(shape)) ] for x in range(len(shape[0]) - 1, -1, -1)]

    def check_collision(self, board, shape, offset):

        off_x, off_y = offset

        for cy, row in enumerate(shape):

            for cx, cell in enumerate(row):

                try:

                    if cell and board[ cy + off_y ][ cx + off_x ]:

                        return True

                except IndexError:

                    return True

        return False

    def remove_row(self, board, row):

        del board[row]

        self.score += 1

        return [[0 for i in range(self.width)]] + board

    def join_matrixes(self, mat1, mat2, mat2_off):

        off_x, off_y = mat2_off

        for cy, row in enumerate(mat2):

            for cx, val in enumerate(row):

                mat1[cy+off_y-1	][cx+off_x] += val

        return mat1

    def new_board(self):

        board = [[0 for x in range(self.width)] for y in range(self.height)]

        board += [[1 for x in range(self.width)]]

        return board

    def new_stone(self):

        self.stone = self.tetris_shapes[rand(len(self.tetris_shapes))]

        self.stone_x = int(self.width / 2 - len(self.stone[0])/2)

        self.stone_y = 0

        if self.check_collision(self.board, self.stone, (self.stone_x, self.stone_y)):

            self.gameover = True

    def draw(self, matrix, board, offset):

        off_x, off_y  = offset

        for y, row in enumerate(board):

            for x, val in enumerate(row):

                if val and y < self.height:

                    matrix.set_pixel(off_x + x, off_y + y, self.colors[val])

    def move(self, delta_x):

        if not self.gameover and not self.paused:

            new_x = self.stone_x + delta_x

            if new_x < 0: