pi-extensions 0.1.9

package/arcade/spice-invaders.ts

@@ -0,0 +1,1104 @@
+/**
+ * sPIce Invaders game extension - play with /spice-invaders
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+const GAME_WIDTH = 24;
+const GAME_HEIGHT = 16;
+const PLAYER_Y = GAME_HEIGHT - 1;
+const TICK_MS = 100;
+
+const INVADER_ROWS = 3;
+const INVADER_COLS = 6;
+const INVADER_START_X = 1;
+const INVADER_START_Y = 1;
+const INVADER_SPACING_X = 2;
+const INVADER_SPACING_Y = 1;
+const INITIAL_INVADER_COUNT = INVADER_ROWS * INVADER_COLS;
+
+const INITIAL_LIVES = 3;
+const BASE_INVADER_DELAY = 8;
+const PLAYER_SHOT_DELAY = 1;
+const MAX_PLAYER_BULLETS = 3;
+const PLAYER_MOVE_STEP = 1;
+const PLAYER_MOVE_HOLD_TICKS = 3;
+const INVADER_FIRE_DELAY = 6;
+const INVADER_BULLET_STEP_TICKS = 2;
+const MAX_INVADER_BULLETS = 2;
+const INVADER_SCORE = 10;
+const INVADER_ROW_SCORES = [30, 20, 10];
+const UFO_SCORE = 50;
+const UFO_BASE_COOLDOWN = 70;
+const READY_TICKS = 20;
+
+const BOSS_WIDTH = 6;
+const BOSS_HEIGHT = 2;
+const BOSS_HP = 20;
+const BOSS_MOVE_DELAY = 6;
+const BOSS_BULLET_STEP_TICKS = 4;
+const BOSS_MAX_BULLETS = 4;
+const BOSS_FIRE_CHANCE_BONUS = 0.2;
+const BOSS_SCORE = 200;
+const BOSS_Y = 1;
+const CHEAT_CODE = "clawd";
+const CHEAT_BUFFER_TICKS = 12;
+const BOSS_ENRAGE_RATIO = 0.5;
+const BOSS_ENRAGE_TICKS = 16;
+
+const CELL_WIDTH = 2;
+const MIN_RENDER_CELLS = 10;
+
+const SPACE_INVADERS_SAVE_TYPE = "spice-invaders-save";
+
+const UFO_Y = 0;
+
+const BOSS_FRAMES = [
+	[
+		["<\\", "()", "==", "==", "()", "/>"],
+		["()", "\\/", "/\\", "/\\", "\\/", "()"],
+	],
+	[
+		["<\\", "()", "~~", "~~", "()", "/>"],
+		["()", "\\/", "/\\", "/\\", "\\/", "()"],
+	],
+] as const;
+
+type Direction = -1 | 1;
+type MoveDir = Direction | 0;
+type Point = { x: number; y: number };
+
+type BulletSource = "player" | "invader";
+
+interface Bullet {
+	x: number;
+	y: number;
+	from: BulletSource;
+	unblockable?: boolean;
+}
+
+interface UfoState {
+	x: number;
+	dir: Direction;
+	active: boolean;
+}
+
+interface BossState {
+	active: boolean;
+	x: number;
+	y: number;
+	dir: Direction;
+	hp: number;
+	maxHp: number;
+	frame: 0 | 1;
+	moveCounter: number;
+}
+
+interface ScatterInvader {
+	x: number;
+	y: number;
+	vx: Direction;
+	vy: Direction;
+}
+
+type BossIntroPhase = "scatter" | "descend" | null;
+
+interface GameState {
+	invaders: Point[];
+	invaderDir: Direction;
+	invaderFrame: 0 | 1;
+	invaderMoveDelay: number;
+	invaderMoveCounter: number;
+	invaderOffsetY: number;
+	playerX: number;
+	playerBullets: Bullet[];
+	invaderBullets: Bullet[];
+	playerCooldown: number;
+	invaderCooldown: number;
+	playerMoveDir: MoveDir;
+	playerMoveHold: number;
+	bulletTick: number;
+	wavePauseTicks: number;
+	pendingWave: boolean;
+	score: number;
+	highScore: number;
+	lives: number;
+	level: number;
+	gameOver: boolean;
+	ufo: UfoState;
+	ufoCooldown: number;
+	boss: BossState;
+	bossEnrageTicks: number;
+	bossEnrageBlink: boolean;
+	bossIntroPhase: BossIntroPhase;
+	scatterInvaders: ScatterInvader[];
+}
+
+const createInvaders = (): Point[] => {
+	const invaders: Point[] = [];
+	for (let row = 0; row < INVADER_ROWS; row++) {
+		for (let col = 0; col < INVADER_COLS; col++) {
+			const x = INVADER_START_X + col * (1 + INVADER_SPACING_X);
+			const y = INVADER_START_Y + row * (1 + INVADER_SPACING_Y);
+			invaders.push({ x, y });
+		}
+	}
+	return invaders;
+};
+
+const createBossState = (level = 1): BossState => {
+	const maxHp = BOSS_HP * Math.max(1, level);
+	return {
+		active: false,
+		x: 0,
+		y: BOSS_Y,
+		dir: 1,
+		hp: maxHp,
+		maxHp,
+		frame: 0,
+		moveCounter: 0,
+	};
+};
+
+const bossEnrageHp = (boss: BossState): number => Math.max(1, Math.ceil(boss.maxHp * BOSS_ENRAGE_RATIO));
+
+const bossIsEnraged = (boss: BossState): boolean => boss.active && boss.hp <= bossEnrageHp(boss);
+
+const bossMoveDelayFor = (boss: BossState, level: number): number => {
+	const levelBoost = Math.max(1, level);
+	const base = Math.max(1, Math.floor(BOSS_MOVE_DELAY / levelBoost));
+	return bossIsEnraged(boss) ? Math.max(1, Math.floor(base / 1.5)) : base;
+};
+
+const invaderDelayFor = (level: number, remaining: number): number => {
+	const cleared = Math.max(0, INITIAL_INVADER_COUNT - remaining);
+	const speedUp = Math.floor(cleared / 4);
+	const levelBoost = Math.floor((level - 1) / 2);
+	return Math.max(2, BASE_INVADER_DELAY - speedUp - levelBoost);
+};
+
+const invaderFireDelayFor = (level: number, remaining: number): number => {
+	const cleared = Math.max(0, INITIAL_INVADER_COUNT - remaining);
+	const speedUp = Math.floor(cleared / 6);
+	const levelBoost = Math.floor((level - 1) / 3);
+	return Math.max(2, INVADER_FIRE_DELAY - speedUp - levelBoost);
+};
+
+const invaderFireChanceFor = (remaining: number): number => {
+	const ratio = 1 - remaining / INITIAL_INVADER_COUNT;
+	return Math.min(0.75, 0.35 + ratio * 0.35);
+};
+
+const bossFireDelayFor = (level: number, boss: BossState): number => {
+	const base = invaderFireDelayFor(level, 1);
+	return bossIsEnraged(boss) ? Math.max(1, Math.floor(base / 1.5)) : base;
+};
+
+const bossFireChanceFor = (boss: BossState): number => {
+	const base = Math.min(0.9, invaderFireChanceFor(1) + BOSS_FIRE_CHANCE_BONUS);
+	return bossIsEnraged(boss) ? Math.min(0.95, base * 1.5) : base;
+};
+
+const bossBulletStepFor = (level: number, boss: BossState): number => {
+	const levelBoost = Math.max(1, level);
+	const base = Math.max(1, Math.floor(BOSS_BULLET_STEP_TICKS / levelBoost));
+	return bossIsEnraged(boss) ? Math.max(1, Math.floor(base / 1.5)) : base;
+};
+
+const invaderRowScoreFor = (invader: Point, offsetY: number): number => {
+	const spacing = 1 + INVADER_SPACING_Y;
+	const rawRow = Math.round((invader.y - offsetY - INVADER_START_Y) / spacing);
+	const row = Math.max(0, Math.min(INVADER_ROW_SCORES.length - 1, rawRow));
+	return INVADER_ROW_SCORES[row] ?? INVADER_SCORE;
+};
+
+const createInitialState = (highScore = 0): GameState => {
+	const invaders = createInvaders();
+	return {
+		invaders,
+		invaderDir: 1,
+		invaderFrame: 0,
+		invaderMoveDelay: invaderDelayFor(1, invaders.length),
+		invaderMoveCounter: 0,
+		invaderOffsetY: 0,
+		playerX: Math.floor(GAME_WIDTH / 2),
+		playerBullets: [],
+		invaderBullets: [],
+		playerCooldown: 0,
+		invaderCooldown: invaderFireDelayFor(1, invaders.length),
+		playerMoveDir: 0,
+		playerMoveHold: 0,
+		bulletTick: 0,
+		wavePauseTicks: 0,
+		pendingWave: false,
+		score: 0,
+		highScore,
+		lives: INITIAL_LIVES,
+		level: 1,
+		gameOver: false,
+		ufo: { x: 0, dir: 1, active: false },
+		ufoCooldown: UFO_BASE_COOLDOWN,
+		boss: createBossState(1),
+		bossEnrageTicks: 0,
+		bossEnrageBlink: false,
+		bossIntroPhase: null,
+		scatterInvaders: [],
+	};
+};
+
+const cloneState = (state: GameState): GameState => ({
+	...state,
+	invaders: state.invaders.map((invader) => ({ ...invader })),
+	playerBullets: state.playerBullets.map((bullet) => ({ ...bullet })),
+	invaderBullets: state.invaderBullets.map((bullet) => ({ ...bullet })),
+	ufo: { ...state.ufo },
+	boss: { ...state.boss },
+	bossEnrageTicks: state.bossEnrageTicks,
+	bossEnrageBlink: state.bossEnrageBlink,
+	bossIntroPhase: state.bossIntroPhase,
+	scatterInvaders: state.scatterInvaders.map((invader) => ({ ...invader })),
+});
+
+const normalizeState = (state: GameState): GameState => {
+	const invaders = state.invaders ?? createInvaders();
+	const level = state.level ?? 1;
+	const boss = state.boss
+		? {
+				...state.boss,
+				y: state.boss.y ?? BOSS_Y,
+				maxHp: state.boss.maxHp ?? BOSS_HP * Math.max(1, level),
+			}
+		: createBossState(level);
+	return {
+		...state,
+		invaders,
+		ufo: state.ufo ?? { x: 0, dir: 1, active: false },
+		ufoCooldown: state.ufoCooldown ?? UFO_BASE_COOLDOWN,
+		invaderOffsetY: state.invaderOffsetY ?? 0,
+		playerMoveDir: state.playerMoveDir ?? 0,
+		playerMoveHold: state.playerMoveHold ?? 0,
+		bulletTick: state.bulletTick ?? 0,
+		wavePauseTicks: state.wavePauseTicks ?? 0,
+		pendingWave: state.pendingWave ?? false,
+		invaderCooldown: state.invaderCooldown ?? invaderFireDelayFor(level, invaders.length),
+		boss,
+		bossEnrageTicks: state.bossEnrageTicks ?? 0,
+		bossEnrageBlink: state.bossEnrageBlink ?? false,
+		bossIntroPhase: state.bossIntroPhase ?? null,
+		scatterInvaders: state.scatterInvaders ?? [],
+	};
+};
+
+class SpaceInvadersComponent {
+	private state: GameState;
+	private interval: ReturnType<typeof setInterval> | null = null;
+	private onClose: () => void;
+	private onSave: (state: GameState | null) => void;
+	private tui: { requestRender: () => void };
+	private cachedLines: string[] = [];
+	private cachedWidth = 0;
+	private version = 0;
+	private cachedVersion = -1;
+	private paused: boolean;
+	private cheatBuffer = "";
+	private cheatBufferTicks = 0;
+
+	constructor(
+		tui: { requestRender: () => void },
+		onClose: () => void,
+		onSave: (state: GameState | null) => void,
+		savedState?: GameState,
+	) {
+		this.tui = tui;
+		this.onClose = onClose;
+		this.onSave = onSave;
+
+		if (savedState && !savedState.gameOver) {
+			this.state = normalizeState(savedState);
+			this.paused = true;
+		} else {
+			const highScore = savedState?.highScore ?? 0;
+			this.state = createInitialState(highScore);
+			this.paused = false;
+			this.startLoop();
+		}
+	}
+
+	private startLoop(): void {
+		if (this.interval) return;
+		this.interval = setInterval(() => {
+			if (this.paused || this.state.gameOver) return;
+			this.tick();
+			this.markDirty();
+		}, TICK_MS);
+	}
+
+	private stopLoop(): void {
+		if (!this.interval) return;
+		clearInterval(this.interval);
+		this.interval = null;
+	}
+
+	private markDirty(): void {
+		this.version++;
+		this.tui.requestRender();
+	}
+
+	private tick(): void {
+		this.decayCheatBuffer();
+		if (this.state.bossIntroPhase) {
+			this.updateBossIntro();
+			return;
+		}
+		if (this.state.bossEnrageTicks > 0) {
+			this.state.bossEnrageTicks -= 1;
+			this.state.bossEnrageBlink = !this.state.bossEnrageBlink;
+			if (this.state.bossEnrageTicks === 0) {
+				this.state.bossEnrageBlink = false;
+			}
+			return;
+		}
+		if (this.state.wavePauseTicks > 0) {
+			this.state.wavePauseTicks -= 1;
+			if (this.state.wavePauseTicks === 0 && this.state.pendingWave) {
+				this.startNextWave();
+			}
+			return;
+		}
+
+		this.state.bulletTick += 1;
+		if (this.state.playerCooldown > 0) this.state.playerCooldown--;
+		if (this.state.invaderCooldown > 0) this.state.invaderCooldown--;
+
+		this.applyHeldMovement();
+		if (this.state.boss.active) {
+			this.updateBoss();
+		} else {
+			this.updateUfo();
+		}
+		this.moveBullets();
+		this.resolveBulletCollisions();
+		if (this.state.gameOver) {
+			this.stopLoop();
+			return;
+		}
+		if (this.state.boss.active) {
+			this.maybeFireInvaderBullet();
+			return;
+		}
+		this.moveInvaders();
+		if (this.state.gameOver) {
+			this.stopLoop();
+			return;
+		}
+		this.maybeFireInvaderBullet();
+		this.maybeAdvanceWave();
+	}
+
+	private decayCheatBuffer(): void {
+		if (this.cheatBufferTicks <= 0) return;
+		this.cheatBufferTicks -= 1;
+		if (this.cheatBufferTicks <= 0) {
+			this.cheatBuffer = "";
+		}
+	}
+
+	private registerCheatInput(data: string): boolean {
+		if (data.length !== 1) return false;
+		const lower = data.toLowerCase();
+		if (lower < "a" || lower > "z") return false;
+		this.cheatBuffer = (this.cheatBuffer + lower).slice(-CHEAT_CODE.length);
+		this.cheatBufferTicks = CHEAT_BUFFER_TICKS;
+		if (!this.cheatBuffer.endsWith(CHEAT_CODE)) return false;
+		this.cheatBuffer = "";
+		this.activateBoss();
+		return true;
+	}
+
+	private activateBoss(): void {
+		if (this.state.boss.active || this.state.bossIntroPhase) return;
+		const centered = Math.floor((GAME_WIDTH - BOSS_WIDTH) / 2);
+		const maxHp = BOSS_HP * Math.max(1, this.state.level);
+		const scatterInvaders = this.state.invaders.map((invader) => ({
+			x: invader.x,
+			y: invader.y,
+			vx: Math.random() < 0.5 ? -1 : 1,
+			vy: Math.random() < 0.5 ? -1 : 1,
+		}));
+
+		this.state.boss = {
+			active: false,
+			x: Math.max(0, Math.min(GAME_WIDTH - BOSS_WIDTH, centered)),
+			y: -BOSS_HEIGHT,
+			dir: 1,
+			hp: maxHp,
+			maxHp,
+			frame: 0,
+			moveCounter: 0,
+		};
+		this.state.invaders = [];
+		this.state.scatterInvaders = scatterInvaders;
+		this.state.invaderBullets = [];
+		this.state.playerBullets = [];
+		this.state.invaderOffsetY = 0;
+		this.state.invaderMoveCounter = 0;
+		this.state.pendingWave = false;
+		this.state.wavePauseTicks = 0;
+		this.state.bossEnrageTicks = 0;
+		this.state.bossEnrageBlink = false;
+		this.state.bossIntroPhase = scatterInvaders.length ? "scatter" : "descend";
+		this.state.playerMoveDir = 0;
+		this.state.playerMoveHold = 0;
+		this.state.ufo.active = false;
+		this.state.ufoCooldown = UFO_BASE_COOLDOWN;
+		this.state.invaderCooldown = bossFireDelayFor(this.state.level, this.state.boss);
+		this.markDirty();
+	}
+
+	private updateBossIntro(): void {
+		if (this.state.bossIntroPhase === "scatter") {
+			this.updateScatterInvaders();
+			if (this.state.scatterInvaders.length === 0) {
+				this.state.bossIntroPhase = "descend";
+			}
+			return;
+		}
+		if (this.state.bossIntroPhase === "descend") {
+			this.state.boss.y += 1;
+			if (this.state.boss.y >= BOSS_Y) {
+				this.state.boss.y = BOSS_Y;
+				this.state.boss.active = true;
+				this.state.bossIntroPhase = null;
+				this.state.boss.moveCounter = 0;
+				this.state.invaderCooldown = bossFireDelayFor(this.state.level, this.state.boss);
+			}
+		}
+	}
+
+	private updateScatterInvaders(): void {
+		const remaining: ScatterInvader[] = [];
+		for (const invader of this.state.scatterInvaders) {
+			const next = {
+				...invader,
+				x: invader.x + invader.vx,
+				y: invader.y + invader.vy,
+			};
+			if (next.x < -1 || next.x > GAME_WIDTH || next.y < -1 || next.y > GAME_HEIGHT) {
+				continue;
+			}
+			remaining.push(next);
+		}
+		this.state.scatterInvaders = remaining;
+	}
+
+	private updateBoss(): void {
+		if (!this.state.boss.active) return;
+		const moveDelay = bossMoveDelayFor(this.state.boss, this.state.level);
+		this.state.boss.moveCounter += 1;
+		if (this.state.boss.moveCounter < moveDelay) return;
+		this.state.boss.moveCounter = 0;
+		let nextX = this.state.boss.x + this.state.boss.dir;
+		if (nextX < 0 || nextX + BOSS_WIDTH > GAME_WIDTH) {
+			this.state.boss.dir = (this.state.boss.dir === 1 ? -1 : 1) as Direction;
+			nextX = this.state.boss.x + this.state.boss.dir;
+		}
+		this.state.boss.x = Math.max(0, Math.min(GAME_WIDTH - BOSS_WIDTH, nextX));
+		this.state.boss.frame = this.state.boss.frame === 0 ? 1 : 0;
+	}
+
+	private applyHeldMovement(): void {
+		if (this.state.playerMoveHold <= 0 || this.state.playerMoveDir === 0) return;
+		this.state.playerX = Math.max(
+			0,
+			Math.min(GAME_WIDTH - 1, this.state.playerX + this.state.playerMoveDir * PLAYER_MOVE_STEP),
+		);
+		this.state.playerMoveHold -= 1;
+	}
+
+	private queuePlayerMove(dir: Direction): void {
+		this.state.playerMoveDir = dir;
+		this.state.playerMoveHold = PLAYER_MOVE_HOLD_TICKS;
+		this.state.playerX = Math.max(0, Math.min(GAME_WIDTH - 1, this.state.playerX + dir * PLAYER_MOVE_STEP));
+		this.markDirty();
+	}
+
+	private updateUfo(): void {
+		if (this.state.ufo.active) {
+			this.state.ufo.x += this.state.ufo.dir;
+			if (this.state.ufo.x < 0 || this.state.ufo.x >= GAME_WIDTH) {
+				this.state.ufo.active = false;
+				this.state.ufoCooldown = UFO_BASE_COOLDOWN;
+			}
+			return;
+		}
+
+		if (this.state.ufoCooldown > 0) {
+			this.state.ufoCooldown -= 1;
+			return;
+		}
+
+		if (Math.random() < 0.25) {
+			const dir: Direction = Math.random() < 0.5 ? 1 : -1;
+			this.state.ufo = {
+				x: dir === 1 ? 0 : GAME_WIDTH - 1,
+				dir,
+				active: true,
+			};
+		} else {
+			this.state.ufoCooldown = 10;
+		}
+	}
+
+	private moveBullets(): void {
+		const nextPlayerBullets: Bullet[] = [];
+		for (const bullet of this.state.playerBullets) {
+			const moved = { ...bullet, y: bullet.y - 1 };
+			if (moved.y >= 0) {
+				nextPlayerBullets.push(moved);
+			}
+		}
+		this.state.playerBullets = nextPlayerBullets;
+
+		const invaderStep = this.state.boss.active
+			? bossBulletStepFor(this.state.level, this.state.boss)
+			: INVADER_BULLET_STEP_TICKS;
+		const shouldMoveInvaderBullets = this.state.bulletTick % invaderStep === 0;
+		const nextInvaderBullets: Bullet[] = [];
+		for (const bullet of this.state.invaderBullets) {
+			const moved = shouldMoveInvaderBullets ? { ...bullet, y: bullet.y + 1 } : { ...bullet };
+			if (moved.y <= PLAYER_Y) {
+				nextInvaderBullets.push(moved);
+			}
+		}
+		this.state.invaderBullets = nextInvaderBullets;
+	}
+
+	private resolveBulletCollisions(): void {
+		const invaderBulletByPos = new Map<string, Bullet>();
+		for (const bullet of this.state.invaderBullets) {
+			invaderBulletByPos.set(`${bullet.x},${bullet.y}`, bullet);
+		}
+
+		const invaderIndexByPos = new Map<string, number>();
+		for (let i = 0; i < this.state.invaders.length; i++) {
+			const invader = this.state.invaders[i];
+			invaderIndexByPos.set(`${invader.x},${invader.y}`, i);
+		}
+
+		const bossBulletsUnblockable = this.state.boss.active && bossIsEnraged(this.state.boss);
+
+		const hitBoss = (bullet: Bullet): boolean => {
+			if (!this.state.boss.active) return false;
+			const bossY = this.state.boss.y;
+			if (bullet.y < bossY || bullet.y >= bossY + BOSS_HEIGHT) return false;
+			if (bullet.x < this.state.boss.x || bullet.x >= this.state.boss.x + BOSS_WIDTH) return false;
+			const wasEnraged = bossIsEnraged(this.state.boss);
+			this.state.boss.hp -= 1;
+			if (this.state.boss.hp <= 0) {
+				this.state.boss.active = false;
+				this.state.bossEnrageTicks = 0;
+				this.state.bossEnrageBlink = false;
+				this.state.score += BOSS_SCORE;
+				if (this.state.score > this.state.highScore) {
+					this.state.highScore = this.state.score;
+				}
+				return true;
+			}
+			if (!wasEnraged && bossIsEnraged(this.state.boss)) {
+				this.state.bossEnrageTicks = BOSS_ENRAGE_TICKS;
+				this.state.bossEnrageBlink = true;
+			}
+			return true;
+		};
+
+		const afterBulletClash: Bullet[] = [];
+		for (const bullet of this.state.playerBullets) {
+			const key = `${bullet.x},${bullet.y}`;
+			const blocking = invaderBulletByPos.get(key);
+			if (blocking) {
+				if (!(blocking.unblockable || bossBulletsUnblockable)) {
+					invaderBulletByPos.delete(key);
+				}
+				continue;
+			}
+			afterBulletClash.push(bullet);
+		}
+		this.state.invaderBullets = Array.from(invaderBulletByPos.values());
+
+		const hitInvaders = new Map<number, number>();
+		const remainingPlayerBullets: Bullet[] = [];
+		for (const bullet of afterBulletClash) {
+			const key = `${bullet.x},${bullet.y}`;
+			if (this.state.ufo.active && bullet.y === UFO_Y && bullet.x === this.state.ufo.x) {
+				this.state.ufo.active = false;
+				this.state.ufoCooldown = UFO_BASE_COOLDOWN;
+				this.state.score += UFO_SCORE;
+				if (this.state.score > this.state.highScore) {
+					this.state.highScore = this.state.score;
+				}
+				continue;
+			}
+			if (hitBoss(bullet)) {
+				continue;
+			}
+			const invaderIndex = invaderIndexByPos.get(key);
+			if (invaderIndex !== undefined) {
+				if (!hitInvaders.has(invaderIndex)) {
+					const invader = this.state.invaders[invaderIndex];
+					hitInvaders.set(invaderIndex, invaderRowScoreFor(invader, this.state.invaderOffsetY));
+				}
+				continue;
+			}
+			remainingPlayerBullets.push(bullet);
+		}
+
+		if (hitInvaders.size > 0) {
+			this.state.invaders = this.state.invaders.filter((_invader, idx) => !hitInvaders.has(idx));
+			let scoreDelta = 0;
+			for (const value of hitInvaders.values()) {
+				scoreDelta += value;
+			}
+			this.state.score += scoreDelta;
+			if (this.state.score > this.state.highScore) {
+				this.state.highScore = this.state.score;
+			}
+			this.state.invaderMoveDelay = invaderDelayFor(this.state.level, this.state.invaders.length);
+			const newFireDelay = invaderFireDelayFor(this.state.level, this.state.invaders.length);
+			if (this.state.invaderCooldown > newFireDelay) {
+				this.state.invaderCooldown = newFireDelay;
+			}
+		}
+		this.state.playerBullets = remainingPlayerBullets;
+
+		const remainingInvaderBullets: Bullet[] = [];
+		for (const bullet of this.state.invaderBullets) {
+			if (bullet.x === this.state.playerX && bullet.y === PLAYER_Y) {
+				this.state.lives -= 1;
+				if (this.state.lives <= 0) {
+					this.state.gameOver = true;
+				}
+				continue;
+			}
+			remainingInvaderBullets.push(bullet);
+		}
+		this.state.invaderBullets = remainingInvaderBullets;
+	}
+
+	private moveInvaders(): void {
+		this.state.invaderMoveCounter += 1;
+		if (this.state.invaderMoveCounter < this.state.invaderMoveDelay) return;
+		this.state.invaderMoveCounter = 0;
+
+		const dir = this.state.invaderDir;
+		let hitEdge = false;
+		for (const invader of this.state.invaders) {
+			const nextX = invader.x + dir;
+			if (nextX < 0 || nextX >= GAME_WIDTH) {
+				hitEdge = true;
+				break;
+			}
+		}
+
+		if (hitEdge) {
+			this.state.invaderDir = (dir === 1 ? -1 : 1) as Direction;
+			for (const invader of this.state.invaders) {
+				invader.y += 1;
+				if (invader.y >= PLAYER_Y) {
+					this.state.gameOver = true;
+				}
+			}
+			this.state.invaderOffsetY += 1;
+		} else {
+			for (const invader of this.state.invaders) {
+				invader.x += dir;
+			}
+		}
+
+		this.state.invaderFrame = this.state.invaderFrame === 0 ? 1 : 0;
+	}
+
+	private maybeFireInvaderBullet(): void {
+		if (this.state.invaderCooldown > 0) return;
+		const maxBullets = this.state.boss.active ? BOSS_MAX_BULLETS : MAX_INVADER_BULLETS;
+		if (this.state.invaderBullets.length >= maxBullets) return;
+
+		if (this.state.boss.active) {
+			const fireChance = bossFireChanceFor(this.state.boss);
+			if (Math.random() > fireChance) {
+				this.state.invaderCooldown = 1;
+				return;
+			}
+			const bossEnraged = bossIsEnraged(this.state.boss);
+			const bulletY = this.state.boss.y + BOSS_HEIGHT;
+			const leftX = this.state.boss.x + 1;
+			const rightX = this.state.boss.x + BOSS_WIDTH - 2;
+			const slots = maxBullets - this.state.invaderBullets.length;
+			if (slots >= 1) {
+				this.state.invaderBullets.push({
+					x: leftX,
+					y: bulletY,
+					from: "invader",
+					unblockable: bossEnraged,
+				});
+			}
+			if (slots >= 2 && rightX !== leftX) {
+				this.state.invaderBullets.push({
+					x: rightX,
+					y: bulletY,
+					from: "invader",
+					unblockable: bossEnraged,
+				});
+			}
+			this.state.invaderCooldown = bossFireDelayFor(this.state.level, this.state.boss);
+			return;
+		}
+
+		if (this.state.invaders.length === 0) return;
+
+		const fireChance = invaderFireChanceFor(this.state.invaders.length);
+		if (Math.random() > fireChance) {
+			this.state.invaderCooldown = 1;
+			return;
+		}
+
+		const shooters = new Map<number, Point>();
+		for (const invader of this.state.invaders) {
+			const existing = shooters.get(invader.x);
+			if (!existing || invader.y > existing.y) {
+				shooters.set(invader.x, invader);
+			}
+		}
+
+		const shooterList = Array.from(shooters.values());
+		if (shooterList.length === 0) return;
+		const shooter = shooterList[Math.floor(Math.random() * shooterList.length)];
+
+		this.state.invaderBullets.push({ x: shooter.x, y: shooter.y + 1, from: "invader" });
+		this.state.invaderCooldown = invaderFireDelayFor(this.state.level, this.state.invaders.length);
+	}
+
+	private maybeAdvanceWave(): void {
+		if (this.state.invaders.length > 0) return;
+		if (this.state.pendingWave) return;
+		this.state.pendingWave = true;
+		this.state.wavePauseTicks = READY_TICKS;
+		this.state.playerBullets = [];
+		this.state.invaderBullets = [];
+		this.state.playerMoveHold = 0;
+		this.state.playerMoveDir = 0;
+		this.state.ufo.active = false;
+	}
+
+	private startNextWave(): void {
+		this.state.level += 1;
+		this.state.invaders = createInvaders();
+		this.state.invaderDir = 1;
+		this.state.invaderFrame = 0;
+		this.state.invaderMoveDelay = invaderDelayFor(this.state.level, this.state.invaders.length);
+		this.state.invaderMoveCounter = 0;
+		this.state.invaderOffsetY = 0;
+		this.state.playerBullets = [];
+		this.state.invaderBullets = [];
+		this.state.playerCooldown = 0;
+		this.state.invaderCooldown = invaderFireDelayFor(this.state.level, this.state.invaders.length);
+		this.state.playerX = Math.floor(GAME_WIDTH / 2);
+		this.state.playerMoveDir = 0;
+		this.state.playerMoveHold = 0;
+		this.state.ufo = { x: 0, dir: 1, active: false };
+		this.state.ufoCooldown = UFO_BASE_COOLDOWN;
+		this.state.wavePauseTicks = 0;
+		this.state.pendingWave = false;
+	}
+
+	private togglePause(): void {
+		this.paused = !this.paused;
+		if (this.paused) {
+			this.stopLoop();
+		} else {
+			this.startLoop();
+		}
+		this.markDirty();
+	}
+
+	private restartGame(): void {
+		const highScore = this.state.highScore;
+		this.state = createInitialState(highScore);
+		this.paused = false;
+		this.stopLoop();
+		this.startLoop();
+		this.onSave(null);
+		this.markDirty();
+	}
+
+	handleInput(data: string): void {
+		if (this.state.bossIntroPhase) {
+			if (matchesKey(data, "escape")) {
+				this.dispose();
+				this.onSave(cloneState(this.state));
+				this.onClose();
+				return;
+			}
+			if (data === "q" || data === "Q") {
+				this.dispose();
+				this.onSave(null);
+				this.onClose();
+				return;
+			}
+			return;
+		}
+
+		if (this.registerCheatInput(data)) {
+			return;
+		}
+
+		if (this.paused) {
+			if (matchesKey(data, "escape") || data === "q" || data === "Q") {
+				this.dispose();
+				this.onClose();
+				return;
+			}
+			this.paused = false;
+			this.startLoop();
+			this.markDirty();
+			return;
+		}
+
+		if (matchesKey(data, "escape")) {
+			this.dispose();
+			this.onSave(cloneState(this.state));
+			this.onClose();
+			return;
+		}
+
+		if (data === "q" || data === "Q") {
+			this.dispose();
+			this.onSave(null);
+			this.onClose();
+			return;
+		}
+
+		if (this.state.gameOver && (data === "r" || data === "R" || data === " ")) {
+			this.restartGame();
+			return;
+		}
+
+		if (data === "p" || data === "P") {
+			this.togglePause();
+			return;
+		}
+
+		if (matchesKey(data, "left") || data === "a" || data === "A") {
+			this.queuePlayerMove(-1);
+			return;
+		}
+
+		if (matchesKey(data, "right") || data === "d" || data === "D") {
+			this.queuePlayerMove(1);
+			return;
+		}
+
+		if (data === " " && !this.state.gameOver) {
+			if (this.state.playerCooldown === 0 && this.state.playerBullets.length < MAX_PLAYER_BULLETS) {
+				this.state.playerBullets.push({ x: this.state.playerX, y: PLAYER_Y - 1, from: "player" });
+				this.state.playerCooldown = PLAYER_SHOT_DELAY;
+				this.markDirty();
+			}
+		}
+	}
+
+	invalidate(): void {
+		this.cachedWidth = 0;
+	}
+
+	render(width: number): string[] {
+		if (width === this.cachedWidth && this.cachedVersion === this.version) {
+			return this.cachedLines;
+		}
+
+		const maxCells = Math.floor((width - 2) / CELL_WIDTH);
+		if (maxCells < MIN_RENDER_CELLS) {
+			const message = "Lobster Invaders needs a wider terminal";
+			const line = truncateToWidth(message, width);
+			this.cachedLines = [line];
+			this.cachedWidth = width;
+			this.cachedVersion = this.version;
+			return this.cachedLines;
+		}
+
+		const renderWidth = Math.min(GAME_WIDTH, maxCells);
+		const boxWidth = renderWidth * CELL_WIDTH;
+
+		const color = (code: string, text: string) => `\x1b[${code}m${text}\x1b[0m`;
+		const dim = (text: string) => color("2", text);
+		const accent = (text: string) => color("1;31", text);
+		const scoreColor = (text: string) => color("33", text);
+		const livesColor = (text: string) => color("32", text);
+		const levelColor = (text: string) => color("35", text);
+		const invaderColor = (text: string) => color("31", text);
+		const bossEnraged = bossIsEnraged(this.state.boss);
+		const bossCellColor = (text: string, col: number) => {
+			if (!bossEnraged) return color("1;37", text);
+			const center = (BOSS_WIDTH - 1) / 2;
+			const dist = Math.abs(col - center);
+			const code = dist <= 0.75 ? "1;31" : dist <= 1.75 ? "31" : "2;31";
+			return color(code, text);
+		};
+		const bossBulletColor = (text: string) => color("95", text);
+		const playerColor = (text: string) => color("1;36", text);
+		const playerBulletColor = (text: string) => color("33", text);
+		const invaderBulletColor = (text: string) => color("31;1", text);
+		const ufoColor = (text: string) => color("1;37", text);
+
+		const lines: string[] = [];
+		const topBorder = dim(`+${"-".repeat(boxWidth)}+`);
+
+		lines.push(this.padLine(topBorder, width));
+
+		const titleLine = `${accent("LOBSTER INVADERS")}  ${dim(`Claws: ${this.state.invaders.length}`)}`;
+		const statsLine =
+			`Score: ${scoreColor(String(this.state.score))}  ` +
+			`Lives: ${livesColor(String(this.state.lives))}  ` +
+			`Level: ${levelColor(String(this.state.level))}  ` +
+			`High: ${dim(String(this.state.highScore))}`;
+
+		lines.push(this.padLine(this.boxLine(titleLine, boxWidth), width));
+		lines.push(this.padLine(this.boxLine(statsLine, boxWidth), width));
+		lines.push(this.padLine(this.boxLine(dim("-".repeat(boxWidth)), boxWidth), width));
+
+		const invaderMap = new Set(this.state.invaders.map((invader) => `${invader.x},${invader.y}`));
+		const scatterMap = new Set(this.state.scatterInvaders.map((invader) => `${invader.x},${invader.y}`));
+		const invaderBulletMap = new Set(this.state.invaderBullets.map((bullet) => `${bullet.x},${bullet.y}`));
+		const playerBulletMap = new Set(this.state.playerBullets.map((bullet) => `${bullet.x},${bullet.y}`));
+		const bossMap = new Map<string, string>();
+		const showBoss = this.state.boss.active || this.state.bossIntroPhase === "descend";
+		if (showBoss) {
+			const frame = BOSS_FRAMES[this.state.boss.frame];
+			for (let row = 0; row < BOSS_HEIGHT; row++) {
+				const y = this.state.boss.y + row;
+				if (y < 0 || y >= GAME_HEIGHT) continue;
+				for (let col = 0; col < BOSS_WIDTH; col++) {
+					const cell = frame[row][col] ?? "  ";
+					const key = `${this.state.boss.x + col},${y}`;
+					bossMap.set(key, bossCellColor(cell, col));
+				}
+			}
+		}
+
+		const invaderGlyph = invaderColor(this.state.invaderFrame === 0 ? "}{" : "><");
+		const playerGlyph = playerColor("/\\");
+		const playerBulletGlyph = playerBulletColor("||");
+		const invaderBulletGlyph = bossEnraged ? bossBulletColor("!!") : invaderBulletColor("!!");
+		const ufoGlyph = ufoColor("==");
+
+		for (let y = 0; y < GAME_HEIGHT; y++) {
+			let row = "";
+			for (let x = 0; x < renderWidth; x++) {
+				const key = `${x},${y}`;
+				if (this.state.ufo.active && y === UFO_Y && x === this.state.ufo.x) {
+					row += ufoGlyph;
+					continue;
+				}
+				if (playerBulletMap.has(key)) {
+					row += playerBulletGlyph;
+					continue;
+				}
+				if (invaderBulletMap.has(key)) {
+					row += invaderBulletGlyph;
+					continue;
+				}
+				const bossCell = bossMap.get(key);
+				if (bossCell) {
+					row += bossCell;
+					continue;
+				}
+				if (y === PLAYER_Y && x === this.state.playerX) {
+					row += playerGlyph;
+					continue;
+				}
+				if (scatterMap.has(key)) {
+					row += invaderGlyph;
+					continue;
+				}
+				if (invaderMap.has(key)) {
+					row += invaderGlyph;
+					continue;
+				}
+				row += "  ";
+			}
+			lines.push(this.padLine(`|${row}|`, width));
+		}
+
+		lines.push(this.padLine(this.boxLine(dim("-".repeat(boxWidth)), boxWidth), width));
+
+		let footer: string;
+		if (this.state.bossEnrageTicks > 0) {
+			footer = this.state.bossEnrageBlink ? accent("BOILING MAD LOBSTER") : "";
+		} else if (this.state.pendingWave && this.state.wavePauseTicks > 0) {
+			footer = `${accent("READY")} - Wave ${this.state.level + 1} incoming`;
+		} else if (this.paused) {
+			footer = `${accent("PAUSED")} - Press any key to resume, ${accent("Q")} to quit`;
+		} else if (this.state.gameOver) {
+			footer = `${color("31;1", "GAME OVER")} - Press ${accent("R")} to restart, ${accent("Q")} to quit`;
+		} else {
+			footer = `Left/Right or A/D move, ${accent("Space")} fire, ${accent("ESC")} save`;
+		}
+		lines.push(this.padLine(this.boxLine(footer, boxWidth), width));
+		lines.push(this.padLine(topBorder, width));
+
+		this.cachedLines = lines;
+		this.cachedWidth = width;
+		this.cachedVersion = this.version;
+
+		return lines;
+	}
+
+	private boxLine(content: string, width: number): string {
+		const truncated = truncateToWidth(content, width);
+		const padding = Math.max(0, width - visibleWidth(truncated));
+		return `|${truncated}${" ".repeat(padding)}|`;
+	}
+
+	private padLine(line: string, width: number): string {
+		const truncated = truncateToWidth(line, width);
+		const padding = Math.max(0, width - visibleWidth(truncated));
+		return truncated + " ".repeat(padding);
+	}
+
+	dispose(): void {
+		this.stopLoop();
+	}
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("spice-invaders", {
+		description: "Play Lobster Invaders!",
+		handler: async (_args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("Lobster Invaders requires interactive mode", "error");
+				return;
+			}
+
+			const entries = ctx.sessionManager.getEntries();
+			let savedState: GameState | undefined;
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				if (entry.type === "custom" && entry.customType === SPACE_INVADERS_SAVE_TYPE) {
+					savedState = entry.data as GameState;
+					break;
+				}
+			}
+
+			await ctx.ui.custom((tui, _theme, _kb, done) => {
+				return new SpaceInvadersComponent(
+					tui,
+					() => done(undefined),
+					(state) => {
+						pi.appendEntry(SPACE_INVADERS_SAVE_TYPE, state);
+					},
+					savedState,
+				);
+			});
+		},
+	});
+}