broken tetris implementation

pi.py

@@ -17,14 +17,13 @@ from rgbmatrix import RGBMatrix, RGBMatrixOptions
 from PIL import Image
 
 class PiMatrix:
-    def __init__(self):
-        # TODO configurable
-        self.width = 32
-        self.height = 32
+    def __init__(self, w = 32, h = 32):
+        self.width = w
+        self.height = h
 
         options = RGBMatrixOptions()
-        options.rows = 32
-        options.cols = 32
+        options.rows = w
+        options.cols = h
         options.chain_length = 1
         options.parallel = 1
         options.row_address_type = 0
@@ -63,5 +62,5 @@ class PiMatrix:
         self.image.putpixel((int(x), int(y)), color)
 
 if __name__ == "__main__":
-    t = PiMatrix()
+    t = PiMatrix(32, 32)
     t.debug_loop(lambda: t.set_pixel(15, 15, (255, 255, 255)))

tetris.py

@@ -0,0 +1,266 @@
+#!/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 Tetris:
+    def __init__(self, g, i, ts = 0.5, to = 60.0):
+        self.gui = g
+        self.input = i
+        self.timestep = ts
+        self.timeout = to
+
+        self.endText = ScrollText(self.gui, "Game Over!", "uushi",
+                                   2, 75, (251, 72, 196))
+        self.scoreText = ScrollText(self.gui, "Score:", "uushi",
+                                    2, 75, (63, 255, 33))
+
+        self.bg = (0, 0, 0)
+        self.colors = [
+            (251, 72, 196), # camp23 pink
+            (63, 255, 33), # camp23 green
+            (255, 0, 0),
+            #(0, 255, 0),
+            (0, 0, 255),
+            (255, 255, 0),
+            (0, 255, 255),
+            (255, 0, 255),
+            #(255, 255, 255),
+        ]
+
+        # all [y][x] sub-lists must be the same length
+        self.pieces = [
+            # "I"
+            [
+                [1],
+                [1],
+                [1],
+                [1],
+            ],
+
+            # "L"
+            [
+                [1, 0],
+                [1, 0],
+                [1, 1],
+            ],
+
+            # "J"
+            [
+                [0, 1],
+                [0, 1],
+                [1, 1],
+            ],
+
+            # "T"
+            [
+                [1, 1, 1],
+                [0, 1, 0],
+            ],
+
+            # "O"
+            [
+                [1, 1],
+                [1, 1],
+            ],
+
+            # "S"
+            [
+                [0, 1, 1],
+                [1, 1, 0],
+            ],
+
+            # "Z"
+            [
+                [1, 1, 0],
+                [0, 1, 1],
+            ],
+        ]
+
+        random.seed()
+        self.restart()
+
+    def restart(self):
+        self.start = time.time()
+        self.last = time.time()
+        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.piece = None
+
+    def finished(self):
+        if self.input == None:
+            # backup timeout for "AI"
+            if (time.time() - self.start) >= self.timeout:
+                return True
+
+        if self.done:
+            # game over screen
+            return self.scoreText.finished()
+
+        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])
+        for y in range(0, len(self.piece[0])):
+            for x in range(0, len(self.piece[0][y])):
+                # only check where piece actually is
+                if self.piece[0][y][x] == 0:
+                    continue
+
+                # check for collision with bottom wall
+                if (y + pos[1]) >= self.gui.height:
+                    return True
+
+                # check for collision with previous pieces
+                if self.data[x + pos[0]][y + pos[1]] != self.bg:
+                    return True
+        return False
+
+    # copy piece into data buffer
+    def put(self, clear, pos = None, pie = None):
+        position = pos
+        if position == None:
+            position = (self.piece[2], self.piece[3])
+
+        piece = pie
+        if piece == None:
+            piece = self.piece[0]
+
+        for y in range(0, len(piece)):
+            for x in range(0, len(piece[y])):
+                remove = False
+                if piece[y][x] == 0:
+                    remove = True
+
+                if clear or remove:
+                    self.data[x + position[0]][y + position[1]] = self.bg
+                else:
+                    self.data[x + position[0]][y + position[1]] = self.piece[1]
+
+    def step(self):
+        if self.piece == None:
+            justPlaced = True
+
+            # select a new piece type and color
+            self.piece = [
+                self.pieces[random.randrange(0, len(self.pieces))], # piece
+                self.colors[random.randrange(0, len(self.colors))], # color
+                0, # x
+                0, # y
+            ]
+
+            # center the piece on top of the playing board
+            self.piece[2] = int((self.gui.width - len(self.piece[0][0])) / 2)
+
+            if self.collision():
+                # new piece immediately collided. game over!
+                return False
+
+            # copy piece into data buffer
+            self.put(False)
+
+            # don't move in the placement-step
+            return True
+
+        oldPosition = (self.piece[2], self.piece[3])
+        oldPiece = [x[:] for x in self.piece[0]]
+
+        # button input
+        if self.button == "u":
+            # rotate piece
+            # https://stackoverflow.com/a/48444999
+            self.piece[0] = [list(x) for x in zip(*self.piece[0][::-1])]
+        elif self.button == "l":
+            if self.piece[2] > 0:
+                self.piece[2] -= 1
+        elif self.button == "r":
+            if self.piece[2] < (self.gui.width - 1):
+                self.piece[2] += 1
+        else:
+            # one pixel down
+            self.piece[3] += 1
+
+        # clear out piece from its old location
+        self.put(True, oldPosition, oldPiece)
+
+        collision = self.collision()
+        if collision:
+            # piece collided, put it back
+            self.put(False, oldPosition, oldPiece)
+            self.piece[0] = oldPiece
+            self.piece[2] = oldPosition[0]
+            self.piece[3] = oldPosition[1]
+
+            if (self.button != "l") and (self.button != "r"):
+                # but only stop playing it if it was moving down
+                self.piece = None
+        else:
+            # copy piece at new location into buffer
+            self.put(False)
+
+        # clear previous input
+        self.button = None
+
+        return True
+
+    def buttons(self):
+        keys = self.input.get()
+        if keys["left"]:
+            self.button = "l"
+        elif keys["right"]:
+            self.button = "r"
+        elif keys["up"]:
+            self.button = "u"
+        elif keys["down"]:
+            self.button = "d"
+
+    def draw(self):
+        if self.done:
+            if self.endText.finished():
+                self.scoreText.draw()
+            else:
+                self.endText.draw()
+                self.scoreText.restart()
+            return
+
+        if self.input != None:
+            self.buttons()
+        else:
+            # TODO "AI"
+            self.button = None
+
+        if (self.button != None) or ((time.time() - self.last) >= self.timestep):
+            self.last = time.time()
+            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])
+
+if __name__ == "__main__":
+    import util
+    t = util.getTarget()
+
+    from gamepad import InputWrapper
+    i = InputWrapper()
+
+    d = Tetris(t, i, 0.1)
+    t.debug_loop(d.draw)