fix tetris. image resize aspect ratio. cheap chinese gamepad support.

camp_pico.py

 from qr_tmp import qr_data
 from img_tmp import img_data
 
-if True:#__name__ == "__main__":
-    from solid import Solid
-    from life import GameOfLife
-    from net import CheckHTTP
-    from qr import QRScreen
-    from scroll import ScrollText
-    from splash import SplashScreen
-    from manager import Manager
-    from pico import PicoBatt
+from solid import Solid
+from life import GameOfLife
+from net import CheckHTTP
+from qr import QRScreen
+from scroll import ScrollText
+from splash import SplashScreen
+from manager import Manager
+from pico import PicoBatt
 
-    url = "http://ubabot.frubar.net"
+#url = "http://ubabot.frubar.net"
+url = "http://www.xythobuz.de"
 
-    import util
-    t = util.getTarget()
+import util
+t = util.getTarget()
 
-    # Loading fonts and graphics takes a while.
-    # So show a splash screen while the user waits.
-    splash = SplashScreen(t)
-    t.loop_start()
-    splash.draw()
-    t.loop_end()
+# Loading fonts and graphics takes a while.
+# So show a splash screen while the user waits.
+splash = SplashScreen(t)
+t.loop_start()
+splash.draw()
+t.loop_end()
 
-    # UbaBot is online
-    success = Manager(t)
-    success.add(ScrollText(t, "Visit UbaBot Cocktail machine at FruBar village for drinks!", "bitmap8", 1, 10, camp_green))
-    success.add(Solid(t, 1.0))
-    success.add(QRScreen(t, qr_data, 30.0, "Drinks", "bitmap6", camp_pink, (0, 0, 0)))
-    success.add(Solid(t, 1.0))
+# UbaBot is online
+success = Manager(t)
+success.add(ScrollText(t, "Visit UbaBot Cocktail machine at FruBar village for drinks!", "bitmap8", 1, 10, camp_green))
+success.add(Solid(t, 1.0))
+success.add(QRScreen(t, qr_data, 30.0, "Drinks", "bitmap6", camp_pink, (0, 0, 0)))
+success.add(Solid(t, 1.0))
 
-    # UbaBot is offline
-    fail = Manager(t)
-    fail.add(ScrollText(t, "#CCCAMP23", "bitmap8", 1, 10, camp_green))
-    fail.add(Solid(t, 1.0))
-    fail.add(ScrollText(t, "The UbaBot Cocktail machine is closed. Please come back later!", "bitmap8", 1, 10, camp_green))
-    fail.add(Solid(t, 1.0))
-    fail.add(GameOfLife(t, 20, (0, 255, 0), (0, 0, 0), None, 2.0))
-    fail.add(Solid(t, 1.0))
-    fail.add(ScrollText(t, "Your advertisement could appear here. Open a Pull Request on git.xythobuz.de/thomas/rgb-matrix-visualizer or send an e-mail to thomas@xythobuz.de", "bitmap8", 1, 10, camp_green))
-    fail.add(Solid(t, 1.0))
+# UbaBot is offline
+fail = Manager(t)
+fail.add(ScrollText(t, "#CCCAMP23", "bitmap8", 1, 10, camp_green))
+fail.add(Solid(t, 1.0))
+fail.add(ScrollText(t, "The UbaBot Cocktail machine is closed. Please come back later!", "bitmap8", 1, 10, camp_green))
+fail.add(Solid(t, 1.0))
+fail.add(GameOfLife(t, 20, (0, 255, 0), (0, 0, 0), None, 2.0))
+fail.add(Solid(t, 1.0))
+fail.add(ScrollText(t, "Your advertisement could appear here. Open a Pull Request on git.xythobuz.de/thomas/rgb-matrix-visualizer or send an e-mail to thomas@xythobuz.de", "bitmap8", 1, 10, camp_green))
+fail.add(Solid(t, 1.0))
 
-    # UbaBot status checker
-    d = CheckHTTP(url)
-    d.success(success)
-    d.fail(fail)
+# UbaBot status checker
+d = CheckHTTP(url)
+d.success(success)
+d.fail(fail)
 
