533 lines
19 KiB
Python
533 lines
19 KiB
Python
#!/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()
|