Terminal-Screensaver: dino.py (Chrome-Dino-Runner) und pacman.py (Pac-Man-Screensaver) hinzugefuegt

pacman.py

@@ -0,0 +1,533 @@
+#!/usr/bin/env python3
+"""pacman: Pac-Man ASCII screensaver with maze. Press any key to exit.
+No external dependencies -- pure ANSI escape codes, no Curses.
+"""
+
+import os, sys, tty, termios, fcntl, signal, time, random, shutil, argparse
+from typing import List, Optional, Set, Tuple
+
+# ── Terminal control ──────────────────────────────────────────────────────────
+RESET    = "\033[0m"
+HIDE_CUR = "\033[?25l"
+SHOW_CUR = "\033[?25h"
+ALT_ON   = "\033[?1049h"
+ALT_OFF  = "\033[?1049l"
+
+def _fg(r, g, b): return f"\033[38;2;{r};{g};{b}m"
+def _go(r, c):    return f"\033[{r+1};{c+1}H"
+def term_size():  s = shutil.get_terminal_size(); return s.lines, s.columns
+
+def _write_all(fd: int, data: bytes) -> None:
+    mv = memoryview(data)
+    off = 0
+    while off < len(mv):
+        try:
+            off += os.write(fd, mv[off:])
+        except BlockingIOError:
+            time.sleep(0.001)
+
+# ── Colors ────────────────────────────────────────────────────────────────────
+C_WALL   = _fg( 30,  60, 255)   # classic Pac-Man blue
+C_PAC    = _fg(255, 255,   0)   # yellow
+C_DOT    = _fg(255, 220, 180)   # cream
+C_PILL   = _fg(255, 220, 180)
+C_SCORE  = _fg(180, 180, 255)
+C_SCARED = _fg( 20,  20, 200)
+C_SCARE2 = _fg(200, 200, 255)   # flashing near end
+
+GHOST_COLORS = [
+    _fg(255,  40,  40),   # Blinky – red
+    _fg(255, 170, 200),   # Pinky  – pink
+    _fg( 30, 210, 255),   # Inky   – cyan
+    _fg(255, 175,  80),   # Clyde  – orange
+]
+
+# ── Maze definition ───────────────────────────────────────────────────────────
+# 28 cols × 14 rows. # = wall, . = dot, * = power pellet
+MAZE = [
+    "############################",
+    "#............##............#",
+    "#.####.#####.##.#####.####.#",
+    "#*####.#####.##.#####.####*#",
+    "#.####.#####.##.#####.####.#",
+    "#..........................#",
+    "#.####.##.########.##.####.#",
+    "#......##....##....##......#",
+    "#.####.##.########.##.####.#",
+    "#..........................#",
+    "#.####.#####.##.#####.####.#",
+    "#*####.#####.##.#####.####*#",
+    "#............##............#",
+    "############################",
+]
+MAZE_H = len(MAZE)    # 14
+MAZE_W = len(MAZE[0]) # 28
+
+# Box-drawing lookup: (N, S, W, E) → character
+# Each wall cell gets the char that shows which sides connect to other walls.
+_BOX: dict = {
+    (False,False,False,False): '·',
+    (True, False,False,False): '╵',
+    (False,True, False,False): '╷',
+    (True, True, False,False): '│',
+    (False,False,True, False): '╴',
+    (False,False,False,True ): '╶',
+    (False,False,True, True ): '─',
+    (True, False,True, False): '┘',
+    (True, False,False,True ): '└',
+    (False,True, True, False): '┐',
+    (False,True, False,True ): '┌',
+    (True, True, True, False): '┤',
+    (True, True, False,True ): '├',
+    (True, False,True, True ): '┴',
+    (False,True, True, True ): '┬',
+    (True, True, True, True ): '┼',
+}
+
+# ── Movement helpers ──────────────────────────────────────────────────────────
+DIRS  = ['R', 'L', 'U', 'D']
+DELTA = {'R': (0, 1), 'L': (0, -1), 'U': (-1, 0), 'D': (1, 0)}
+
+def is_wall(mr: int, mc: int) -> bool:
+    if 0 <= mr < MAZE_H and 0 <= mc < MAZE_W:
+        return MAZE[mr][mc] == '#'
+    return True
+
+def valid_dirs(mr: int, mc: int, exclude: Optional[str] = None) -> List[str]:
+    return [d for d in DIRS
+            if d != exclude
+            and not is_wall(mr + DELTA[d][0], mc + DELTA[d][1])]
+
+def try_move(mr: int, mc: int, d: str) -> Tuple[int, int, bool]:
+    dr, dc = DELTA[d]
+    nmr, nmc = mr + dr, mc + dc
+    if is_wall(nmr, nmc):
+        return mr, mc, False
+    return nmr, nmc, True
+
+# ── Sprite generators ─────────────────────────────────────────────────────────
+def make_pac(sw: int, sh: int, direction: str, frame: int) -> List[str]:
+    """Pac-Man sprite sw×sh using /\\ for the mouth wedge.
+    frame 0/1 = open, frame 2 = closed (full block).
+
+    At sw=4, sh=4 (user's design):
+      RIGHT open   LEFT open    UP open    DOWN open
+        ####         ####         #/\\#      ####
+        #  \\        /  #         ####       ####
+        #  /         \\  #        ####       #\\/#
+        ####         ####         ####       ####
+    """
+    W   = sw
+    mid = max(0, sw - 2)
+    arc = '#' * W
+    opn = (frame <= 1)
+
+    def right() -> List[str]:
+        rows = [arc] * sh
+        if opn:
+            if sh == 1:
+                rows[0] = '#' * (W - 1) + '>'
+            else:
+                hi = max(0, sh // 3)
+                lo = min(sh - 1, 2 * sh // 3)
+                if hi == lo and sh > 1:
+                    lo = min(hi + 1, sh - 1)
+                rows[hi] = '#' + ' ' * mid + '\\'
+                rows[lo] = '#' + ' ' * mid + '/'
+        return rows
+
+    def left() -> List[str]:
+        rows = [arc] * sh
+        if opn:
+            if sh == 1:
+                rows[0] = '<' + '#' * (W - 1)
+            else:
+                hi = max(0, sh // 3)
+                lo = min(sh - 1, 2 * sh // 3)
+                if hi == lo and sh > 1:
+                    lo = min(hi + 1, sh - 1)
+                rows[hi] = '/' + ' ' * mid + '#'
+                rows[lo] = '\\' + ' ' * mid + '#'
+        return rows
+
+    def up() -> List[str]:
+        rows = [arc] * sh
+        if opn:
+            mc = W // 2
+            r = list(arc)
+            if mc > 0:  r[mc - 1] = '/'
+            if mc < W:  r[mc]     = '\\'
+            for i in range(mc - 1):    r[i] = ' '
+            for i in range(mc + 1, W): r[i] = ' '
+            rows[0] = ''.join(r)
+        return rows
+
+    def down() -> List[str]:
+        rows = [arc] * sh
+        if opn:
+            mc = W // 2
+            r = list(arc)
+            if mc > 0:  r[mc - 1] = '\\'
+            if mc < W:  r[mc]     = '/'
+            for i in range(mc - 1):    r[i] = ' '
+            for i in range(mc + 1, W): r[i] = ' '
+            rows[-1] = ''.join(r)
+        return rows
+
+    return {'R': right, 'L': left, 'U': up, 'D': down}[direction]()
+
+
+def make_ghost(sw: int, sh: int, scared: bool, frame: int) -> List[str]:
+    """Ghost sprite sw×sh chars."""
+    mid = sw - 2
+
+    if sh == 1 or mid < 0:
+        return [('=' if scared else '&') * max(1, sw)]
+
+    eye_str = ('= =' if mid >= 5 else '==' if mid >= 2 else '=') if scared else \
+              ('o o' if mid >= 5 else 'oo' if mid >= 2 else 'o')
+    eyes = eye_str.center(mid)[:mid]
+
+    top   = '/' + '-' * mid + '\\'
+    body  = '|' + eyes + '|'
+    pat   = '/\\' if frame == 0 else '\\/'
+    skirt = (pat * (sw // 2 + 2))[:sw]
+
+    if sh == 2:
+        return [top, body]
+    else:
+        return [top, body, skirt]
+
+
+# ── Canvas ────────────────────────────────────────────────────────────────────
+class Canvas:
+    def __init__(self, rows: int, cols: int):
+        self.rows, self.cols = rows, cols
+        self._ch: List[List[str]]           = [[' '] * cols for _ in range(rows)]
+        self._ck: List[List[Optional[str]]] = [[None] * cols for _ in range(rows)]
+
+    def resize(self, rows: int, cols: int):
+        self.rows, self.cols = rows, cols
+        self._ch = [[' '] * cols for _ in range(rows)]
+        self._ck = [[None] * cols for _ in range(rows)]
+
+    def clear(self):
+        for r in range(self.rows):
+            self._ch[r] = [' '] * self.cols
+            self._ck[r] = [None] * self.cols
+
+    def put(self, row: int, col: int, ch: str, ck: Optional[str]):
+        if 0 <= row < self.rows and 0 <= col < self.cols:
+            self._ch[row][col] = ch
+            self._ck[row][col] = ck
+
+    def put_str(self, row: int, col: int, s: str, ck: Optional[str]):
+        for i, ch in enumerate(s):
+            self.put(row, col + i, ch, ck)
+
+    def fill_rect(self, row: int, col: int, h: int, w: int, ch: str, ck: Optional[str]):
+        for dr in range(h):
+            for dc in range(w):
+                self.put(row + dr, col + dc, ch, ck)
+
+    def put_sprite_solid(self, y: int, x: int, lines: List[str], ck: Optional[str]):
+        """Draw sprite; interior spaces are erased (opaque body)."""
+        for dy, line in enumerate(lines):
+            vis = [i for i, c in enumerate(line) if c not in (' ', '?')]
+            if not vis:
+                continue
+            lo, hi = vis[0], vis[-1]
+            for dx, ch in enumerate(line):
+                if ch in (' ', '?'):
+                    if lo < dx < hi:
+                        self.put(y + dy, x + dx, ' ', None)
+                else:
+                    self.put(y + dy, x + dx, ch, ck)
+
+    def render(self) -> str:
+        col_limit = self.cols - 1
+        parts = ["\033[H", RESET]
+        sentinel = object()
+        last_ck: object = sentinel
+        for r in range(self.rows):
+            parts.append(_go(r, 0))
+            for c in range(col_limit):
+                ck = self._ck[r][c]
+                if ck is not last_ck:
+                    parts.append(RESET if ck is None else ck)
+                    last_ck = ck
+                parts.append(self._ch[r][c])
+            parts.append(RESET + "\033[K")
+            last_ck = sentinel
+        parts.append(RESET)
+        return ''.join(parts)
+
+
+# ── Input ─────────────────────────────────────────────────────────────────────
+class Input:
+    def __init__(self):
+        self.fd = sys.stdin.fileno()
+        self._old = termios.tcgetattr(self.fd)
+        tty.setraw(self.fd)
+        fl = fcntl.fcntl(self.fd, fcntl.F_GETFL)
+        fcntl.fcntl(self.fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
+
+    def read(self) -> bytes:
+        try:
+            return os.read(self.fd, 32)
+        except (BlockingIOError, OSError):
+            return b''
+
+    def restore(self):
+        termios.tcsetattr(self.fd, termios.TCSADRAIN, self._old)
+
+
+# ── Entities ──────────────────────────────────────────────────────────────────
+class Ghost:
+    def __init__(self, mr: int, mc: int, color: str):
+        self.mr, self.mc   = mr, mc
+        self.color         = color
+        self.dir           = random.choice(valid_dirs(mr, mc) or ['R'])
+        self.frame         = 0
+        self.scared_ticks  = 0
+
+    def step(self):
+        nmr, nmc, ok = try_move(self.mr, self.mc, self.dir)
+        if ok:
+            self.mr, self.mc = nmr, nmc
+        # Turn randomly or when blocked
+        if not ok or random.random() < 0.07:
+            vd = valid_dirs(self.mr, self.mc)
+            if vd:
+                self.dir = random.choice(vd)
+        self.frame = (self.frame + 1) % 2
+        if self.scared_ticks > 0:
+            self.scared_ticks -= 1
+
+
+class Pacman:
+    def __init__(self, mr: int, mc: int):
+        self.mr, self.mc = mr, mc
+        self.dir         = 'R'
+        self.frame       = 0
+        self._fanim      = 1   # mouth open/close direction
+
+    def step(self, dots: Set[Tuple[int, int]],
+             pills: Set[Tuple[int, int]]) -> Tuple[int, int]:
+        """Move one step. Returns (score_delta, scared_bonus)."""
+        self.frame += self._fanim
+        if self.frame >= 2:
+            self._fanim = -1
+        elif self.frame <= 0:
+            self._fanim = 1
+
+        nmr, nmc, ok = try_move(self.mr, self.mc, self.dir)
+        if ok:
+            self.mr, self.mc = nmr, nmc
+        if not ok or random.random() < 0.05:
+            vd = valid_dirs(self.mr, self.mc)
+            if vd:
+                self.dir = random.choice(vd)
+
+        score, scared = 0, 0
+        pos = (self.mr, self.mc)
+        if pos in dots:
+            dots.discard(pos)
+            score = 10
+        if pos in pills:
+            pills.discard(pos)
+            score = 50
+            scared = 150
+        return score, scared
+
+
+# ── Game ──────────────────────────────────────────────────────────────────────
+class PacmanGame:
+    def __init__(self):
+        rows, cols = term_size()
+        self.rows, self.cols = rows, cols
+        self.canvas = Canvas(rows, cols)
+        self.score  = 0
+        self.level  = 1
+        self._scale()
+        self._init_level()
+
+    def _scale(self):
+        rows, cols = self.rows, self.cols
+        self.sw = max(2, min(8, (cols - 4) // MAZE_W))
+        self.sh = max(1, min(4, (rows - 4) // MAZE_H))
+        self.mleft = (cols - MAZE_W * self.sw) // 2
+        self.mtop  = (rows - MAZE_H * self.sh) // 2 + 1  # +1 for status line
+
+    def _init_level(self):
+        self.dots:  Set[Tuple[int, int]] = set()
+        self.pills: Set[Tuple[int, int]] = set()
+        for mr in range(MAZE_H):
+            for mc in range(MAZE_W):
+                ch = MAZE[mr][mc]
+                if ch == '.':
+                    self.dots.add((mr, mc))
+                elif ch == '*':
+                    self.pills.add((mr, mc))
+
+        open_cells = [(mr, mc) for mr in range(MAZE_H)
+                      for mc in range(MAZE_W) if MAZE[mr][mc] != '#']
+
+        # Pac-Man near center
+        cr, cc = MAZE_H // 2, MAZE_W // 2
+        start = min(open_cells, key=lambda p: abs(p[0] - cr) + abs(p[1] - cc))
+        self.pac = Pacman(start[0], start[1])
+
+        # Ghosts spread out
+        spots = random.sample(open_cells, min(4, len(open_cells)))
+        self.ghosts = [Ghost(mr, mc, GHOST_COLORS[i % 4])
+                       for i, (mr, mc) in enumerate(spots)]
+        self.scared_ticks = 0
+        self._ptick = 0
+        self._gtick = 0
+
+    def resize(self, rows: int, cols: int):
+        self.rows, self.cols = rows, cols
+        self.canvas.resize(rows, cols)
+        self._scale()
+        self._init_level()
+
+    def step(self):
+        self._ptick += 1
+        if self._ptick >= 2:
+            self._ptick = 0
+            sd, sb = self.pac.step(self.dots, self.pills)
+            self.score += sd
+            if sb:
+                self.scared_ticks = sb
+                for g in self.ghosts:
+                    g.scared_ticks = sb
+
+        if self.scared_ticks > 0:
+            self.scared_ticks -= 1
+
+        self._gtick += 1
+        if self._gtick >= 3:
+            self._gtick = 0
+            for g in self.ghosts:
+                g.step()
+
+        if not self.dots and not self.pills:
+            self.level += 1
+            self._init_level()
+
+    def _tpos(self, mr: int, mc: int) -> Tuple[int, int]:
+        return self.mtop + mr * self.sh, self.mleft + mc * self.sw
+
+    def render(self) -> str:
+        sw, sh = self.sw, self.sh
+        canvas = self.canvas
+        canvas.clear()
+
+        # Status line
+        status = f" SCORE: {self.score:>6}   LEVEL: {self.level}   dots: {len(self.dots)+len(self.pills)} "
+        canvas.put_str(0, 0, status, C_SCORE)
+
+        # Maze: walls, dots, pills
+        for mr in range(MAZE_H):
+            for mc in range(MAZE_W):
+                ty, tx = self._tpos(mr, mc)
+                cell = MAZE[mr][mc]
+                if cell == '#':
+                    n    = is_wall(mr - 1, mc)
+                    s    = is_wall(mr + 1, mc)
+                    w_n  = is_wall(mr, mc - 1)
+                    e_n  = is_wall(mr, mc + 1)
+                    ne   = is_wall(mr - 1, mc + 1)
+                    nw   = is_wall(mr - 1, mc - 1)
+                    se   = is_wall(mr + 1, mc + 1)
+                    sw_d = is_wall(mr + 1, mc - 1)
+
+                    top, bot = ty, ty + sh - 1
+                    lft, rgt = tx, tx + sw - 1
+
+                    # Boundary lines only where wall meets corridor
+                    if not n:
+                        for dx in range(sw): canvas.put(top, tx + dx, '─', C_WALL)
+                    if not s:
+                        for dx in range(sw): canvas.put(bot, tx + dx, '─', C_WALL)
+                    if not w_n:
+                        for dy in range(sh): canvas.put(ty + dy, lft, '│', C_WALL)
+                    if not e_n:
+                        for dy in range(sh): canvas.put(ty + dy, rgt, '│', C_WALL)
+
+                    # Outer corners (convex: two boundary edges meet)
+                    if not n and not w_n: canvas.put(top, lft, '┌', C_WALL)
+                    if not n and not e_n: canvas.put(top, rgt, '┐', C_WALL)
+                    if not s and not w_n: canvas.put(bot, lft, '└', C_WALL)
+                    if not s and not e_n: canvas.put(bot, rgt, '┘', C_WALL)
+
+                    # Inner corners (concave: both direct neighbours are walls, diagonal is corridor)
+                    if n and w_n and not nw:   canvas.put(top, lft, '┘', C_WALL)
+                    if n and e_n and not ne:   canvas.put(top, rgt, '└', C_WALL)
+                    if s and w_n and not sw_d: canvas.put(bot, lft, '┐', C_WALL)
+                    if s and e_n and not se:   canvas.put(bot, rgt, '┌', C_WALL)
+                elif (mr, mc) in self.dots:
+                    canvas.put(ty + sh // 2, tx + sw // 2, '\u2022', C_DOT)
+                elif (mr, mc) in self.pills:
+                    canvas.put(ty + sh // 2, tx + sw // 2, '\u25cf', C_PILL)
+
+        # Ghosts
+        for g in self.ghosts:
+            ty, tx = self._tpos(g.mr, g.mc)
+            scared = g.scared_ticks > 0
+            color = (C_SCARE2 if (g.scared_ticks // 5) % 2 == 0
+                     else C_SCARED) if scared else g.color
+            sp = make_ghost(sw, sh, scared, g.frame)
+            canvas.put_sprite_solid(ty, tx, sp, color)
+
+        # Pac-Man
+        ty, tx = self._tpos(self.pac.mr, self.pac.mc)
+        sp = make_pac(sw, sh, self.pac.dir, min(self.pac.frame, 2))
+        canvas.put_sprite_solid(ty, tx, sp, C_PAC)
+
+        return canvas.render()
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+def main():
+    ap = argparse.ArgumentParser(description='Pac-Man ASCII screensaver')
+    ap.add_argument('--speed', type=float, default=1.0,
+                    help='Speed multiplier (default 1.0)')
+    args = ap.parse_args()
+
+    TICK = 0.08 / args.speed
+
+    fd_out = sys.stdout.fileno()
+    inp    = Input()
+    game   = PacmanGame()
+    resize_flag = False
+
+    def on_resize(sig, frame):
+        nonlocal resize_flag
+        resize_flag = True
+    signal.signal(signal.SIGWINCH, on_resize)
+
+    _write_all(fd_out, (ALT_ON + HIDE_CUR).encode())
+    try:
+        while True:
+            t0 = time.monotonic()
+            if resize_flag:
+                resize_flag = False
+                r, c = term_size()
+                game.resize(r, c)
+            if inp.read():
+                break
+            game.step()
+            _write_all(fd_out, game.render().encode())
+            rem = TICK - (time.monotonic() - t0)
+            if rem > 0:
+                time.sleep(rem)
+    finally:
+        _write_all(fd_out, (ALT_OFF + SHOW_CUR + RESET).encode())
+        inp.restore()
+        print(f"\nFinal score: {game.score}  (Level {game.level})")
+
+
+if __name__ == '__main__':
+    main()