-    # Main "Menu"
-    m = Manager(t)
-    m.add(QRScreen(t, img_data, 15.0))
-    m.add(Solid(t, 1.0))
-    m.add(d) # HTTP Check, either "success" or "fail"
-    m.add(Solid(t, 1.0))
-    m.add(PicoBatt(t, 5.0, 5.0))
-    m.add(Solid(t, 1.0))
+# Main "Menu"
+m = Manager(t)
+m.add(QRScreen(t, img_data, 15.0))
+m.add(Solid(t, 1.0))
+m.add(d) # HTTP Check, either "success" or "fail"
+m.add(Solid(t, 1.0))
+m.add(PicoBatt(t, 5.0, 5.0))
+m.add(Solid(t, 1.0))
 
-    m.restart()
-    t.loop(m.draw)
+m.restart()
+t.loop(m.draw)

camp_small.py

 camp_pink = (251, 72, 196)
 camp_green = (63, 255, 33)
 
-if __name__ == "__main__":
-    from splash import SplashScreen
-    from scroll import ScrollText
-    from solid import Solid
-    from life import GameOfLife
-    from net import CheckHTTP
-    from image import ImageScreen
-    from qr import QRScreen
-    from snake import Snake
-    from gamepad import InputWrapper
-    from manager import Manager
+from splash import SplashScreen
+from scroll import ScrollText
+from solid import Solid
+from life import GameOfLife
+from net import CheckHTTP
+from image import ImageScreen
+from qr import QRScreen
+from snake import Snake
+from gamepad import InputWrapper
+from manager import Manager
+import util
 
-    url = "http://ubabot.frubar.net"
+url = "http://ubabot.frubar.net"
 
-    import util
-    t = util.getTarget()
-    i = InputWrapper()
+# Need to import InputWrapper before initializing RGB Matrix on Pi
+i = InputWrapper()
 
-    # Loading fonts and graphics takes a while.
-    # So show a splash screen while the user waits.
-    splash = SplashScreen(t)
-    t.loop_start()
-    splash.draw()
-    t.loop_end()
+t = util.getTarget()
 
-    # UbaBot is online
-    success = Manager(t)
-    success.add(ImageScreen(t, "drinka.gif", 0.2, 2, 20.0))
-    success.add(Solid(t, 1.0))
-    success.add(QRScreen(t, url, 30.0, "Drinks:", "tom-thumb", (255, 255, 255), (0, 0, 0)))
-    success.add(Solid(t, 1.0))
+# Loading fonts and graphics takes a while.
+# So show a splash screen while the user waits.
+splash = SplashScreen(t)
+t.loop_start()
+splash.draw()
+t.loop_end()
 
-    # UbaBot is offline
-    fail = Manager(t)
-    fail.add(ImageScreen(t, "attention.gif", 0.2, 2, 20.0, (0, 0, 0)))
-    fail.add(ScrollText(t, "The UbaBot Cocktail machine is currently closed. Please come back later for more drinks!", "lemon", 2, 75, camp_pink))
-    fail.add(Solid(t, 1.0))
-    fail.add(GameOfLife(t, 20, (0, 255, 0), (0, 0, 0), None, 2.0))
-    fail.add(Solid(t, 1.0))
+# UbaBot is online
+success = Manager(t)
+success.add(ImageScreen(t, "drinka.gif", 0.2, 2, 20.0))
+success.add(Solid(t, 1.0))
+success.add(QRScreen(t, url, 30.0, "Drinks:", "tom-thumb", (255, 255, 255), (0, 0, 0)))
+success.add(Solid(t, 1.0))
 
