add gamepad/keyboard handler and simple snake game

README.md

@@ -17,6 +17,9 @@ You always need:
     pip install pil
     pip install bdfparser
     pip install "qrcode[pil]"
+    pip install evdev
+
+For evdev to find all devices you may need to add your user to the `input` group or run the scripts as root.
 
 The rest depends on the output device chosen.
 For debugging on your host PC you can use the TestGUI interface with pygame:

camp_small.py

@@ -18,12 +18,15 @@ if __name__ == "__main__":
     from net import CheckHTTP
     from image import ImageScreen
     from qr import QRScreen
+    from snake import Snake
+    from gamepad import InputWrapper
     from manager import Manager
 
     url = "http://ubabot.frubar.net"
 
     import util
     t = util.getTarget()
+    i = InputWrapper()
 
     # Loading fonts and graphics takes a while.
     # So show a splash screen while the user waits.
@@ -60,6 +63,8 @@ if __name__ == "__main__":
     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))
 

draw.py

@@ -122,14 +122,17 @@ class ScrollText:
     def __init__(self, g, t, f, i = 1, s = 75, fg = (255, 255, 255), bg = (0, 0, 0)):
         self.gui = g
         self.drawer = DrawText(self.gui, fg, bg)
-        self.text = t
-        self.font = f
         self.iterations = i
         self.speed = 1.0 / s
 
-        self.width = self.drawer.text(self.text, self.font, 0, False)
+        self.setText(t, f)
         self.restart()
 
+    def setText(self, t, f):
+        self.text = t
+        self.font = f
+        self.width = self.drawer.text(self.text, self.font, 0, False)
+
     def restart(self):
         self.offset = -self.gui.width
         self.last = time.time()

gamepad.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+
+# Uses the Python evdev wrapper:
+# https://github.com/gvalkov/python-evdev
+#
+# ----------------------------------------------------------------------------
+# "THE BEER-WARE LICENSE" (Revision 42):
+# <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+# you can do whatever you want with this stuff. If we meet some day, and you
+# think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+# ----------------------------------------------------------------------------
+
+from evdev import InputDevice, list_devices, ecodes, categorize
+from selectors import DefaultSelector, EVENT_READ
+
+class InputWrapper:
+    def __init__(self):
+        self.devices = []
+        self.selector = DefaultSelector()
+        self.keys = {
+            "left": False,
+            "right": False,
+            "up": False,
+            "down": False,
+            "a": False,
+            "b": False,
+            "x": False,
+            "y": False,
+        }
+
+        devices = [InputDevice(path) for path in list_devices()]
+        for device in devices:
+            c = device.capabilities()
+            keep = False
+
+            # check for key events
+            if ecodes.EV_KEY in c:
+                # check for gamepad
+                if ecodes.BTN_A in c[ecodes.EV_KEY]:
+                    print("Gamepad detected: ", device.name)
+                    keep = True
+
+                # check for arrow keys
+                elif ecodes.KEY_LEFT in c[ecodes.EV_KEY]:
+                    print("Keyboard detected:", device.name)
+                    keep = True
+
+            if not keep:
+                continue
+
+            d = InputDevice(device.path)
+            self.devices.append(d)
+            self.selector.register(d, EVENT_READ)
+
+    def get(self, verbose = False):
+        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.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 verbose:
+                    print(categorize(event), event)
+
+        return self.keys
+
+if __name__ == "__main__":
+    from pprint import pprint
+    import sys
+
+    if len(sys.argv) > 1:
+        devices = [InputDevice(path) for path in list_devices()]
+        for device in devices:
+            print(device.path, device.name, device.phys)
+            pprint(device.capabilities(verbose=True))
+            print()
+    else:
+        i = InputWrapper()
+        while True:
+            i.get(True)

