working on TetrisTwoBlockApp

Author: trevorwslee

dumbdisplay_examples/tetris/_common.py

@@ -58,33 +58,78 @@ def __init__(self, x: int, y: int, block_grid: Grid, block_pen: LayerTurtle):
         _draw_grid(block_grid, block_pen)
 
     def move_down(self, grid: Grid) -> bool:
-        if _check_block_grid_placement(self.block_grid, self.x, self.y + 1, grid=grid):
+        if _check_bad_block_grid_placement(self.block_grid, self.x, self.y + 1, grid=grid):
             return False
         self.y += 1
         self.sync_image()
         return True
 
     def move_right(self, grid: Grid) -> bool:
-        if _check_block_grid_placement(self.block_grid, self.x + 1, self.y, grid=grid):
+        if _check_bad_block_grid_placement(self.block_grid, self.x + 1, self.y, grid=grid):
             return False
         self.x += 1
         self.sync_image()
         return True
 
     def move_left(self, grid: Grid) -> bool:
-        if _check_block_grid_placement(self.block_grid, self.x - 1, self.y, grid=grid):
+        if _check_bad_block_grid_placement(self.block_grid, self.x - 1, self.y, grid=grid):
             return False
         self.x -= 1
         #print(f"* left ==> x={self.x}")
         self.sync_image()
         return True
 
+    def rotate(self, grid: Grid) -> bool:
+        (rotated_block_grid, y_offset) = _rotate_block_grid_if_possible(self.block_grid, self.x, self.y, grid=grid)
+        if rotated_block_grid is None:
+            return False
+        self.block_grid = rotated_block_grid
+        self.y += y_offset
+        self.block_pen.clear()
+        _draw_grid(self.block_grid, self.block_pen)
+        return True
+
+
     def sync_image(self):
         anchor_x = self.x * _block_unit_width
         anchor_y = self.y * _block_unit_width
         self.block_pen.setLevelAnchor(anchor_x, anchor_y)
 
 
+
+def _check_bad_block_grid_cells_placement(grid_cells: list[list[int]], block_grid_x_off: int, block_grid_y_offset: int, grid: Grid, check_boundary: bool = True) -> bool:
+    n_rows = len(grid_cells)
+    n_cols = len(grid_cells[0]) if n_rows > 0 else 0
+    for y in range(n_rows):
+        for x in range(n_cols):
+            if grid_cells[y][x] != 0:
+                row_idx = y + block_grid_y_offset
+                col_idx = x + block_grid_x_off
+                if row_idx < 0:
+                    continue  # never mind above the grid
+                if row_idx < 0 or row_idx >= grid.n_rows:
+                    if not check_boundary:
+                        continue
+                    return True
+                if col_idx < 0 or col_idx >= grid.n_cols:
+                    if not check_boundary:
+                        continue
+                    return True
+                if grid.get_value(row_idx, col_idx) != 0:
+                    return True
+    return False
+
+
+def _rotate_block_grid_cells(grid_cells: list[list[int]]) -> list[list[int]]:
+    rotated = []
+    for x in range(len(grid_cells[0])):
+        new_row = []
+        for y in range(len(grid_cells) -1, -1, -1):
+            new_row.append(grid_cells[y][x])
+        rotated.append(new_row)
+    return rotated
+
+
 def _randomize_grid(randomize_row_count: int) -> Grid:
     grid_cells = []
     for y in range(_grid_n_rows):
@@ -120,25 +165,38 @@ def _draw_grid(grid: Grid, pen: LayerTurtle):
             color_number = grid.get_value(y, x)
             _draw(x, y, color_number, pen)
 
-def _check_block_grid_placement(block_grid: Grid, block_grid_x_off: int, block_grid_y_offset: int, grid: Grid, check_boundary: bool = True) -> bool:
-    for y in range(block_grid.n_rows):
-        for x in range(block_grid.n_cols):
-            if block_grid.get_value(y, x) != 0:
-                row_idx = y + block_grid_y_offset
-                col_idx = x + block_grid_x_off
-                if row_idx < 0:
-                    continue  # never mind above the grid
-                if row_idx < 0 or row_idx >= grid.n_rows:
-                    if not check_boundary:
-                        continue
-                    return True
-                if col_idx < 0 or col_idx >= grid.n_cols:
-                    if not check_boundary:
-                        continue
-                    return True
-                if grid.get_value(row_idx, col_idx) != 0:
-                    return True
-    return False
+def _check_bad_block_grid_placement(block_grid: Grid, block_grid_x_off: int, block_grid_y_offset: int, grid: Grid, check_boundary: bool = True) -> bool:
+    if True:
+        return _check_bad_block_grid_cells_placement(block_grid.grid_cells, block_grid_x_off, block_grid_y_offset, grid, check_boundary)
+    else:
+        for y in range(block_grid.n_rows):
+            for x in range(block_grid.n_cols):
+                if block_grid.get_value(y, x) != 0:
+                    row_idx = y + block_grid_y_offset
+                    col_idx = x + block_grid_x_off
+                    if row_idx < 0:
+                        continue  # never mind above the grid
+                    if row_idx < 0 or row_idx >= grid.n_rows:
+                        if not check_boundary:
+                            continue
+                        return True
+                    if col_idx < 0 or col_idx >= grid.n_cols:
+                        if not check_boundary:
+                            continue
+                        return True
+                    if grid.get_value(row_idx, col_idx) != 0:
+                        return True
+        return False
+
+
+def _rotate_block_grid_if_possible(block_grid: Grid, block_grid_x_off: int, block_grid_y_offset: int, grid: Grid) -> (Grid, int):
+    block_grid_cells = block_grid.grid_cells
+    rotated_cells = _rotate_block_grid_cells(block_grid_cells)
+    y_offset = len(rotated_cells) - len(block_grid_cells)
+    if _check_bad_block_grid_cells_placement(rotated_cells, block_grid_x_off, block_grid_y_offset + y_offset, grid, check_boundary=True):
+        return (None, None)
+    rotated_block_grid = Grid(grid_cells=rotated_cells)
+    return (rotated_block_grid, y_offset)
 
 
 def _commit_block_grid(block_grid: Grid, block_grid_x_off: int, block_grid_y_offset: int, grid: Grid):

