claude-games 1.0.0

package/README.md

@@ -0,0 +1,51 @@
+# Claude Games 🎮
+
+Terminal arcade games to play while [Claude Code](https://claude.ai/claude-code) works on your tasks.
+
+## Install
+
+```bash
+npm install -g claude-games
+```
+
+## Usage
+
+In Claude Code, type:
+
+```
+/games
+```
+
+Or launch a specific game:
+
+```
+/games tetris
+/games pacman
+/games snake
+```
+
+## Games
+
+| Game | Description |
+|------|-------------|
+| Crab Runner | Chrome dino-style endless runner |
+| 2048 | Slide and merge tiles |
+| Pac-Man | Classic dot-eating maze game |
+| ASCII Patrol | Side-scrolling space shooter |
+| Hogwarts Duels | Harry Potter spell-casting adventure |
+| Pokemon Battle | Choose your starter and battle to become Champion |
+| Tetris | Classic block-stacking puzzler |
+| Snake | Eat food, grow long, don't bite yourself |
+| Wordle | Guess the 5-letter word in 6 tries |
+| Space Invaders | Defend Earth from alien waves |
+| Hangman | Guess the programming word |
+
+## Requirements
+
+- Python 3 (for the game engines)
+- A terminal that supports curses (most do)
+- Claude Code
+
+## How it works
+
+`npm install -g` copies game files to `~/.claude/games/` and registers a `/games` slash command in `~/.claude/commands/`. The games run in a tmux split pane, iTerm2 split, or new Terminal window depending on your environment.

package/command.md

@@ -0,0 +1,19 @@
+---
+description: Play terminal games while Claude works (crab-runner, 2048, pacman, ascii-patrol, hogwarts-duels, pokemon-battle, tetris, snake, wordle, invaders, hangman)
+argument-hint: [game-name]
+allowed-tools: [Bash]
+---
+
+Launch the Claude Games Arcade immediately with a SINGLE background bash command — do not wait, do not use multiple steps.
+
+If `$ARGUMENTS` is provided, pass it as the game name argument. Otherwise launch the game menu.
+
+Run this ONE command with run_in_background=true:
+```bash
+bash "$HOME/.claude/games/launch.sh" "$ARGUMENTS"
+```
+
+After triggering, immediately respond with exactly one short sentence:
+- If no argument: tell the user the games arcade is opening in a new pane/tab and they can pick a game.
+- If argument provided: tell them the game is launching.
+Add: "Controls shown in-game. Press Q to quit anytime." Nothing else. Do NOT wait for the background task to complete.

package/games/2048.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""2048 – Slide and merge tiles to reach 2048!"""
+import curses
+import random
+
+def main(stdscr):
+    curses.curs_set(0)
+    curses.start_color()
+    curses.use_default_colors()
+    curses.init_pair(1, curses.COLOR_WHITE,   -1)
+    curses.init_pair(2, curses.COLOR_YELLOW,  -1)
+    curses.init_pair(3, curses.COLOR_GREEN,   -1)
+    curses.init_pair(4, curses.COLOR_CYAN,    -1)
+    curses.init_pair(5, curses.COLOR_BLUE,    -1)
+    curses.init_pair(6, curses.COLOR_MAGENTA, -1)
+    curses.init_pair(7, curses.COLOR_RED,     -1)
+
+    TILE_COLOR = {
+        0:    curses.color_pair(1) | curses.A_DIM,
+        2:    curses.color_pair(2),
+        4:    curses.color_pair(2) | curses.A_BOLD,
+        8:    curses.color_pair(3),
+        16:   curses.color_pair(3) | curses.A_BOLD,
+        32:   curses.color_pair(4),
+        64:   curses.color_pair(4) | curses.A_BOLD,
+        128:  curses.color_pair(5) | curses.A_BOLD,
+        256:  curses.color_pair(6),
+        512:  curses.color_pair(6) | curses.A_BOLD,
+        1024: curses.color_pair(7),
+        2048: curses.color_pair(7) | curses.A_BOLD,
+    }
+
+    def tile_color(v):
+        return TILE_COLOR.get(v, curses.color_pair(7) | curses.A_BOLD)
+
+    def new_board():
+        b = [[0]*4 for _ in range(4)]
+        spawn(b); spawn(b)
+        return b
+
+    def spawn(b):
+        empty = [(r, c) for r in range(4) for c in range(4) if b[r][c] == 0]
+        if empty:
+            r, c = random.choice(empty)
+            b[r][c] = 4 if random.random() < 0.1 else 2
+
+    def slide(row):
+        tiles = [x for x in row if x]
+        merged, pts = [], 0
+        i = 0
+        while i < len(tiles):
+            if i + 1 < len(tiles) and tiles[i] == tiles[i+1]:
+                val = tiles[i] * 2
+                merged.append(val)
+                pts += val
+                i += 2
+            else:
+                merged.append(tiles[i])
+                i += 1
+        merged += [0] * (4 - len(merged))
+        return merged, pts
+
+    def do_move(b, d):
+        nb = [r[:] for r in b]
+        pts = 0
+        moved = False
+        if d == 'L':
+            for r in range(4):
+                nr, s = slide(nb[r])
+                if nr != nb[r]: moved = True
+                nb[r] = nr; pts += s
+        elif d == 'R':
+            for r in range(4):
+                rev, s = slide(nb[r][::-1])
+                nr = rev[::-1]
+                if nr != nb[r]: moved = True
+                nb[r] = nr; pts += s
+        elif d == 'U':
+            for c in range(4):
+                col = [nb[r][c] for r in range(4)]
+                nc, s = slide(col)
+                for r in range(4):
+                    if nb[r][c] != nc[r]: moved = True
+                    nb[r][c] = nc[r]
+                pts += s
+        elif d == 'D':
+            for c in range(4):
+                col = [nb[r][c] for r in range(4)][::-1]
+                ncr, s = slide(col)
+                nc = ncr[::-1]
+                for r in range(4):
+                    if nb[r][c] != nc[r]: moved = True
+                    nb[r][c] = nc[r]
+                pts += s
+        return nb, pts, moved
+
+    def is_over(b):
+        for r in range(4):
+            for c in range(4):
+                if b[r][c] == 0: return False
+                if c < 3 and b[r][c] == b[r][c+1]: return False
+                if r < 3 and b[r][c] == b[r+1][c]: return False
+        return True
+
+    def has_won(b):
+        return any(b[r][c] >= 2048 for r in range(4) for c in range(4))
+
+    CW, CH = 7, 3  # cell width / height
+
+    def draw(b, score, best, over, won):
+        H, W = stdscr.getmaxyx()
+        stdscr.erase()
+
+        # ── Title ──────────────────────────────────────────────
+        title = "  ╔══╗ ╔═══╗ ╔══╗ ╔═══╗  "
+        sub   = "  ║    ║   ║ ╠══╣ ║   ║  "
+        sub2  = "  ╚══╝ ╚═══╝ ║  ║ ╚═══╝  "
+        big = " 2  0  4  8 "
+        try:
+            stdscr.addstr(0, max(0, (W - len(big)) // 2), big,
+                          curses.color_pair(7) | curses.A_BOLD)
+        except curses.error:
+            pass
+
+        sc_str = f"Score: {score:7d}   Best: {best:7d}"
+        try:
+            stdscr.addstr(1, max(0, (W - len(sc_str)) // 2), sc_str,
+                          curses.color_pair(2))
+        except curses.error:
+            pass
+
+        # ── Grid ───────────────────────────────────────────────
+        bw = 4 * CW + 5
+        sx = max(0, (W - bw) // 2)
+        sy = 3
+
+        # Horizontal lines
+        for row in range(5):
+            y = sy + row * (CH + 1)
+            l = "┌" if row == 0 else ("└" if row == 4 else "├")
+            r = "┐" if row == 0 else ("┘" if row == 4 else "┤")
+            m = "┬" if row == 0 else ("┴" if row == 4 else "┼")
+            seg = "─" * CW
+            line = l + (seg + m) * 3 + seg + r
+            try:
+                stdscr.addstr(y, sx, line, curses.color_pair(1) | curses.A_DIM)
+            except curses.error:
+                pass
+
+        # Cell content + vertical separators
+        for row in range(4):
+            for line in range(CH):
+                y = sy + row * (CH + 1) + 1 + line
+                try:
+                    stdscr.addstr(y, sx, "│", curses.color_pair(1) | curses.A_DIM)
+                except curses.error:
+                    pass
+                for col in range(4):
+                    x = sx + 1 + col * (CW + 1)
+                    val = b[row][col]
+                    color = tile_color(val)
+                    if line == CH // 2:
+                        text = (str(val) if val else "·").center(CW)
+                    else:
+                        text = " " * CW
+                    try:
+                        stdscr.addstr(y, x, text, color)
+                        stdscr.addstr(y, x + CW, "│", curses.color_pair(1) | curses.A_DIM)
+                    except curses.error:
+                        pass
+
+        # ── Status bar ─────────────────────────────────────────
+        bot = sy + 4 * (CH + 1) + 1
+        if over:
+            msg = "GAME OVER!   R = restart   Q = quit"
+            try:
+                stdscr.addstr(bot, max(0, (W - len(msg)) // 2), msg,
+                              curses.color_pair(7) | curses.A_BOLD)
+            except curses.error:
+                pass
+        elif won:
+            msg = "YOU WIN! 🎉  Keep going or R = restart   Q = quit"
+            try:
+                stdscr.addstr(bot, max(0, (W - len(msg)) // 2), msg,
+                              curses.color_pair(3) | curses.A_BOLD)
+            except curses.error:
+                pass
+        else:
+            hint = "← → ↑ ↓  slide    R restart    Q quit"
+            try:
+                stdscr.addstr(bot, max(0, (W - len(hint)) // 2), hint,
+                              curses.color_pair(1) | curses.A_DIM)
+            except curses.error:
+                pass
+
+        stdscr.refresh()
+
+    # ── Game loop ──────────────────────────────────────────────
+    board = new_board()
+    score = 0
+    best = 0
+    over = False
+    won = False
+    keep_going = False
+
+    while True:
+        draw(board, score, best, over, won and not keep_going)
+        key = stdscr.getch()
+
+        if key in (ord('q'), ord('Q')):
+            break
+        if key in (ord('r'), ord('R')):
+            board = new_board(); score = 0
+            over = False; won = False; keep_going = False
+            continue
+        if key in (ord('c'), ord('C')) and won:
+            keep_going = True
+        if over:
+            continue
+
+        d = None
+        if   key == curses.KEY_LEFT:  d = 'L'
+        elif key == curses.KEY_RIGHT: d = 'R'
+        elif key == curses.KEY_UP:    d = 'U'
+        elif key == curses.KEY_DOWN:  d = 'D'
+
+        if d:
+            nb, pts, moved = do_move(board, d)
+            if moved:
+                board = nb
+                score += pts
+                if score > best: best = score
+                spawn(board)
+                if not keep_going and has_won(board): won = True
+                if is_over(board): over = True
+
+
+if __name__ == "__main__":
+    curses.wrapper(main)

package/games/dino.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""Claude Crab Runner - Play while Claude Code runs!"""
+import curses
+import random
+import time
+from notify import init_notify_colors, check_task_done, draw_notification
+
+def main(stdscr):
+    curses.curs_set(0)
+    stdscr.nodelay(True)
+    curses.start_color()
+    # Try to set a terracotta/orange color for the crab
+    if curses.can_change_color() and curses.COLORS >= 256:
+        curses.init_color(16, 800, 480, 360)  # terracotta
+        curses.init_pair(1, 16, curses.COLOR_BLACK)
+    else:
+        curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)    # crab (fallback)
+    curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK)     # cactus
+    curses.init_pair(3, curses.COLOR_YELLOW, curses.COLOR_BLACK)  # score
+    curses.init_pair(4, curses.COLOR_CYAN, curses.COLOR_BLACK)    # clouds
+    init_notify_colors()
+
+    height, width = stdscr.getmaxyx()
+    ground_y = height - 4
+    crab_x = 8
+
+    # Game state
+    crab_y = ground_y
+    vel_y = 0.0
+    is_jumping = False
+    is_ducking = False
+    duck_frames = 0
+    score = 0
+    high_score = 0
+    game_speed = 1.5
+    game_over = False
+    started = False
+    paused = False
+    frame = 0
+    notify_timer = 0
+    scroll_acc = 0.0
+
+    obstacles = []
+    clouds = [[width - 10, ground_y - 6], [width - 30, ground_y - 8]]
+    particles = []
+
+    # Claude crab sprites – pixel-art matching claudecode-color.png icon
+    # Wide body, two square eye-holes, 4 stubby legs
+    CRAB_RUN1 = [
+        "▄▄▄▄▄▄▄▄",
+        "█ ▄  ▄ █",
+        "█ ▀  ▀ █",
+        "████████",
+        "▌▌    ▐▐",
+    ]
+    CRAB_RUN2 = [
+        "▄▄▄▄▄▄▄▄",
+        "█ ▄  ▄ █",
+        "█ ▀  ▀ █",
+        "████████",
+        " ▌▌  ▐▐ ",
+    ]
+    CRAB_DUCK = [
+        "▄▄▄▄▄▄▄▄",
+        "█ ▄  ▄ █",
+        "█ ▀  ▀ █",
+        "████████",
+    ]
+
+    CACTUS_SMALL  = [" ▐█▌ ", " ███ ", "─███─"]
+    CACTUS_TALL   = [" ▐█▌ ", " ███ ", " ███ ", "─███─"]
+    CACTUS_DOUBLE = [" ▐█▌▐█▌", " ███████", " ███████", "─███████"]
+
+    CLOUD = "☁ ☁ ☁"
+
+    obstacle_types = [CACTUS_SMALL, CACTUS_TALL, CACTUS_DOUBLE]
+    obs_heights    = [3, 4, 3]
+    obs_widths     = [5, 5, 8]
+
+    next_obs_dist = random.randint(40, 70)
+    obs_timer = 0
+
+    FRAME_TIME = 0.05   # 20 fps
+    GRAVITY    = 0.7
+    JUMP_VEL   = -5.5
+    SPRITE_H   = 5      # rows tall
+    SPRITE_H_DUCK = 4   # rows tall when ducking
+
+    def draw_crab(y, x, f, ducking):
+        sprite = CRAB_DUCK if ducking else (CRAB_RUN1 if f % 2 == 0 else CRAB_RUN2)
+        sh = len(sprite)
+        for i, line in enumerate(sprite):
+            row = y - sh + i + 1
+            if 0 <= row < height and 0 <= x < width - len(line):
+                try:
+                    stdscr.addstr(row, x, line, curses.color_pair(1) | curses.A_BOLD)
+                except curses.error:
+                    pass
+
+    def draw_obstacle(obs):
+        ox, otype = obs
+        sprite = obstacle_types[otype]
+        oh = obs_heights[otype]
+        for i, line in enumerate(sprite):
+            row = ground_y - oh + i + 1
+            if 0 <= row < height and 0 <= ox < width - len(line):
+                try:
+                    stdscr.addstr(row, ox, line, curses.color_pair(2) | curses.A_BOLD)
+                except curses.error:
+                    pass
+
+    def check_collision(cy, cx, obs_list):
+        sh = SPRITE_H_DUCK if is_ducking else SPRITE_H
+        c_top   = cy - (sh - 1)
+        c_bot   = cy
+        c_left  = cx + 1
+        c_right = cx + 6
+        for obs in obs_list:
+            ox, otype = obs
+            oh = obs_heights[otype]
+            ow = obs_widths[otype]
+            o_top   = ground_y - oh + 1
+            o_bot   = ground_y
+            o_left  = ox
+            o_right = ox + ow - 1
+            if (c_right >= o_left + 1 and c_left <= o_right - 1 and
+                    c_bot >= o_top and c_top <= o_bot):
+                return True
+        return False
+
+    def draw_title_screen():
+        stdscr.erase()
+        try:
+            stdscr.addstr(ground_y + 1, 0, "─" * (width - 1))
+        except curses.error:
+            pass
+        title    = "🦀  CLAUDE CRAB RUNNER  🦀"
+        subtitle = "SPACE / ↑ to start & jump   ↓ to duck   Q to quit"
+        try:
+            stdscr.addstr(height // 2 - 3, max(0, (width - len(title)) // 2), title,
+                          curses.color_pair(1) | curses.A_BOLD)
+            stdscr.addstr(height // 2 - 1, max(0, (width - len(subtitle)) // 2), subtitle,
+                          curses.color_pair(3))
+        except curses.error:
+            pass
+        if game_over:
+            msgs = [
+                ("GAME OVER",         curses.color_pair(2) | curses.A_BOLD),
+                (f"High Score: {high_score}", curses.color_pair(3)),
+                ("Press SPACE to restart",    curses.color_pair(4)),
+            ]
+            for offset, (msg, attr) in enumerate(msgs, 1):
+                try:
+                    stdscr.addstr(height // 2 + offset, max(0, (width - len(msg)) // 2), msg, attr)
+                except curses.error:
+                    pass
+        draw_crab(ground_y, crab_x, 0, False)
+        stdscr.refresh()
+
+    while True:
+        frame_start = time.time()
+
+        # --- Input: drain buffer, keep last key ---
+        key = stdscr.getch()
+        k2 = key
+        while k2 != -1:
+            k2 = stdscr.getch()
+            if k2 != -1:
+                key = k2
+
+        if key in (ord('q'), ord('Q')):
+            break
+
+        if key in (ord('p'), ord('P')) and started and not game_over:
+            paused = not paused
+
+        if paused:
+            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(FRAME_TIME)
+            continue
+
+        if key in (ord(' '), curses.KEY_UP):
+            if not started:
+                started = True
+                game_over = False
+            elif game_over:
+                crab_y = ground_y
+                vel_y = 0.0
+                is_jumping = False
+                is_ducking = False
+                duck_frames = 0
+                obstacles.clear()
+                obs_timer = 0
+                next_obs_dist = random.randint(40, 70)
+                score = 0
+                game_speed = 1.5
+                game_over = False
+                frame = 0
+                scroll_acc = 0.0
+            elif not is_jumping:
+                vel_y = JUMP_VEL
+                is_jumping = True
+                particles.append([crab_x + 3, crab_y, 4])
+
+        # Duck: extend timer on each DOWN keypress; auto-expires
+        if key == curses.KEY_DOWN:
+            duck_frames = max(duck_frames, 8)
+        if duck_frames > 0:
+            is_ducking = True
+            duck_frames -= 1
+        else:
+            is_ducking = False
+
+        if check_task_done():
+            notify_timer = 80  # 4 seconds at 20fps
+
+        if not started or game_over:
+            draw_title_screen()
+            time.sleep(FRAME_TIME)
+            continue
+
+        # --- Physics ---
+        vel_y += GRAVITY
+        crab_y += vel_y
+        if crab_y >= ground_y:
+            crab_y = ground_y
+            vel_y = 0.0
+            is_jumping = False
+
+        # --- Scroll ---
+        scroll_acc += game_speed
+        scroll = int(scroll_acc)
+        scroll_acc -= scroll
+
+        obs_timer += scroll
+        for obs in obstacles:
+            obs[0] -= scroll
+        obstacles = [o for o in obstacles if o[0] > -10]
+
+        if obs_timer >= next_obs_dist:
+            obs_timer = 0
+            next_obs_dist = random.randint(35, 60)
+            obstacles.append([width - 2, random.randint(0, 2)])
+
+        for cloud in clouds:
+            if frame % 2 == 0:
+                cloud[0] -= max(1, scroll // 2)
+            if cloud[0] < -len(CLOUD):
+                cloud[0] = width + random.randint(5, 20)
+                cloud[1] = ground_y - random.randint(5, 10)
+
+        for p in particles:
+            p[0] += random.randint(-1, 1)
+            p[1] += 1
+            p[2] -= 1
+        particles[:] = [p for p in particles if p[2] > 0]
+
+        score += 1
+        if score > high_score:
+            high_score = score
+        game_speed = min(4.0, 1.5 + score / 800)
+
+        if check_collision(int(crab_y), crab_x, obstacles):
+            game_over = True
+
+        # --- Draw ---
+        stdscr.erase()
+
+        for cloud in clouds:
+            if 0 <= cloud[1] < height and 0 <= cloud[0] < width - len(CLOUD):
+                try:
+                    stdscr.addstr(cloud[1], cloud[0], CLOUD, curses.color_pair(4))
+                except curses.error:
+                    pass
+
+        try:
+            stdscr.addstr(ground_y + 1, 0, "─" * (width - 1))
+            dot_offset = (frame * scroll) % 6
+            ground_detail = "".join("·" if (i + dot_offset) % 6 == 0 else " " for i in range(width - 1))
+            stdscr.addstr(ground_y + 2, 0, ground_detail)
+        except curses.error:
+            pass
+
+        for p in particles:
+            if 0 <= p[1] < height and 0 <= p[0] < width:
+                try:
+                    stdscr.addstr(p[1], p[0], "·", curses.color_pair(3))
+                except curses.error:
+                    pass
+
+        for obs in obstacles:
+            draw_obstacle(obs)
+
+        draw_crab(int(crab_y), crab_x, frame, is_ducking)
+
+        score_str = f"SCORE: {score:05d}  HI: {high_score:05d}"
+        controls  = "↑/SPACE jump  ↓ duck  P pause  Q quit"
+        try:
+            stdscr.addstr(0, max(0, (width - len(score_str)) // 2), score_str,
+                          curses.color_pair(3) | curses.A_BOLD)
+            stdscr.addstr(0, 1, controls, curses.color_pair(4))
+        except curses.error:
+            pass
+
+        notify_timer = draw_notification(stdscr, height, width, notify_timer)
+        stdscr.refresh()
+        frame += 1
+
+        elapsed = time.time() - frame_start
+        sleep_t = FRAME_TIME - elapsed
+        if sleep_t > 0:
+            time.sleep(sleep_t)
+
+def run():
+    curses.wrapper(main)
+
+if __name__ == "__main__":
+    run()