snake.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+
+# ----------------------------------------------------------------------------
+# "THE BEER-WARE LICENSE" (Revision 42):
+# <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+# you can do whatever you want with this stuff. If we meet some day, and you
+# think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+# ----------------------------------------------------------------------------
+
+from draw import ScrollText
+import time
+import random
+
+class Snake:
+    def __init__(self, g, i, sc = (0, 255, 0), d = (0, 0, 255), bg = (0, 0, 0), ts = 0.3, su = 0.75, to = 60.0):
+        self.gui = g
+        self.input = i
+        self.colors = [ bg, sc, d ]
+        self.timestep = ts
+        self.timeout = to
+        self.speedup = su
+
+        self.winText = ScrollText(self.gui, "You Won!", "uushi",
+                                  2, 75, (0, 255, 0))
+        self.loseText = ScrollText(self.gui, "Game Over!", "uushi",
+                                   2, 75, (255, 0, 0))
+        self.scoreText = ScrollText(self.gui, "Score:", "uushi",
+                                    2, 75, sc)
+
+        random.seed()
+        self.restart()
+
+    def restart(self):
+        self.start = time.time()
+        self.last = time.time()
+        self.direction = "r"
+        self.directionTmp = "r"
+        self.score = 0
+        self.data = [[0 for y in range(self.gui.height)] for x in range(self.gui.width)]
+
+        self.player = [ (int(self.gui.width / 2), int(self.gui.height / 2)) ]
+        self.data[self.player[0][0]][self.player[0][1]] = 1
+
+        self.placeDot()
+
+    def finished(self):
+        if self.input == None:
+            # backup timeout for "AI"
+            if (time.time() - self.start) >= self.timeout:
+                return True
+
+        if self.direction == "":
+            # game over screen
+            return self.scoreText.finished()
+
+        return False
+
+    def placeDot(self):
+        d = (random.randrange(0, self.gui.width), random.randrange(0, self.gui.height))
+        while self.data[d[0]][d[1]] != 0:
+            d = (random.randrange(0, self.gui.width), random.randrange(0, self.gui.height))
+        self.data[d[0]][d[1]] = 2
+
+    def buttons(self):
+        keys = self.input.get()
+        if keys["left"]:
+            self.directionTmp = "l"
+        elif keys["right"]:
+            self.directionTmp = "r"
+        elif keys["up"]:
+            self.directionTmp = "u"
+        elif keys["down"]:
+            self.directionTmp = "d"
+
+    def step(self):
+        player = self.player[len(self.player) - 1]
+        if self.direction == "r":
+            player = (player[0] + 1, player[1])
+        elif self.direction == "l":
+            player = (player[0] - 1, player[1])
+        elif self.direction == "u":
+            player = (player[0], player[1] - 1)
+        elif self.direction == "d":
+            player = (player[0], player[1] + 1)
+
+        if (player[0] < 0) or (player[1] < 0) or (player[0] >= self.gui.width) or (player[1] >= self.gui.height):
+            return False
+
+        if self.data[player[0]][player[1]] == 0:
+            # remove last tail piece if not on dot
+            self.data[self.player[0][0]][self.player[0][1]] = 0
+            self.player.pop(0)
+        elif self.data[player[0]][player[1]] == 1:
+            # snake crashed into itself
+            return False
+        else:
+            # collected a dot
+            self.score += 1
+            if self.score >= self.gui.width * self.gui.height:
+                return False
+
+            self.timestep = self.timestep * self.speedup
+            self.placeDot()
+
+        self.player.append(player)
+        self.data[player[0]][player[1]] = 1
+        return True
+
+    def finishedEndScreen(self):
+        if self.score >= self.gui.width * self.gui.height:
+            return self.winText.finished()
+        else:
+            return self.loseText.finished()
+
+    def drawEndScreen(self):
+        if self.score >= self.gui.width * self.gui.height:
+            self.winText.draw()
+        else:
+            self.loseText.draw()
+
+    def drawScoreScreen(self):
+        self.scoreText.draw()
+
+    def draw(self):
+        if self.direction == "":
+            if self.finishedEndScreen():
+                self.drawScoreScreen()
+            else:
+                self.drawEndScreen()
+                self.scoreText.restart()
+            return
+
+        if self.input != None:
+            self.buttons()
+        else:
+            # TODO "AI"
+            pass
+
+        if (time.time() - self.last) >= self.timestep:
+            self.last = time.time()
+
+            # only allow valid inputs
+            tmp = self.direction + self.directionTmp
+            if (tmp != "lr") and (tmp != "rl") and (tmp != "ud") and (tmp != "du"):
+                self.direction = self.directionTmp
+
+            cont = self.step()
+            if cont == False:
+                self.direction = ""
+                self.scoreText.setText("Score: " + str(self.score), "uushi")
+                self.winText.restart()
+                self.loseText.restart()
+                self.scoreText.restart()
+
+        for x in range(0, self.gui.width):
+            for y in range(0, self.gui.height):
+                self.gui.set_pixel(x, y, self.colors[self.data[x][y]])
+
+if __name__ == "__main__":
+    import util
+    t = util.getTarget()
+
+    from gamepad import InputWrapper
+    i = InputWrapper()
+
+    d = Snake(t, i)
+    t.debug_loop(d.draw)