dumbdisplay_examples/tetris/tetris_classic.py

@@ -12,7 +12,7 @@
 from dumbdisplay.layer_lcd import LayerLcd
 from dumbdisplay_examples.tetris._common import Grid, _colors, _grid_n_rows, _grid_n_cols, _block_unit_width, \
     _width, _height, _left, _top, _draw_grid, _commit_block_grid, Block, \
-    _check_block_grid_placement, _randomize_grid
+    _check_bad_block_grid_placement, _randomize_grid, _rotate_block_grid_if_possible
 from dumbdisplay_examples.tetris._shapes import _randomize_block_grid
 
 from dumbdisplay_examples.utils import DDAppBase, create_example_wifi_dd
@@ -78,7 +78,7 @@ def reset_block(self) -> bool:
         block_grid = _randomize_block_grid()
         x -= int((block_grid.n_cols - 1) / 2)
         y += 1 - block_grid.n_rows
-        if _check_block_grid_placement(block_grid, x, y, grid=self.grid, check_boundary=False):
+        if _check_bad_block_grid_placement(block_grid, x, y, grid=self.grid, check_boundary=False):
             return False
         self.block = Block(x, y, block_grid=block_grid, block_pen=self.block_pen)
         self.sync_image()
@@ -96,6 +96,9 @@ def move_block_down(self) -> bool:
     def move_block_right(self) -> bool:
         return self.block.move_right(self.grid)
 
+    def rotate_block(self) -> bool:
+        return self.block.rotate(self.grid)
+
     def move_block_left(self) -> bool:
         return self.block.move_left(self.grid)
 
@@ -163,9 +166,14 @@ def initializeDD(self):
         right_button.writeLine("➡️")
         right_button.enableFeedback("f", lambda *args: self.moveBlockRight())
 
+        rotate_button = LayerLcd(self.dd, 2, 1, char_height=28)
+        rotate_button.noBackgroundColor()
+        rotate_button.writeLine("🔄")
+        rotate_button.enableFeedback("f", lambda *args: self.rotateBlock())
+
         AutoPin('V',
                 AutoPin('S'),
-                AutoPin('H', left_button, right_button)).pin(self.dd)
+                AutoPin('H', left_button, rotate_button, right_button)).pin(self.dd)
 
         self.score = score
         self.block_pen = block_pen
@@ -254,20 +262,18 @@ def moveBlockLeft(self) -> bool:
             self.startGame()
             return False
         return self.shape.move_block_left()
-        # if self.shape.move_block_left():
-        #     self.drawBlock()
-        #     return True
-        # return False
 
     def moveBlockRight(self) -> bool:
         if self.shape is None:
             self.startGame()
             return False
         return self.shape.move_block_right()
-        # if self.shape.move_block_right():
-        #     self.drawBlock()
-        #     return True
-        # return False
+
+    def rotateBlock(self) -> bool:
+        if self.shape is None:
+            self.startGame()
+            return False
+        return self.shape.rotate_block()
 
 
 if __name__ == "__main__":

dumbdisplay_examples/tetris/tetris_two_block.py

@@ -11,7 +11,7 @@
 from dumbdisplay.layer_lcd import LayerLcd
 from dumbdisplay_examples.tetris._common import Grid, _colors, _grid_n_rows, _grid_n_cols, _block_unit_width, \
     _width, _height, _left, _top, _draw_grid, _commit_block_grid, Block, \
-    _check_block_grid_placement, _randomize_grid
+    _check_bad_block_grid_placement, _randomize_grid
 
 from dumbdisplay_examples.utils import DDAppBase, create_example_wifi_dd
 
@@ -109,7 +109,7 @@ def reset_block(self) -> bool:
         block_grid = _randomize_block_grid()
         x -= int((block_grid.n_cols - 1) / 2)
         y += 1 - block_grid.n_rows
-        if _check_block_grid_placement(block_grid, x, y, grid=self.grid, check_boundary=False):
+        if _check_bad_block_grid_placement(block_grid, x, y, grid=self.grid, check_boundary=False):
             return False
         self.block = Block(x, y, block_grid=block_grid, block_pen=self.block_pen)
         self.sync_image()