-    # UbaBot status checker
-    d = CheckHTTP(url)
-    d.success(success)
-    d.fail(fail)
+# UbaBot is offline
+fail = Manager(t)
+fail.add(ImageScreen(t, "attention.gif", 0.2, 2, 20.0, (0, 0, 0)))
+fail.add(ScrollText(t, "The UbaBot Cocktail machine is currently closed. Please come back later for more drinks!", "lemon", 2, 75, camp_pink))
+fail.add(Solid(t, 1.0))
+fail.add(GameOfLife(t, 20, (0, 255, 0), (0, 0, 0), None, 2.0))
+fail.add(Solid(t, 1.0))
 
-    # Main "Menu"
-    m = Manager(t)
-    m.add(ScrollText(t, "#CCCAMP23", "lemon", 1, 75, camp_green))
-    m.add(Solid(t, 1.0))
-    m.add(ImageScreen(t, "Favicon.png", 0, 1, 10.0))
-    m.add(Solid(t, 1.0))
-    m.add(d) # HTTP Check, either "success" or "fail"
-    m.add(Solid(t, 1.0))
-    m.add(Snake(t, i, camp_pink, camp_green))
-    m.add(Solid(t, 1.0))
-    m.add(ScrollText(t, "Your advertisement could appear here. Open a Pull Request on git.xythobuz.de/thomas/rgb-matrix-visualizer or send an e-mail to thomas@xythobuz.de", "iv18x16u", 2, 70, camp_green))
-    m.add(Solid(t, 1.0))
+# UbaBot status checker
+d = CheckHTTP(url)
+d.success(success)
+d.fail(fail)
 
-    m.restart()
-    t.loop(m.draw)
+# Main "Menu"
+m = Manager(t)
+m.add(ScrollText(t, "#CCCAMP23", "lemon", 1, 75, camp_green))
+m.add(Solid(t, 1.0))
+m.add(ImageScreen(t, "Favicon.png", 0, 1, 10.0))
+m.add(Solid(t, 1.0))
+m.add(d) # HTTP Check, either "success" or "fail"
+m.add(Solid(t, 1.0))
+m.add(Snake(t, i, camp_pink, camp_green))
+m.add(Solid(t, 1.0))
+m.add(ScrollText(t, "Your advertisement could appear here. Open a Pull Request on git.xythobuz.de/thomas/rgb-matrix-visualizer or send an e-mail to thomas@xythobuz.de", "iv18x16u", 2, 70, camp_green))
+m.add(Solid(t, 1.0))
+
+m.restart()
+t.loop(m.draw)

gamepad.py

             "b": False,
             "x": False,
             "y": False,
+            "l": False,
+            "r": False,
+            "start": False,
+            "select": False,
         }
 
         devices = [InputDevice(path) for path in list_devices()]
         for device in devices:
-            c = device.capabilities()
+            c = device.capabilities(absinfo=False)
             keep = False
 
-            # check for key events
-            if ecodes.EV_KEY in c:
+            # check for axis events
+            if ecodes.EV_ABS in c:
                 # check for gamepad
-                if ecodes.BTN_A in c[ecodes.EV_KEY]:
+                if ecodes.ABS_X in c[ecodes.EV_ABS]:
                     print("Gamepad detected: ", device.name)
                     keep = True
 
+            # check for key events
+            if ecodes.EV_KEY in c:
                 # check for arrow keys
-                elif ecodes.KEY_LEFT in c[ecodes.EV_KEY]:
+                if ecodes.KEY_LEFT in c[ecodes.EV_KEY]:
                     print("Keyboard detected:", device.name)
                     keep = True
 
         for key, mask in self.selector.select(0):
             device = key.fileobj
             for event in device.read():
-                if event.type != ecodes.EV_KEY:
-                    continue
-
-                v = False
-                if event.value != 0:
-                    v = True
+                if event.type == ecodes.EV_KEY:
+                    v = False
+                    if event.value != 0:
+                        v = True
 
