Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,180 @@
+import random
+import sys
+import time
+import termios
+import tty
+from typing import List, Tuple, Optional
+
+# Board dimensions
+WIDTH, HEIGHT = 10, 20
+
+# Tetromino shapes
+SHAPES = [
+    [[1, 1, 1, 1]],  # I
+    [[1, 1], [1, 1]],  # O
+    [[0, 1, 0], [1, 1, 1]],  # T
+    [[0, 1, 1], [1, 1, 0]],  # S
+    [[1, 1, 0], [0, 1, 1]],  # Z
+    [[1, 0, 0], [1, 1, 1]],  # J
+    [[0, 0, 1], [1, 1, 1]],  # L
+]
+
+# Colors (ANSI)
+COLORS = ["\033[31m", "\033[32m", "\033[33m", "\033[34m", "\033[35m", "\033[36m", "\033[37m"]
+RESET = "\033[0m"
+
+class Tetromino:
+    def __init__(self, shape: List[List[int]], color: str):
+        self.shape = shape
+        self.color = color
+        self.x = WIDTH // 2 - len(shape[0]) // 2
+        self.y = 0
+
+    def rotated(self) -> List[List[int]]:
+        """Return the shape rotated 90° clockwise."""
+        return [list(row) for row in zip(*self.shape[::-1])]
+
+class Tetris:
+    def __init__(self):
+        self.board: List[List[Optional[str]]] = [[None] * WIDTH for _ in range(HEIGHT)]
+        self.current: Tetromino = self.new_piece()
+        self.next: Tetromino = self.new_piece()
+        self.game_over = False
+        self.score = 0
+        self.level = 1
+        self.drop_time = 0.5  # seconds between drops
+
+    def new_piece(self) -> Tetromino:
+        shape = random.choice(SHAPES)
+        color = random.choice(COLORS)
+        return Tetromino(shape, color)
+
+    def valid(self, shape: List[List[int]], x: int, y: int) -> bool:
+        for dy, row in enumerate(shape):
+            for dx, cell in enumerate(row):
+                if cell:
+                    nx, ny = x + dx, y + dy
+                    if nx < 0 or nx >= WIDTH or ny >= HEIGHT or (ny >= 0 and self.board[ny][nx]):
+                        return False
+        return True
+
+    def lock_piece(self):
+        shape = self.current.shape
+        x, y = self.current.x, self.current.y
+        for dy, row in enumerate(shape):
+            for dx, cell in enumerate(row):
+                if cell and y + dy >= 0:
+                    self.board[y + dy][x + dx] = self.current.color
+        self.clear_lines()
+        self.current = self.next
+        self.next = self.new_piece()
+        if not self.valid(self.current.shape, self.current.x, self.current.y):
+            self.game_over = True
+
+    def clear_lines(self):
+        new_board = [row for row in self.board if any(cell is None for cell in row)]
+        lines_cleared = HEIGHT - len(new_board)
+        if lines_cleared:
+            self.score += (lines_cleared ** 2) * 100 * self.level
+            for _ in range(lines_cleared):
+                new_board.insert(0, [None] * WIDTH)
+            self.board = new_board
+            self.level = self.score // 1000 + 1
+            self.drop_time = max(0.05, 0.5 - (self.level - 1) * 0.05)
+
+    def move(self, dx: int, dy: int) -> bool:
+        new_x = self.current.x + dx
+        new_y = self.current.y + dy
+        if self.valid(self.current.shape, new_x, new_y):
+            self.current.x, self.current.y = new_x, new_y
+            return True
+        return False
+
+    def rotate(self):
+        rotated = self.current.rotated()
+        if self.valid(rotated, self.current.x, self.current.y):
+            self.current.shape = rotated
+        else:
+            # Try wall kicks (simple)
+            for dx in (-1, 1, -2, 2):
+                if self.valid(rotated, self.current.x + dx, self.current.y):
+                    self.current.x += dx
+                    self.current.shape = rotated
+                    break
+
+    def hard_drop(self):
+        while self.move(0, 1):
+            pass
+        self.lock_piece()
+
+    def draw(self):
+        # Clear screen + hide cursor
+        print("\033[2J\033[?25l", end="")
+        # Draw board with border
+        output = []
+        output.append("Score: {}  Level: {}".format(self.score, self.level))
+        output.append("┌" + "─" * WIDTH + "┐")
+        for y in range(HEIGHT):
+            line = []
+            for x in range(WIDTH):
+                if (0 <= y - self.current.y < len(self.current.shape) and
+                    0 <= x - self.current.x < len(self.current.shape[0]) and
+                    self.current.shape[y - self.current.y][x - self.current.x]):
+                    line.append(self.current.color + "■" + RESET)
+                else:
+                    cell = self.board[y][x]
+                    line.append(cell + "■" + RESET if cell else " ")
+            output.append("│" + "".join(line) + "│")
+        output.append("└" + "─" * WIDTH + "┘")
+        # Draw next
+        output.append("Next:")
+        for row in self.next.shape:
+            line = []
+            for cell in row:
+                line.append(self.next.color + "■" + RESET if cell else " ")
+            output.append("  " + "".join(line))
+        output.append("\nControls: ← → ↓  rotate: ↑  drop: space  quit: q")
+        print("\n".join(output), end="", flush=True)
+
+    def run(self):
+        last_drop = time.time()
+        while not self.game_over:
+            self.draw()
+            ch = self.getch()
+            if ch == '\x1b':  # ESC sequence
+                ch += sys.stdin.read(2)
+            if ch in ('q', '\x03'):  # q or Ctrl-C
+                break
+            elif ch == '\x1b[A':  # up
+                self.rotate()
+            elif ch == '\x1b[B':  # down
+                self.move(0, 1)
+            elif ch == '\x1b[C':  # right
+                self.move(1, 0)
+            elif ch == '\x1b[D':  # left
+                self.move(-1, 0)
+            elif ch == ' ':
+                self.hard_drop()
+                last_drop = time.time()
+            # Auto-drop
+            if time.time() - last_drop > self.drop_time:
+                if not self.move(0, 1):
+                    self.lock_piece()
+                last_drop = time.time()
+        print("\033[?25h\033[2JGame Over! Score: {}".format(self.score))
+
+    def getch(self) -> str:
+        fd = sys.stdin.fileno()
+        old = termios.tcgetattr(fd)
+        try:
+            tty.setraw(fd)
+            ch = sys.stdin.read(1)
+            return ch
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+if __name__ == "__main__":
+    try:
+        Tetris().run()
+    except KeyboardInterrupt:
+        print("\033[?25h")  # restore cursor