pi-extensions 0.1.9

package/arcade/picman.ts

@@ -0,0 +1,328 @@
+/**
+ * Picman - Pi eats tokens, avoids bugs! Play with /picman
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+const TICK_MS = 100;
+const POWER_DURATION = 50;
+const BUG_RESPAWN_TICKS = 30;
+const INITIAL_LIVES = 3;
+const BUG_MOVE_INTERVAL = 2;
+const SAVE_TYPE = "picman-save";
+
+type Direction = "up" | "down" | "left" | "right";
+
+// The codebase - navigate and collect tokens!
+const MAZE_TEMPLATE = [
+	"#####################",
+	"#.........#.........#",
+	"#O###.###.#.###.###O#",
+	"#.###.###.#.###.###.#",
+	"#...................#",
+	"#.###.#.#####.#.###.#",
+	"#.....#...#...#.....#",
+	"#####.### # ###.#####",
+	"    #.#  B B  #.#    ",
+	"#####.# BBB B#.#####",
+	"     .  BBB B .     ",
+	"#####.# BBBBB #.#####",
+	"    #.#       #.#    ",
+	"#####.# ##### #.#####",
+	"#.........#.........#",
+	"#.###.###.#.###.###.#",
+	"#O..#.....P.....#..O#",
+	"###.#.#.#####.#.#.###",
+	"#.....#...#...#.....#",
+	"#.#######.#.#######.#",
+	"#####################",
+];
+
+const DIRECTIONS: Record<Direction, { x: number; y: number }> = {
+	up: { x: 0, y: -1 }, down: { x: 0, y: 1 }, left: { x: -1, y: 0 }, right: { x: 1, y: 0 },
+};
+const OPPOSITE: Record<Direction, Direction> = { up: "down", down: "up", left: "right", right: "left" };
+
+// ANSI colors
+const [RESET, CYAN, BLUE, WHITE, DIM, RED] = ["\x1b[0m", "\x1b[1;96m", "\x1b[1;34m", "\x1b[1;97m", "\x1b[2m", "\x1b[1;91m"];
+const GREEN = "\x1b[1;32m";
+const BUG_COLORS = ["\x1b[1;91m", "\x1b[1;95m", "\x1b[1;93m", "\x1b[1;31m"]; // Red, Magenta, Yellow, Dark Red
+const BUG_NAMES = ["Bug", "Error", "Crash", "Glitch"];
+
+interface Bug {
+	x: number; y: number; homeX: number; homeY: number;
+	direction: Direction; color: string; name: string;
+	squashed: boolean; respawnTimer: number;
+}
+
+interface GameState {
+	pi: { x: number; y: number };
+	piDir: Direction;
+	nextDir: Direction | null;
+	bugs: Bug[];
+	maze: string[][];
+	tokens: number; highScore: number; lives: number; level: number;
+	tokensRemaining: number; caffeine: number; tickCount: number;
+	gameOver: boolean; paused: boolean; mouthOpen: boolean;
+	deathAnimation: number; levelCompleteTimer: number;
+}
+
+const findInMaze = (char: string): { x: number; y: number }[] => {
+	const results: { x: number; y: number }[] = [];
+	MAZE_TEMPLATE.forEach((row, y) => {
+		for (let x = 0; x < row.length; x++) if (row[x] === char) results.push({ x, y });
+	});
+	return results;
+};
+
+const createMaze = (): string[][] => {
+	const maze = MAZE_TEMPLATE.map(row => row.split(""));
+	for (let y = 0; y < maze.length; y++)
+		for (let x = 0; x < maze[y].length; x++)
+			if (maze[y][x] === "P" || maze[y][x] === "B") maze[y][x] = " ";
+	return maze;
+};
+
+const countTokens = (maze: string[][]): number =>
+	maze.flat().filter(c => c === "." || c === "O").length;
+
+const createBugs = (): Bug[] =>
+	findInMaze("B").slice(0, 4).map((pos, i) => ({
+		x: pos.x, y: pos.y, homeX: pos.x, homeY: pos.y,
+		direction: "up" as Direction, color: BUG_COLORS[i], name: BUG_NAMES[i],
+		squashed: false, respawnTimer: 0,
+	}));
+
+const createState = (highScore = 0): GameState => {
+	const maze = createMaze();
+	const piStart = findInMaze("P")[0] || { x: 10, y: 16 };
+	return {
+		pi: piStart, piDir: "right", nextDir: null,
+		bugs: createBugs(), maze,
+		tokens: 0, highScore, lives: INITIAL_LIVES, level: 1,
+		tokensRemaining: countTokens(maze), caffeine: 0, tickCount: 0,
+		gameOver: false, paused: false, mouthOpen: true,
+		deathAnimation: 0, levelCompleteTimer: 0,
+	};
+};
+
+const resetLevel = (s: GameState): void => {
+	s.maze = createMaze();
+	s.pi = findInMaze("P")[0] || { x: 10, y: 16 };
+	s.piDir = "right"; s.nextDir = null;
+	s.bugs = createBugs();
+	s.tokensRemaining = countTokens(s.maze);
+	s.caffeine = s.deathAnimation = s.levelCompleteTimer = 0;
+};
+
+const resetPositions = (s: GameState): void => {
+	s.pi = findInMaze("P")[0] || { x: 10, y: 16 };
+	s.piDir = "right"; s.nextDir = null;
+	s.caffeine = s.deathAnimation = 0;
+	s.bugs.forEach(b => { b.x = b.homeX; b.y = b.homeY; b.squashed = false; b.respawnTimer = 0; });
+};
+
+const isWalkable = (maze: string[][], x: number, y: number): boolean =>
+	y >= 0 && y < maze.length && (x < 0 || x >= maze[0].length || maze[y][x] !== "#");
+
+const wrap = (x: number, w: number): number => x < 0 ? w - 1 : x >= w ? 0 : x;
+
+const dist = (a: { x: number; y: number }, b: { x: number; y: number }): number =>
+	Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+
+const getValidDirs = (maze: string[][], x: number, y: number, exclude?: Direction): Direction[] =>
+	(Object.keys(DIRECTIONS) as Direction[]).filter(dir => {
+		if (dir === exclude) return false;
+		const d = DIRECTIONS[dir];
+		return isWalkable(maze, x + d.x, y + d.y);
+	});
+
+const moveBug = (b: Bug, s: GameState): void => {
+	if (b.squashed) {
+		if (--b.respawnTimer <= 0) { b.squashed = false; b.x = b.homeX; b.y = b.homeY; }
+		return;
+	}
+
+	const { maze, pi, caffeine } = s;
+	const validDirs = getValidDirs(maze, b.x, b.y, OPPOSITE[b.direction]);
+
+	if (validDirs.length === 0) {
+		const rev = OPPOSITE[b.direction], d = DIRECTIONS[rev];
+		if (isWalkable(maze, b.x + d.x, b.y + d.y)) {
+			b.direction = rev; b.x = wrap(b.x + d.x, maze[0].length); b.y += d.y;
+		}
+		return;
+	}
+
+	// Target: flee if Pi is caffeinated, else chase with personality
+	let target = pi;
+	if (caffeine <= 0) {
+		if (b.name === "Error") {
+			const d = DIRECTIONS[s.piDir];
+			target = { x: pi.x + d.x * 4, y: pi.y + d.y * 4 };
+		} else if (b.name === "Glitch" && dist(b, pi) < 8) {
+			target = { x: 0, y: maze.length - 1 };
+		}
+	}
+
+	// Pick best direction
+	const bestDir = validDirs.reduce((best, dir) => {
+		const d = DIRECTIONS[dir];
+		const nx = wrap(b.x + d.x, maze[0].length), ny = b.y + d.y;
+		const score = dist({ x: nx, y: ny }, target);
+		const bestScore = dist({ x: wrap(b.x + DIRECTIONS[best].x, maze[0].length), y: b.y + DIRECTIONS[best].y }, target);
+		return caffeine > 0 ? (score > bestScore ? dir : best) : (score < bestScore ? dir : best);
+	}, validDirs[0]);
+
+	b.direction = bestDir;
+	const d = DIRECTIONS[bestDir];
+	b.x = wrap(b.x + d.x, maze[0].length); b.y += d.y;
+};
+
+const movePi = (s: GameState): void => {
+	const { maze, pi } = s;
+
+	// Try queued direction
+	if (s.nextDir) {
+		const d = DIRECTIONS[s.nextDir];
+		if (isWalkable(maze, pi.x + d.x, pi.y + d.y)) { s.piDir = s.nextDir; s.nextDir = null; }
+	}
+
+	const d = DIRECTIONS[s.piDir];
+	if (isWalkable(maze, pi.x + d.x, pi.y + d.y)) {
+		pi.x = wrap(pi.x + d.x, maze[0].length); pi.y += d.y;
+		const cell = maze[pi.y][pi.x];
+		if (cell === ".") { maze[pi.y][pi.x] = " "; s.tokens += 10; s.tokensRemaining--; }
+		else if (cell === "O") { maze[pi.y][pi.x] = " "; s.tokens += 50; s.tokensRemaining--; s.caffeine = POWER_DURATION; }
+	}
+
+	if (s.tickCount % 3 === 0) s.mouthOpen = !s.mouthOpen;
+};
+
+const checkCollisions = (s: GameState): void => {
+	for (const b of s.bugs) {
+		if (b.squashed || b.x !== s.pi.x || b.y !== s.pi.y) continue;
+		if (s.caffeine > 0) { b.squashed = true; b.respawnTimer = BUG_RESPAWN_TICKS; s.tokens += 200; }
+		else if (--s.lives <= 0) s.gameOver = true;
+		else s.deathAnimation = 10;
+	}
+};
+
+class PicmanComponent {
+	private state: GameState;
+	private interval: ReturnType<typeof setInterval> | null = null;
+	private onClose: () => void;
+	private onSave: (state: GameState) => void;
+	private tui: { requestRender: () => void };
+	private cache = { lines: [] as string[], width: 0, version: -1 };
+	private version = 0;
+
+	constructor(tui: { requestRender: () => void }, onClose: () => void, onSave: (s: GameState) => void, saved?: GameState) {
+		this.tui = tui; this.onClose = onClose; this.onSave = onSave;
+		this.state = saved ? { ...saved, paused: true } : createState();
+		this.interval = setInterval(() => this.tick(), TICK_MS);
+	}
+
+	private tick(): void {
+		const s = this.state;
+		if (s.paused || s.gameOver) return;
+		s.tickCount++;
+
+		if (s.deathAnimation > 0) { if (--s.deathAnimation === 0) resetPositions(s); }
+		else if (s.levelCompleteTimer > 0) { if (--s.levelCompleteTimer === 0) { s.level++; resetLevel(s); } }
+		else if (s.tokensRemaining === 0) s.levelCompleteTimer = 20;
+		else {
+			if (s.caffeine > 0) s.caffeine--;
+			movePi(s);
+			const bugInterval = Math.max(1, BUG_MOVE_INTERVAL - Math.floor(s.level / 3));
+			if (s.tickCount % bugInterval === 0) s.bugs.forEach(b => moveBug(b, s));
+			checkCollisions(s);
+			if (s.tokens > s.highScore) s.highScore = s.tokens;
+		}
+
+		this.version++;
+		this.tui.requestRender();
+	}
+
+	handleInput(key: string): boolean {
+		const s = this.state;
+		if (matchesKey(key, "escape") || key === "q" || key === "Q") { this.onSave(s); this.onClose(); return true; }
+		if (key === "n" || key === "N") { Object.assign(this.state, createState(Math.max(s.highScore, s.tokens))); this.version++; this.tui.requestRender(); return true; }
+		if (key === " " || key === "p" || key === "P") { s.paused = !s.paused; this.version++; this.tui.requestRender(); return true; }
+		if (s.gameOver || s.paused) return true;
+
+		const dirMap: Record<string, Direction> = { k: "up", w: "up", j: "down", s: "down", h: "left", a: "left", l: "right", d: "right" };
+		if (matchesKey(key, "up")) s.nextDir = "up";
+		else if (matchesKey(key, "down")) s.nextDir = "down";
+		else if (matchesKey(key, "left")) s.nextDir = "left";
+		else if (matchesKey(key, "right")) s.nextDir = "right";
+		else if (dirMap[key]) s.nextDir = dirMap[key];
+		return true;
+	}
+
+	render(width: number, _height: number): string[] {
+		const pad = (line: string) => truncateToWidth(line, width) + " ".repeat(Math.max(0, width - visibleWidth(truncateToWidth(line, width))));
+		const minWidth = MAZE_TEMPLATE[0].length * 2 + 4;
+
+		if (width < minWidth) {
+			return ["", pad(`${CYAN}PICMAN${RESET}`), "", pad("Terminal too narrow"), pad(`Need ${minWidth} cols`), "", pad("[Q] Quit")];
+		}
+
+		if (this.cache.version === this.version && this.cache.width === width) return this.cache.lines;
+
+		const s = this.state, lines: string[] = [""];
+		const lives = Array(Math.max(0, s.lives)).fill(`${CYAN}Pi${RESET}`).join(" ");
+		lines.push(pad(`${CYAN}PICMAN${RESET}  Tokens: ${WHITE}${s.tokens}${RESET}  Hi: ${s.highScore}  Lv: ${s.level}  ${lives}`));
+		lines.push("");
+
+		if (s.gameOver) {
+			lines.push(pad(`${RED}SEGFAULT${RESET}`), pad(`Final Tokens: ${s.tokens}`), "", pad("[N] New Game  [Q] Quit"), "");
+		} else {
+			if (s.paused) lines.push(pad(`${DIM}PAUSED${RESET}`), pad("[SPACE] Resume  [N] New  [Q] Quit"), "");
+			if (s.levelCompleteTimer > 0) lines.push(pad(`${GREEN}LEVEL ${s.level} SHIPPED!${RESET}`), "");
+			if (s.deathAnimation > 0) lines.push(pad(`${RED}BUG FOUND!${RESET}`), "");
+
+			for (let y = 0; y < s.maze.length; y++) {
+				let row = "";
+				for (let x = 0; x < s.maze[y].length; x++) {
+					const cell = s.maze[y][x];
+					if (s.pi.x === x && s.pi.y === y && s.deathAnimation === 0) {
+						const glyph = s.mouthOpen ? ({ right: "Pi", left: "iP", up: "Pi", down: "Pi" })[s.piDir] : "PI";
+						row += `${CYAN}${glyph}${RESET}`;
+					} else {
+						const bug = s.bugs.find(b => b.x === x && b.y === y && !b.squashed);
+						if (bug) {
+							const scared = s.caffeine > 0, blink = scared && s.caffeine < 15 && s.tickCount % 4 < 2;
+							row += `${blink ? WHITE : scared ? GREEN : bug.color}${scared ? "><" : "<>"}${RESET}`;
+						} else {
+							row += cell === "#" ? `${BLUE}██${RESET}` : cell === "." ? ` ${DIM};${RESET}` : cell === "O" ? `${GREEN}()${RESET}` : "  ";
+						}
+					}
+				}
+				lines.push(pad(row));
+			}
+
+			lines.push("", pad(s.caffeine > 0 ? `${GREEN}CAFFEINATED!${RESET} [Arrows/HJKL] Move  [SPACE] Pause  [Q] Quit` : "[Arrows/HJKL] Move  [SPACE] Pause  [N] New  [Q] Quit"), "");
+		}
+
+		this.cache = { lines, width, version: this.version };
+		return lines;
+	}
+
+	dispose(): void { if (this.interval) clearInterval(this.interval); }
+}
+
+export default function (api: ExtensionAPI) {
+	api.registerCommand("picman", {
+		description: "Play Picman! Collect tokens, squash bugs, drink coffee!",
+		handler: async (_args, ctx: ExtensionCommandContext) => {
+			if (!ctx.hasUI) { ctx.ui.notify("Picman requires interactive mode", "error"); return; }
+
+			const entries = ctx.sessionManager.getEntries();
+			const saved = entries.reverse().find(e => e.type === "custom" && e.customType === SAVE_TYPE)?.data as GameState | undefined;
+
+			await ctx.ui.custom((tui, _theme, _kb, done) => new PicmanComponent(tui, () => done(undefined), s => api.appendEntry(SAVE_TYPE, s), saved));
+		},
+	});
+}