-                if (event.code == ecodes.KEY_LEFT) or (event.code == ecodes.BTN_WEST):
-                    self.keys["left"] = v
-                elif (event.code == ecodes.KEY_RIGHT) or (event.code == ecodes.BTN_EAST):
-                    self.keys["right"] = v
-                elif (event.code == ecodes.KEY_UP) or (event.code == ecodes.BTN_NORTH):
-                    self.keys["up"] = v
-                elif (event.code == ecodes.KEY_DOWN) or (event.code == ecodes.BTN_SOUTH):
-                    self.keys["down"] = v
-                elif (event.code == ecodes.KEY_SPACE) or (event.code == ecodes.BTN_A):
-                    self.keys["a"] = v
-                elif (event.code == ecodes.KEY_LEFTCTRL) or (event.code == ecodes.BTN_B):
-                    self.keys["b"] = v
-                elif (event.code == ecodes.KEY_LEFTALT) or (event.code == ecodes.BTN_X):
-                    self.keys["x"] = v
-                elif (event.code == ecodes.KEY_ENTER) or (event.code == ecodes.BTN_Y):
-                    self.keys["y"] = v
-                else:
-                    return self.keys
+                    if (event.code == ecodes.KEY_LEFT) or (event.code == ecodes.BTN_WEST):
+                        self.keys["left"] = v
+                    elif (event.code == ecodes.KEY_RIGHT) or (event.code == ecodes.BTN_EAST):
+                        self.keys["right"] = v
+                    elif (event.code == ecodes.KEY_UP) or (event.code == ecodes.BTN_NORTH):
+                        self.keys["up"] = v
+                    elif (event.code == ecodes.KEY_DOWN) or (event.code == ecodes.BTN_SOUTH):
+                        self.keys["down"] = v
+                    elif (event.code == ecodes.KEY_SPACE) or (event.code == ecodes.BTN_A) or (event.code == ecodes.BTN_THUMB):
+                        self.keys["a"] = v
+                    elif (event.code == ecodes.KEY_LEFTCTRL) or (event.code == ecodes.BTN_B) or (event.code == ecodes.BTN_THUMB2):
+                        self.keys["b"] = v
+                    elif (event.code == ecodes.KEY_LEFTALT) or (event.code == ecodes.BTN_X) or (event.code == ecodes.BTN_JOYSTICK) or (event.code == ecodes.BTN_TRIGGER):
+                        self.keys["x"] = v
+                    elif (event.code == ecodes.KEY_ENTER) or (event.code == ecodes.BTN_Y) or (event.code == ecodes.BTN_TOP):
+                        self.keys["y"] = v
+                    elif event.code == ecodes.BTN_PINKIE:
+                        self.keys["r"] = v
+                    elif event.code == ecodes.BTN_TOP2:
+                        self.keys["l"] = v
+                    elif event.code == ecodes.BTN_BASE4:
+                        self.keys["start"] = v
+                    elif event.code == ecodes.BTN_BASE3:
+                        self.keys["select"] = v
+                elif event.type == ecodes.EV_ABS:
+                    # TODO 8bit hardcoded
+                    if event.code == ecodes.ABS_X:
+                        if event.value > 200:
+                            self.keys["right"] = True
+                            self.keys["left"] = False
+                        elif event.value < 100:
+                            self.keys["right"] = False
+                            self.keys["left"] = True
+                        else:
+                            self.keys["right"] = False
+                            self.keys["left"] = False
+                    elif event.code == ecodes.ABS_Y:
+                        if event.value > 200:
+                            self.keys["down"] = True
+                            self.keys["up"] = False
+                        elif event.value < 100:
+                            self.keys["down"] = False
+                            self.keys["up"] = True
+                        else:
+                            self.keys["down"] = False
+                            self.keys["up"] = False
 
                 if verbose:
                     print(categorize(event), event)

image.py

 
         # automatically crop and scale large images
         if not self.image.is_animated and ((self.image.width > self.gui.width) or (self.image.height > self.gui.height)):
+            # crop to visible area
             self.image = self.image.crop(self.image.getbbox())
 
-            if util.isPi():
-                # TODO PIL version is too old on Pi
-                self.image = self.image.resize((self.gui.width, self.gui.height))
+            # keep the aspect ratio and fit within visible area
+            ratio = self.image.width / self.image.height
+            width = self.gui.width
+            height = self.gui.height
+            if width < height:
+                width = self.gui.width
+                height = int(width / ratio)
             else:
