claude-games 1.0.0

package/games/snake.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""Claude Snake - Play while Claude Code runs!"""
+import curses
+import random
+import time
+from collections import deque
+from notify import init_notify_colors, check_task_done, draw_notification
+
+def main(stdscr):
+    curses.curs_set(0)
+    stdscr.nodelay(True)
+    curses.start_color()
+    curses.use_default_colors()
+    curses.init_pair(1, curses.COLOR_GREEN, -1)    # snake
+    curses.init_pair(2, curses.COLOR_RED, -1)       # food
+    curses.init_pair(3, curses.COLOR_YELLOW, -1)    # score
+    curses.init_pair(4, curses.COLOR_CYAN, -1)      # border/title
+    curses.init_pair(5, curses.COLOR_WHITE, -1)     # text
+    init_notify_colors()
+
+    HEAD_CHARS = {(0, 1): '>', (0, -1): '<', (-1, 0): '^', (1, 0): 'v'}
+    FOOD_CHAR = '*'
+    BODY_CHAR = '#'
+
+    high_score = 0
+
+    def play_game():
+        nonlocal high_score
+        height, width = stdscr.getmaxyx()
+
+        # Playfield: inside border
+        top, left = 3, 1
+        bottom = height - 2
+        right = width - 2
+        field_h = bottom - top - 1
+        field_w = right - left - 1
+
+        if field_h < 5 or field_w < 10:
+            stdscr.erase()
+            stdscr.addstr(0, 0, "Terminal too small!", curses.color_pair(2))
+            stdscr.refresh()
+            time.sleep(2)
+            return False
+
+        # Init snake in center
+        mid_y = top + field_h // 2
+        mid_x = left + field_w // 2
+        direction = (0, 1)  # moving right
+        snake = deque([(mid_y, mid_x - 2), (mid_y, mid_x - 1), (mid_y, mid_x)])
+        snake_set = set(snake)
+
+        score = 0
+        base_speed = 0.12
+        game_over = False
+        paused = False
+        notify_timer = 0
+
+        def place_food():
+            while True:
+                fy = random.randint(top + 1, bottom - 1)
+                fx = random.randint(left + 1, right - 1)
+                if (fy, fx) not in snake_set:
+                    return (fy, fx)
+
+        food = place_food()
+
+        def draw_border():
+            try:
+                stdscr.addstr(top, left, '+' + '-' * field_w + '+', curses.color_pair(4))
+                stdscr.addstr(bottom, left, '+' + '-' * field_w + '+', curses.color_pair(4))
+                for y in range(top + 1, bottom):
+                    stdscr.addstr(y, left, '|', curses.color_pair(4))
+                    stdscr.addstr(y, right, '|', curses.color_pair(4))
+            except curses.error:
+                pass
+
+        while True:
+            frame_start = time.time()
+
+            # Input
+            key = stdscr.getch()
+            while True:
+                k2 = stdscr.getch()
+                if k2 == -1:
+                    break
+                key = k2
+
+            if key in (ord('q'), ord('Q')):
+                return False
+
+            if key in (ord('p'), ord('P')) and not game_over:
+                paused = not paused
+
+            if game_over:
+                if key in (ord(' '), curses.KEY_ENTER, 10, 13):
+                    return True  # restart
+                elapsed = time.time() - frame_start
+                if elapsed < 0.05:
+                    time.sleep(0.05 - elapsed)
+                continue
+
+            if paused:
+                stdscr.erase()
+                title = "CLAUDE SNAKE"
+                try:
+                    stdscr.addstr(0, max(0, (width - len(title)) // 2), title,
+                                  curses.color_pair(4) | curses.A_BOLD)
+                except curses.error:
+                    pass
+                score_str = f"Score: {score}  Hi: {high_score}"
+                try:
+                    stdscr.addstr(1, max(0, (width - len(score_str)) // 2), score_str,
+                                  curses.color_pair(3) | curses.A_BOLD)
+                except curses.error:
+                    pass
+                draw_border()
+                # Food
+                try:
+                    stdscr.addstr(food[0], food[1], FOOD_CHAR, curses.color_pair(2) | curses.A_BOLD)
+                except curses.error:
+                    pass
+                # Snake body
+                for i, (sy, sx) in enumerate(snake):
+                    is_head = (i == len(snake) - 1)
+                    try:
+                        if is_head:
+                            ch = HEAD_CHARS.get(direction, '>')
+                            stdscr.addstr(sy, sx, ch, curses.color_pair(1) | curses.A_BOLD)
+                        else:
+                            stdscr.addstr(sy, sx, BODY_CHAR, curses.color_pair(1))
+                    except curses.error:
+                        pass
+                pause_msg = "PAUSED - P to resume"
+                try:
+                    stdscr.addstr(height // 2, max(0, (width - len(pause_msg)) // 2),
+                                  pause_msg, curses.color_pair(3) | curses.A_BOLD)
+                except curses.error:
+                    pass
+                stdscr.refresh()
+                time.sleep(0.05)
+                continue
+
+            if check_task_done():
+                notify_timer = 80
+
+            # Direction
+            dy, dx = direction
+            if key == curses.KEY_UP and dy != 1:
+                direction = (-1, 0)
+            elif key == curses.KEY_DOWN and dy != -1:
+                direction = (1, 0)
+            elif key == curses.KEY_LEFT and dx != 1:
+                direction = (0, -1)
+            elif key == curses.KEY_RIGHT and dx != -1:
+                direction = (0, 1)
+
+            # Move
+            head_y, head_x = snake[-1]
+            ny = head_y + direction[0]
+            nx = head_x + direction[1]
+
+            # Collision check
+            if ny <= top or ny >= bottom or nx <= left or nx >= right:
+                game_over = True
+            elif (ny, nx) in snake_set:
+                game_over = True
+            else:
+                snake.append((ny, nx))
+                snake_set.add((ny, nx))
+
+                if (ny, nx) == food:
+                    score += 10
+                    if score > high_score:
+                        high_score = score
+                    food = place_food()
+                else:
+                    removed = snake.popleft()
+                    snake_set.discard(removed)
+
+            # Draw
+            stdscr.erase()
+
+            # Title
+            title = "CLAUDE SNAKE"
+            try:
+                stdscr.addstr(0, max(0, (width - len(title)) // 2), title,
+                              curses.color_pair(4) | curses.A_BOLD)
+            except curses.error:
+                pass
+
+            score_str = f"Score: {score}  Hi: {high_score}"
+            try:
+                stdscr.addstr(1, max(0, (width - len(score_str)) // 2), score_str,
+                              curses.color_pair(3) | curses.A_BOLD)
+            except curses.error:
+                pass
+
+            draw_border()
+
+            # Food
+            try:
+                stdscr.addstr(food[0], food[1], FOOD_CHAR, curses.color_pair(2) | curses.A_BOLD)
+            except curses.error:
+                pass
+
+            # Snake body
+            for i, (sy, sx) in enumerate(snake):
+                is_head = (i == len(snake) - 1)
+                try:
+                    if is_head:
+                        ch = HEAD_CHARS.get(direction, '>')
+                        stdscr.addstr(sy, sx, ch, curses.color_pair(1) | curses.A_BOLD)
+                    else:
+                        stdscr.addstr(sy, sx, BODY_CHAR, curses.color_pair(1))
+                except curses.error:
+                    pass
+
+            # Controls
+            ctrl = "Arrow keys: move  P: pause  Q: quit"
+            try:
+                stdscr.addstr(height - 1, max(0, (width - len(ctrl)) // 2), ctrl,
+                              curses.color_pair(5) | curses.A_DIM)
+            except curses.error:
+                pass
+
+            if game_over:
+                msgs = ["GAME OVER!", f"Score: {score}", "SPACE to restart  Q to quit"]
+                cy = height // 2 - 1
+                for i, msg in enumerate(msgs):
+                    attr = curses.color_pair(2) | curses.A_BOLD if i == 0 else curses.color_pair(3)
+                    try:
+                        stdscr.addstr(cy + i, max(0, (width - len(msg)) // 2), msg, attr)
+                    except curses.error:
+                        pass
+
+            notify_timer = draw_notification(stdscr, height, width, notify_timer)
+
+            stdscr.refresh()
+
+            # Speed: faster as snake grows
+            speed = max(0.05, base_speed - len(snake) * 0.002)
+            elapsed = time.time() - frame_start
+            if elapsed < speed:
+                time.sleep(speed - elapsed)
+
+    # Game loop
+    while True:
+        result = play_game()
+        if not result:
+            break
+
+
+def run():
+    curses.wrapper(main)
+
+if __name__ == "__main__":
+    run()

package/games/tetris.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+"""Claude Tetris - Play while Claude Code runs!"""
+import curses
+import random
+import time
+import copy
+from notify import init_notify_colors, check_task_done, draw_notification
+
+# Tetrominoes: each is a list of rotations, each rotation is a list of (row, col) offsets
+PIECES = {
+    'I': [[(0,0),(0,1),(0,2),(0,3)], [(0,0),(1,0),(2,0),(3,0)]],
+    'O': [[(0,0),(0,1),(1,0),(1,1)]],
+    'T': [[(0,0),(0,1),(0,2),(1,1)], [(0,0),(1,0),(2,0),(1,1)],
+           [(1,0),(1,1),(1,2),(0,1)], [(0,1),(1,1),(2,1),(1,0)]],
+    'S': [[(0,1),(0,2),(1,0),(1,1)], [(0,0),(1,0),(1,1),(2,1)]],
+    'Z': [[(0,0),(0,1),(1,1),(1,2)], [(0,1),(1,0),(1,1),(2,0)]],
+    'J': [[(0,0),(1,0),(1,1),(1,2)], [(0,0),(0,1),(1,0),(2,0)],
+           [(0,0),(0,1),(0,2),(1,2)], [(0,0),(1,0),(2,0),(2,-1)]],
+    'L': [[(0,2),(1,0),(1,1),(1,2)], [(0,0),(1,0),(2,0),(2,1)],
+           [(0,0),(0,1),(0,2),(1,0)], [(0,0),(0,1),(1,1),(2,1)]],
+}
+
+PIECE_COLORS = {'I': 1, 'O': 2, 'T': 3, 'S': 4, 'Z': 5, 'J': 6, 'L': 7}
+PIECE_NAMES = list(PIECES.keys())
+
+BOARD_W = 10
+BOARD_H = 20
+
+
+def main(stdscr):
+    curses.curs_set(0)
+    stdscr.nodelay(True)
+    curses.start_color()
+    curses.use_default_colors()
+    curses.init_pair(1, curses.COLOR_CYAN, -1)      # I
+    curses.init_pair(2, curses.COLOR_YELLOW, -1)     # O
+    curses.init_pair(3, curses.COLOR_MAGENTA, -1)    # T
+    curses.init_pair(4, curses.COLOR_GREEN, -1)      # S
+    curses.init_pair(5, curses.COLOR_RED, -1)        # Z
+    curses.init_pair(6, curses.COLOR_BLUE, -1)       # J
+    curses.init_pair(7, curses.COLOR_WHITE, -1)      # L
+    curses.init_pair(8, curses.COLOR_WHITE, -1)      # border/text
+    init_notify_colors()
+
+    def new_bag():
+        bag = list(PIECE_NAMES)
+        random.shuffle(bag)
+        return bag
+
+    def play_game():
+        board = [[0] * BOARD_W for _ in range(BOARD_H)]
+        board_colors = [[0] * BOARD_W for _ in range(BOARD_H)]
+
+        bag = new_bag()
+        next_bag = new_bag()
+        score = 0
+        lines = 0
+        level = 1
+        game_over = False
+        paused = False
+        notify_timer = 0
+
+        def next_piece_name():
+            nonlocal bag, next_bag
+            if not bag:
+                bag = next_bag
+                next_bag = new_bag()
+            return bag.pop()
+
+        cur_name = next_piece_name()
+        nxt_name = next_piece_name()
+        cur_rot = 0
+        cur_r = 0
+        cur_c = BOARD_W // 2 - 1
+
+        drop_timer = 0.0
+        last_time = time.time()
+
+        def get_cells(name, rot, r, c):
+            shape = PIECES[name][rot % len(PIECES[name])]
+            return [(r + dr, c + dc) for dr, dc in shape]
+
+        def fits(name, rot, r, c):
+            for cr, cc in get_cells(name, rot, r, c):
+                if cr < 0 or cr >= BOARD_H or cc < 0 or cc >= BOARD_W:
+                    return False
+                if board[cr][cc]:
+                    return False
+            return True
+
+        def lock_piece():
+            nonlocal score, lines, level, game_over, cur_name, nxt_name, cur_rot, cur_r, cur_c
+            color = PIECE_COLORS[cur_name]
+            for cr, cc in get_cells(cur_name, cur_rot, cur_r, cur_c):
+                if cr < 0:
+                    game_over = True
+                    return
+                board[cr][cc] = 1
+                board_colors[cr][cc] = color
+
+            # Clear lines
+            cleared = 0
+            r = BOARD_H - 1
+            while r >= 0:
+                if all(board[r]):
+                    del board[r]
+                    del board_colors[r]
+                    board.insert(0, [0] * BOARD_W)
+                    board_colors.insert(0, [0] * BOARD_W)
+                    cleared += 1
+                else:
+                    r -= 1
+
+            if cleared > 0:
+                lines += cleared
+                points = [0, 100, 300, 500, 800]
+                score += points[min(cleared, 4)] * level
+                level = lines // 10 + 1
+
+            # Spawn next
+            cur_name = nxt_name
+            nxt_name = next_piece_name()
+            cur_rot = 0
+            cur_r = 0
+            cur_c = BOARD_W // 2 - 1
+            if not fits(cur_name, cur_rot, cur_r, cur_c):
+                game_over = True
+
+        def ghost_y():
+            gy = cur_r
+            while fits(cur_name, cur_rot, gy + 1, cur_c):
+                gy += 1
+            return gy
+
+        while True:
+            now = time.time()
+            dt = now - last_time
+            last_time = now
+
+            # Input
+            key = stdscr.getch()
+            while True:
+                k2 = stdscr.getch()
+                if k2 == -1:
+                    break
+                key = k2
+
+            if key in (ord('q'), ord('Q')):
+                return False
+
+            if game_over:
+                if key in (ord(' '), curses.KEY_ENTER, 10, 13):
+                    return True
+                height, width = stdscr.getmaxyx()
+                stdscr.erase()
+                msgs = ["GAME OVER!", f"Score: {score}  Lines: {lines}  Level: {level}",
+                        "SPACE to restart  Q to quit"]
+                cy = height // 2 - 1
+                for i, msg in enumerate(msgs):
+                    attr = curses.color_pair(5) | curses.A_BOLD if i == 0 else curses.color_pair(8)
+                    try:
+                        stdscr.addstr(cy + i, max(0, (width - len(msg)) // 2), msg, attr)
+                    except curses.error:
+                        pass
+                stdscr.refresh()
+                time.sleep(0.05)
+                continue
+
+            if key == ord('p') or key == ord('P'):
+                paused = not paused
+
+            if not paused:
+                if key == curses.KEY_LEFT and fits(cur_name, cur_rot, cur_r, cur_c - 1):
+                    cur_c -= 1
+                elif key == curses.KEY_RIGHT and fits(cur_name, cur_rot, cur_r, cur_c + 1):
+                    cur_c += 1
+                elif key == curses.KEY_UP:
+                    new_rot = (cur_rot + 1) % len(PIECES[cur_name])
+                    if fits(cur_name, new_rot, cur_r, cur_c):
+                        cur_rot = new_rot
+                    elif fits(cur_name, new_rot, cur_r, cur_c - 1):
+                        cur_c -= 1
+                        cur_rot = new_rot
+                    elif fits(cur_name, new_rot, cur_r, cur_c + 1):
+                        cur_c += 1
+                        cur_rot = new_rot
+                elif key == curses.KEY_DOWN:
+                    if fits(cur_name, cur_rot, cur_r + 1, cur_c):
+                        cur_r += 1
+                        score += 1
+                elif key == ord(' '):
+                    while fits(cur_name, cur_rot, cur_r + 1, cur_c):
+                        cur_r += 1
+                        score += 2
+                    lock_piece()
+
+                if check_task_done():
+                    notify_timer = 80
+
+                # Gravity
+                drop_speed = max(0.05, 0.5 - (level - 1) * 0.04)
+                drop_timer += dt
+                if drop_timer >= drop_speed:
+                    drop_timer = 0
+                    if fits(cur_name, cur_rot, cur_r + 1, cur_c):
+                        cur_r += 1
+                    else:
+                        lock_piece()
+
+            # Draw
+            height, width = stdscr.getmaxyx()
+            stdscr.erase()
+
+            # Board position
+            bx = max(0, (width - BOARD_W * 2 - 2) // 2 - 5)
+            by = max(0, (height - BOARD_H - 2) // 2)
+
+            # Title
+            title = "CLAUDE TETRIS"
+            try:
+                stdscr.addstr(0, max(0, (width - len(title)) // 2), title,
+                              curses.color_pair(1) | curses.A_BOLD)
+            except curses.error:
+                pass
+
+            # Board border
+            for r in range(BOARD_H + 2):
+                y = by + r
+                if y >= height:
+                    break
+                if r == 0 or r == BOARD_H + 1:
+                    line = "+" + "--" * BOARD_W + "+"
+                    try:
+                        stdscr.addstr(y, bx, line, curses.color_pair(8) | curses.A_DIM)
+                    except curses.error:
+                        pass
+                else:
+                    try:
+                        stdscr.addstr(y, bx, "|", curses.color_pair(8) | curses.A_DIM)
+                        stdscr.addstr(y, bx + BOARD_W * 2 + 1, "|", curses.color_pair(8) | curses.A_DIM)
+                    except curses.error:
+                        pass
+
+            # Board cells
+            for r in range(BOARD_H):
+                for c in range(BOARD_W):
+                    if board[r][c]:
+                        y = by + r + 1
+                        x = bx + 1 + c * 2
+                        if 0 <= y < height and 0 <= x < width - 1:
+                            try:
+                                stdscr.addstr(y, x, "[]",
+                                              curses.color_pair(board_colors[r][c]) | curses.A_BOLD)
+                            except curses.error:
+                                pass
+
+            if not game_over:
+                # Ghost piece
+                gy = ghost_y()
+                for gr, gc in get_cells(cur_name, cur_rot, gy, cur_c):
+                    y = by + gr + 1
+                    x = bx + 1 + gc * 2
+                    if 0 <= y < height and 0 <= x < width - 1 and 0 <= gr < BOARD_H:
+                        try:
+                            stdscr.addstr(y, x, "..", curses.color_pair(8) | curses.A_DIM)
+                        except curses.error:
+                            pass
+
+                # Current piece
+                color = PIECE_COLORS[cur_name]
+                for cr, cc in get_cells(cur_name, cur_rot, cur_r, cur_c):
+                    y = by + cr + 1
+                    x = bx + 1 + cc * 2
+                    if 0 <= y < height and 0 <= x < width - 1 and cr >= 0:
+                        try:
+                            stdscr.addstr(y, x, "[]", curses.color_pair(color) | curses.A_BOLD)
+                        except curses.error:
+                            pass
+
+            # Side panel
+            sx = bx + BOARD_W * 2 + 4
+            sy = by + 1
+
+            info = [
+                ("SCORE", str(score)),
+                ("LINES", str(lines)),
+                ("LEVEL", str(level)),
+            ]
+            for i, (label, val) in enumerate(info):
+                y = sy + i * 2
+                if y < height:
+                    try:
+                        stdscr.addstr(y, sx, label, curses.color_pair(8) | curses.A_DIM)
+                        stdscr.addstr(y + 1, sx, val, curses.color_pair(2) | curses.A_BOLD)
+                    except curses.error:
+                        pass
+
+            # Next piece
+            ny = sy + 7
+            try:
+                stdscr.addstr(ny, sx, "NEXT", curses.color_pair(8) | curses.A_DIM)
+            except curses.error:
+                pass
+            nxt_color = PIECE_COLORS[nxt_name]
+            for dr, dc in PIECES[nxt_name][0]:
+                y = ny + 1 + dr
+                x = sx + dc * 2
+                if 0 <= y < height and 0 <= x < width - 1:
+                    try:
+                        stdscr.addstr(y, x, "[]", curses.color_pair(nxt_color) | curses.A_BOLD)
+                    except curses.error:
+                        pass
+
+            # Controls
+            ctrl_y = ny + 5
+            controls = ["<- -> Move", "UP   Rotate", "DOWN Soft drop", "SPACE Hard drop",
+                        "P    Pause", "Q    Quit"]
+            for i, c in enumerate(controls):
+                if ctrl_y + i < height:
+                    try:
+                        stdscr.addstr(ctrl_y + i, sx, c, curses.color_pair(8) | curses.A_DIM)
+                    except curses.error:
+                        pass
+
+            if paused:
+                msg = "  PAUSED - P to resume  "
+                try:
+                    stdscr.addstr(height // 2, max(0, (width - len(msg)) // 2),
+                                  msg, curses.color_pair(2) | curses.A_BOLD)
+                except curses.error:
+                    pass
+
+            notify_timer = draw_notification(stdscr, height, width, notify_timer)
+            stdscr.refresh()
+            time.sleep(0.05)
+
+    while True:
+        result = play_game()
+        if not result:
+            break
+
+
+def run():
+    curses.wrapper(main)
+
+if __name__ == "__main__":
+    run()