animated tetris

Author: rene-d

2022/README.md

@@ -25,7 +25,7 @@ Puzzle                                                                   | Stars
 [Day 14: Regolith Reservoir](https://adventofcode.com/2022/day/14)       | ⭐⭐  | [![Rust](../scripts/assets/rust.png)](../2022/day14/day14.rs) [![Python](../scripts/assets/python.png)](../2022/day14/day14.py)
 [Day 15: Beacon Exclusion Zone](https://adventofcode.com/2022/day/15)    | ⭐⭐  | [![Rust](../scripts/assets/rust.png)](../2022/day15/day15.rs) [![Python](../scripts/assets/python.png)](../2022/day15/day15.py)
 [Day 16: Proboscidea Volcanium](https://adventofcode.com/2022/day/16)    | ⭐⭐  | [![Rust](../scripts/assets/rust.png)](../2022/day16/day16.rs)
-[Day 17: Pyroclastic Flow](https://adventofcode.com/2022/day/17)         | ⭐⭐  | [![Rust](../scripts/assets/rust.png)](../2022/day17/day17.rs) [![Python](../scripts/assets/python.png)](../2022/day17/day17.py)
+[Day 17: Pyroclastic Flow](https://adventofcode.com/2022/day/17)         | ⭐⭐  | [![Rust](../scripts/assets/rust.png)](../2022/day17/day17.rs) [![Python](../scripts/assets/python.png)](../2022/day17/day17.py) [🎁](../2022/day17/README.md)
 [Day 18: Boiling Boulders](https://adventofcode.com/2022/day/18)         | ⭐⭐  | [![Rust](../scripts/assets/rust.png)](../2022/day18/day18.rs)
 [Day 19: Not Enough Minerals](https://adventofcode.com/2022/day/19)      | ⭐⭐  | [![Rust](../scripts/assets/rust.png)](../2022/day19/day19.rs)
 [Day 20: Grove Positioning System](https://adventofcode.com/2022/day/20) | ⭐⭐  | [![Rust](../scripts/assets/rust.png)](../2022/day20/day20.rs)

2022/day17/README.md

@@ -0,0 +1,3 @@
+# Tetris
+
+![tetris](tetris.gif)

2022/day17/day17.py

@@ -3,13 +3,11 @@
 
 # Nota: not sure to write it in Rust, nor to make it cleaner and more Pythonic...
 
-import sys
+import argparse
+import time
 from pathlib import Path
 
-filename = ("test.txt" if sys.argv[1] == "-t" else sys.argv[1]) if len(sys.argv) > 1 else "input.txt"
-data = Path(filename).read_text()
-
-rocks = [
+ROCKS = [
     [
         [1, 1, 1, 1],
     ],
@@ -36,167 +34,183 @@
 ]
 
 
-jets = data.strip()
+class Tetris:
+    def __init__(self, jets):
 
-cave = [
-    [1, 1, 1, 1, 1, 1, 1],  # the bottom
-]
-bottom = 0
+        self.jets = jets.strip()
 
-jet_count = 0
-rock_count = 0
+        self.cave = [
+            [1, 1, 1, 1, 1, 1, 1],  # the bottom
+        ]
+        self.bottom = 0
 
+        self.jet_count = 0
+        self.rock_count = 0
 
-def cave_height():
-    """Returns cave height, including the bottom line."""
-    global bottom
-    return len(cave) + bottom
+    def cave_height(self):
+        """Returns cave height, including the bottom line."""
 
+        return len(self.cave) + self.bottom
 
-def overlap(x, y, rock):
-    width = len(rock[0])
-    height = len(rock)
-    for i in range(height):
-        for j in range(width):
-            if y + i < cave_height():
-                if cave[y + i - bottom][x + j] != 0 and rock[i][j] == 1:
-                    return True
-    return False
+    def overlap(self, x, y, rock):
+        width = len(rock[0])
+        height = len(rock)
+        for i in range(height):
+            for j in range(width):
+                if y + i < self.cave_height():
+                    if self.cave[y + i - self.bottom][x + j] != 0 and rock[i][j] == 1:
+                        return True
+        return False
 
+    def fall(self):
 
-def fall():
-    global jet_count, rock_count, bottom
+        rock = ROCKS[self.rock_count % len(ROCKS)]
+        self.rock_count += 1
 
-    rock = rocks[rock_count % len(rocks)]
-    rock_count += 1
+        width = len(rock[0])
+        height = len(rock)
 
-    width = len(rock[0])
-    height = len(rock)
+        y = self.cave_height() + 3
+        x = 2
 
-    y = cave_height() + 3
-    x = 2
+        while True:
+            # current jet of gas
+            gas = self.jets[self.jet_count % len(self.jets)]
+            self.jet_count += 1
 
-    while True:
-        # current jet of gas
-        gas = jets[jet_count % len(jets)]
-        jet_count += 1
+            # shift the rock if possible
+            if gas == ">" and x + width + 1 <= 7 and not self.overlap(x + 1, y, rock):
+                x += 1
+            elif gas == "<" and x > 0 and not self.overlap(x - 1, y, rock):
+                x -= 1
 
-        # shift the rock if possible
-        if gas == ">" and x + width + 1 <= 7 and not overlap(x + 1, y, rock):
-            x += 1
-        elif gas == "<" and x > 0 and not overlap(x - 1, y, rock):
-            x -= 1
+            # rock falls if possible
+            if not self.overlap(x, y - 1, rock):
+                y -= 1
+            else:
+                break
 
-        # rock falls if possible
-        if not overlap(x, y - 1, rock):
-            y -= 1
-        else:
-            break
+        for i in range(height):
+            if y + i >= self.cave_height():
+                self.cave.append([0, 0, 0, 0, 0, 0, 0])
+            for j in range(width):
+                if rock[i][j] == 1:
+                    self.cave[y + i - self.bottom][x + j] = 65 + (self.rock_count - 1) % len(ROCKS)
 
-    for i in range(height):
-        if y + i >= cave_height():
-            cave.append([0, 0, 0, 0, 0, 0, 0])
-        for j in range(width):
-            if rock[i][j] == 1:
-                cave[y + i - bottom][x + j] = 65 + (rock_count - 1) % len(rocks)
+        if len(self.cave) > 200:
+            del self.cave[0:100]
+            self.bottom += 100
 
-    if len(cave) > 200:
-        del cave[0:100]
-        bottom += 100
+    def show(self, gameover: bool):
 
+        max_rows = 25
+        print(end="\033[H\033[2J")
 
-def show(rx=None, ry=None, rock=None):
-    global bottom
+        h = self.cave_height() + 2
 
-    h = cave_height() + 2
-    if rx and ry and rock:
-        width = len(rock[0])
-        height = len(rock)
+        for y in range(h - 1, self.bottom - 1, -1):
+            s = "|" if y > 0 else "+"
 
-        h = max(h, ry + len(rock))
+            for x in range(0, 7):
 
-    for y in range(h - 1, bottom - 1, -1):
-        s = "|" if y > 0 else "+"
+                if y < self.cave_height():
+                    c = self.cave[y - self.bottom][x]
+                else:
+                    c = 0
 
-        for x in range(0, 7):
-            if rx and ry and rock:
-                if rx <= x < rx + width and ry <= y < ry + height:
-                    if rock[y - ry][x - rx] == 1:
-                        s += "@"
-                        continue
+                if c == 0:
+                    s += "  "
+                elif c == 1:
+                    s += "--"
+                else:
+                    s += "\033[" + str(c - 65 + 31) + "m██\033[0m"
+                    # s += chr(c)█
 
-            if y < cave_height():
-                c = cave[y - bottom][x]
-            else:
-                c = 0
+            s += "|" if y > 0 else "+"
 
-            if c == 0:
-                s += "."
-            elif c == 1:
-                s += "-"
+            if y == self.cave_height() - 1:
+                print(f"{s} <= top ({y})")
             else:
-                s += chr(c)
+                print(s)
+
+            max_rows -= 1
+            if max_rows == 0:
+                time.sleep(0.1)
+                break
+
+        if self.bottom != 0:
+            print(f"({self.bottom} rows suppressed)")
+
+    def make_key(self):
+        top = []
+        mask = 0
+        for y in range(len(self.cave) - 1, -1, -1):
+            for i, c in enumerate(self.cave[y]):
+                if c != 0:
+                    mask |= 1 << i
+            top.append(mask)
+            if mask == 127:  # found a rock on all the 7 columns
+                break
+        return (self.rock_count % len(ROCKS), self.jet_count % len(self.jets), bytes(top))
+
+    def solve(self, show=False):
+
+        keys = {}
+        heights = [0]
+        start, end = None, None
+        part1 = None
+
+        for n in range(1, 10000):
+            self.fall()
+
+            if show:
+                self.show(False)
+
+            if n == 2022:
+                part1 = self.cave_height() - 1
+
+            if not end:
+                heights.append(self.cave_height() - 1)
+                key = self.make_key()
+                if n > 2000 and key in keys:
+                    start = keys[key]
+                    end = n
+                keys[key] = n
+
+            if part1 and end:
+                if show:
+                    self.show(True)
+                break
 
-        s += "|" if y > 0 else "+"
-
-        if y == cave_height() - 1:
-            print(f"{s} <= top ({y})")
         else:
-            print(s)
-
-    if bottom != 0:
-        print(f"({bottom} rows suppressed)")
-
-
-def make_key():
-    global rock_count, jet_count
-    top = []
-    mask = 0
-    for y in range(len(cave) - 1, -1, -1):
-        for i, c in enumerate(cave[y]):
-            if c != 0:
-                mask |= 1 << i
-        top.append(mask)
-        if mask == 127:
-            break
-    return (rock_count % len(rocks), jet_count % len(jets), bytes(top))
-
-
-keys = {}
-heights = [0]
-start, end = None, None
-part1 = None
+            print("no solution")
+            exit()
 
-for n in range(1, 10000):
-    fall()
+        # part 1
 
-    if n == 2022:
-        part1 = cave_height() - 1
+        # part 2
+        q, r = divmod(1_000_000_000_000 - start, end - start)
+        part2 = heights[start + r] + q * (heights[end] - heights[start])
 
-    if not end:
-        heights.append(cave_height() - 1)
-        key = make_key()
-        if n > 2000 and key in keys:
-            start = keys[key]
-            end = n
-        keys[key] = n
+        return part1, part2
 
-    if part1 and end:
-        break
 
-else:
-    print("no solution")
-    exit()
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-v", "--verbose", action="store_true")
+    parser.add_argument("-t", "--test", action="store_true")
+    parser.add_argument("filename", nargs="?", type=Path, default="input.txt")
+    args = parser.parse_args()
+    if args.test:
+        args.filename = Path("test.txt")
 
-# part 1
-print(part1)
+    data = args.filename.read_text().strip()
 
-# part 2
-q, r = divmod(1_000_000_000_000 - start, end - start)
-part2 = heights[start + r] + q * (heights[end] - heights[start])
-print(part2)
+    tetris = Tetris(data)
+    part1, part2 = tetris.solve(args.verbose)
+    print(part1)
+    print(part2)
 
 
-if filename == "test.txt":
-    assert part1 == 3068
-    assert part2 == 1514285714288
+if __name__ == "__main__":
+    main()