-                self.image = self.image.resize((self.gui.width, self.gui.height),
-                                            Image.Resampling.NEAREST)
+                height = self.gui.height
+                width = int(ratio * height)
+
+            # resize
+            self.image = self.image.resize((width, height),
+                                           Image.Resampling.NEAREST)
 
             # new image object is also missing these
             self.image.is_animated = False

mapper.py

 # on hard-corded coordinate ranges.
 class MapperColorAdjust(MapperNull):
     def set_pixel(self, x, y, color):
-        # third panel from the left, with 64 <= x < 96,
+        # second panel from the left, with 32 <= x,
         # is "old" type with brighter LEDs.
-        # rest of panels to the left and right are less bright.
-        # so adjust brightness of inner panel rg channels down.
-        if (x >= (self.gui.panelW * 2)) and (x < (self.gui.panelW * 3)):
+        # rest of panels to the left are less bright.
+        # so adjust brightness of other panel rg channels down.
+        if x >= self.gui.panelW:
             color = (int(color[0] * 0.75), int(color[1] * 0.75), color[2])
 
         self.gui.set_pixel(x, y, color)

pi.py

 from PIL import Image
 
 class PiMatrix:
-    def __init__(self, w = 32 * 4, h = 32, panelW = 32, panelH = 32):
+    def __init__(self, w = 32 * 2, h = 32, panelW = 32, panelH = 32):
         self.width = w # x-axis
         self.height = h # y-axis
 

pico_ota.py

 # to check if we're actually running on MicroPython
 on_pico = False
 try:
-    import uos
+    import machine
     on_pico = True
 except Exception as e:
     print()
 
         self.get = None
         self.update_path = "."
+        self.exe_path = ""
+        self.version_file = "ota_version"
         self.blacklist = []
 
     def path(self, p):
         self.update_path = p
 
+    def exe(self, e):
+        self.exe_path = e
+
     def ignore(self, path):
         if not path in self.blacklist:
             self.blacklist.append(path)
             print()
             return None
 
+    def get_stored_commit(self):
+        current = "unknown"
+        try:
+            f = open(os.path.join(self.update_path, self.version_file), "r")
+            current = f.readline().strip()
+            f.close()
+        except Exception as e:
+            print()
+            if hasattr(sys, "print_exception"):
+                sys.print_exception(e)
+            else:
+                print(e)
+            print()
+        return current
+
+    def get_previous_commit(self, commit):
+        r = self.fetch(self.host + "/" + self.repo + "/commit/" + commit).text
+        for line in r.splitlines():
+            if not (self.repo + "/commit/") in line:
+                continue
+
+            line = line[line.find("/commit/") : ][8 : ][ : 40]
+            if line != commit:
+                return line
+        return "unknown"
+
     def check(self, verbose = False):
         if self.branch == None:
             # get default branch
         if verbose:
             print("Latest commit is " + commit)
 
-        current = ""
-        try:
-            f = open(os.path.join(self.update_path, "ota_version"), "r")
-            current = f.readline().strip()
-            f.close()
-        except Exception as e:
-            print()
-            if hasattr(sys, "print_exception"):
-                sys.print_exception(e)
-            else:
-                print(e)
-            print()
+        current = self.get_stored_commit()
 
         if verbose:
             if current != commit:
                 print("Writing " + f["path"] + " to " + self.update_path)
 
             # overwrite existing file
-            f = open(os.path.join(self.update_path, f["path"]), "w")
-            f.write(r)
-            f.close()
+            fo = open(os.path.join(self.update_path, f["path"]), "w")
+            fo.write(r)
+            fo.close()
+
+            if f["path"] == self.exe_path:
+                if verbose:
+                    print("Writing " + f["path"] + " to main.py")
+
+                fo = open(os.path.join(self.update_path, "main.py"), "w")
+                fo.write(r)
+                fo.close()
 
         # Write new commit id to local file
-        f = open(os.path.join(self.update_path, "ota_version"), "w")
+        f = open(os.path.join(self.update_path, self.version_file), "w")
         f.write(commit + os.linesep)
         f.close()
 
+def non_pico_ota_test(ota):
+    if not os.path.exists("tmp"):
+        os.makedirs("tmp")
+    ota.path("tmp")
+
+    print("Checking for updates")
+    newer, commit = ota.check(True)
+    print()
+
+    # Just for testing
+    previous = ota.get_previous_commit(commit)
+    print("Previous commit (-1):", previous)
+    previous = ota.get_previous_commit(previous)
+    print("Previous commit (-2):", previous)
+    print()
+
+    if newer:
+        print("Updating")
+        ota.update_to_commit(commit, True)
+    else:
+        print("No update required")
+
+def pico_ota_run(ota):
+    newer, commit = ota.check(True)
+
+    if newer:
+        ota.update_to_commit(commit, True)
+        machine.soft_reset()
+
+    fallback = False
+
+    try:
+        import camp_pico
+    except Exception as e:
+        fallback = True
+        print()
+        if hasattr(sys, "print_exception"):
+            sys.print_exception(e)
+        else:
+            print(e)
+        print()
+
+    # TODO this would immediately cause another update on reboot
+    # TODO set a flag to prevent updates after fallbacks?
+    # TODO or better, blacklist failed commit_id!
+    #if fallback:
+    #    previous = ota.get_previous_commit(commit, True)
+    #    ota.update_to_commit(previous, True)
+    #    machine.soft_reset()
+
 if __name__ == "__main__":
     ota = PicoOTA("https://git.xythobuz.de", "thomas/rgb-matrix-visualizer")
 
     ota.ignore("pi.py")
     ota.ignore("test.py")
 
-    if not on_pico:
-        if not os.path.exists("tmp"):
-            os.makedirs("tmp")
-        ota.path("tmp")
+    ota.exe("camp_pico.py")
 
-    newer, commit = ota.check(True)
-    if newer:
-        ota.update_to_commit(commit, True)
+    if not on_pico:
+        non_pico_ota_test(ota)
+    else:
+        pico_ota_run(ota)

snake.py

         self.player = [ (int(self.gui.width / 2), int(self.gui.height / 2)) ]
         self.data[self.player[0][0]][self.player[0][1]] = 1
 
+        self.old_keys = {
+            "left": False,
+            "right": False,
+            "up": False,
+            "down": False,
+        }
+
         self.placeDot()
 
     def finished(self):
 
     def buttons(self):
         keys = self.input.get()
-        if keys["left"]:
+
+        if keys["left"] and (not self.old_keys["left"]):
             self.directionTmp = "l"
-        elif keys["right"]:
+        elif keys["right"] and (not self.old_keys["right"]):
             self.directionTmp = "r"
-        elif keys["up"]:
+        elif keys["up"] and (not self.old_keys["up"]):
             self.directionTmp = "u"
-        elif keys["down"]:
+        elif keys["down"] and (not self.old_keys["down"]):
             self.directionTmp = "d"
+        elif (keys["select"] and keys["start"] and (not self.old_keys["start"])) or (keys["start"] and keys["select"] and (not self.old_keys["select"])):
+            self.restart()
+
+        self.old_keys = keys.copy()
 
     def step(self):
         player = self.player[len(self.player) - 1]
         self.scoreText.draw()
 
     def draw(self):
+        if self.input != None:
+            self.buttons()
+        else:
+            # TODO "AI"
+            pass
+
         if self.direction == "":
             if self.finishedEndScreen():
                 self.drawScoreScreen()
                 self.scoreText.restart()
             return
 
-        if self.input != None:
-            self.buttons()
-        else:
-            # TODO "AI"
-            pass
-
         now = time.time()
         if (now - self.last) >= self.timestep:
             self.last = now
                 self.gui.set_pixel(x, y, self.colors[self.data[x][y]])
 
 if __name__ == "__main__":
-    import util
-    t = util.getTarget()
-
+    # Need to import InputWrapper before initializing RGB Matrix on Pi
     from gamepad import InputWrapper
     i = InputWrapper()
 
+    import util
+    t = util.getTarget()
+
     d = Snake(t, i)
     t.loop(d.draw)

solid.py

         global s, colors, ci, n, c
 
         now = time.time()
-        if ((now - s) >= 0.1) or (now < s):
+        if ((now - s) >= 0.5) or (now < s):
             s = now
             n += 1
             if n >= 15:

tetris.py

 import random
 
 class Tetris:
-    def __init__(self, g, i, ts = 0.5, to = 60.0):
+    def __init__(self, g, i, ts = 0.5, to = 60.0, w = 10, h = 22):
         self.gui = g
         self.input = i
         self.timestep = ts
         self.timeout = to
+        self.width = min(w, self.gui.width)
+        self.height = min(h, self.gui.height)
+
+        self.x_off = int((self.gui.panelW - self.width - 2) / 2)
+        self.y_off = int((self.gui.panelH - self.height - 2) / 2)
 
         self.endText = ScrollText(self.gui, "Game Over!", "uushi",
                                    2, 75, (251, 72, 196))
         self.button = None
         self.score = 0
         self.done = False
-        self.data = [[self.bg for y in range(self.gui.height)] for x in range(self.gui.width)]
+        self.data = [[self.bg for y in range(self.height)] for x in range(self.width)]
         self.piece = None
+        self.old_keys = {
+            "left": False,
+            "right": False,
+            "up": False,
+            "down": False,
+        }
 
     def finished(self):
         if self.input == None:
 
         return False
 
-    # TODO collision detection is broken
-    # TODO not working for pixels outside of vertical center line???
-    # TODO something like that...
     def collision(self):
         # check for collision of piece with data
         pos = (self.piece[2], self.piece[3])
                     continue
 
                 # check for collision with bottom wall
-                if (y + pos[1]) >= self.gui.height:
+                if (y + pos[1]) >= self.height:
+                    return True
+
+                # check for collision with right wall
+                if (x + pos[0]) >= self.width:
                     return True
 
                 # check for collision with previous pieces
 
         for y in range(0, len(piece)):
             for x in range(0, len(piece[y])):
-                remove = False
+                # only set or clear where piece actually is
                 if piece[y][x] == 0:
-                    remove = True
+                    continue
 
-                if clear or remove:
+                if clear:
                     self.data[x + position[0]][y + position[1]] = self.bg
                 else:
                     self.data[x + position[0]][y + position[1]] = self.piece[1]
 
+    def checkWin(self):
+        had_data = False
+        for y in range(0, self.height):
+            line_full = True
+            for x in range(0, self.width):
+                if self.data[x][y] == self.bg:
+                    line_full = False
+                else:
+                    had_data = True
+
+            if had_data and line_full:
+                self.score += 1
+
+                # move stuff above into this line
+                for y2 in reversed(range(1, y + 1)):
+                    for x in range(0, self.width):
+                        self.data[x][y2] = self.data[x][y2 - 1]
+
+                # clear out top line
+                for x in range(0, self.width):
+                    self.data[x][0] = self.bg
+
+        # check for complete win
+        board_clear = (self.piece == None)
+        for y in range(0, self.height):
+            for x in range(0, self.width):
+                if self.data[x][y] != self.bg:
+                    board_clear = False
+                if board_clear == False:
+                    break
+            if board_clear == False:
+                break
+        return board_clear
+
     def step(self):
         if self.piece == None:
             justPlaced = True
             ]
 
             # center the piece on top of the playing board
-            self.piece[2] = int((self.gui.width - len(self.piece[0][0])) / 2)
+            self.piece[2] = int((self.width - len(self.piece[0][0])) / 2)
 
             if self.collision():
                 # new piece immediately collided. game over!
             if self.piece[2] > 0:
                 self.piece[2] -= 1
         elif self.button == "r":
-            if self.piece[2] < (self.gui.width - 1):
+            if self.piece[2] < (self.width - 1):
                 self.piece[2] += 1
         else:
             # one pixel down
             self.piece[2] = oldPosition[0]
             self.piece[3] = oldPosition[1]
 
-            if (self.button != "l") and (self.button != "r"):
+            if (self.button != "l") and (self.button != "r") and (self.button != "u"):
                 # but only stop playing it if it was moving down
                 self.piece = None
+
+                # check for cleared line
+                if self.checkWin():
+                    return False
         else:
             # copy piece at new location into buffer
             self.put(False)
 
     def buttons(self):
         keys = self.input.get()
-        if keys["left"]:
+
+        if keys["left"] and (not self.old_keys["left"]):
             self.button = "l"
-        elif keys["right"]:
+        elif keys["right"] and (not self.old_keys["right"]):
             self.button = "r"
-        elif keys["up"]:
+        elif keys["up"] and (not self.old_keys["up"]):
             self.button = "u"
         elif keys["down"]:
             self.button = "d"
+        elif (keys["select"] and keys["start"] and (not self.old_keys["start"])) or (keys["start"] and keys["select"] and (not self.old_keys["select"])):
+            self.restart()
+
+        self.old_keys = keys.copy()
 
     def draw(self):
         if self.done:
 
         now = time.time()
         if (self.button != None) or ((now - self.last) >= self.timestep) or (now < self.last):
-            self.last = now
+            # don't let user stop falling pieces by moving/rotating endlessly
+            if (self.button != "l") and (self.button != "r") and (self.button != "u"):
+                self.last = now
+
             cont = self.step()
             if cont == False:
                 self.done = True
                 self.scoreText.setText("Score: " + str(self.score), "uushi")
                 self.endText.restart()
 
-        for x in range(0, self.gui.width):
-            for y in range(0, self.gui.height):
-                self.gui.set_pixel(x, y, self.data[x][y])
+        # TODO placement of play area
+        for x in range(-1, self.width + 1):
+            for y in range(-1, self.height + 1):
+                c = (255, 255, 255)
+                if (x >= 0) and (y >= 0) and (x < self.width) and (y < self.height):
+                    c = self.data[x][y]
 
-if __name__ == "__main__":
-    import util
-    t = util.getTarget()
+                self.gui.set_pixel(x + 1 + self.x_off, y + 1 + self.y_off, c)
 
+if __name__ == "__main__":
+    # Need to import InputWrapper before initializing RGB Matrix on Pi
     from gamepad import InputWrapper
     i = InputWrapper()
 
-    d = Tetris(t, i, 0.1)
+    import util
+    t = util.getTarget()
+
+    d = Tetris(t, i)
     t.loop(d.draw)

util.py

 
 import sys
 
+cachedTarget = None
 targetPlatform = None
 wifiConnected = False
 
     return targetPlatform == "pico"
 
 def getTarget():
-    global targetPlatform
+    global targetPlatform, cachedTarget
+
+    if cachedTarget != None:
+        return cachedTarget
 
     target = None
     try:
         # TODO hard-coded adjustments
         from mapper import MapperColorAdjust, MapperStripToRect
         col = MapperColorAdjust(pi)
-        target = MapperStripToRect(col)
+        #target = MapperStripToRect(col)
+        target = col
 
         if targetPlatform == None:
             # only print once
             print("Raspberry Pi Adafruit RGB LED Matrix detected")
         targetPlatform = "pi"
     except Exception as e:
+        target = None
+
         print()
         if hasattr(sys, "print_exception"):
             sys.print_exception(e)
                 print("Raspberry Pi Pico Interstate75 RGB LED Matrix detected")
             targetPlatform = "pico"
         except Exception as e:
+            target = None
+
             print()
             if hasattr(sys, "print_exception"):
                 sys.print_exception(e)
                 print("Falling back to GUI debug interface")
             targetPlatform = "tk"
 
+    cachedTarget = target
     return target
 
 # https://github.com/raspberrypi/pico-examples/blob/master/pico_w/wifi/python_test_tcp/micropython_test_tcp_client.py