pi-extensions 0.1.9

package/arcade/mario-not/mario-not.ts

@@ -0,0 +1,297 @@
+/**
+ * Mario-Not - a Mario-style TUI platformer. Play with /mario-not
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+const {
+	createGame,
+	stepGame,
+	renderViewport,
+	renderHud,
+	saveState,
+	loadState,
+	setPaused,
+	makeLevel,
+} = require("./engine.js") as typeof import("./engine.js");
+const { ALL_LEVELS } = require("./levels.js") as typeof import("./levels.js");
+const { COLORS } = require("./colors.js") as { COLORS: Record<string, string> };
+const { DEFAULT_CONFIG, LEVEL_INTRO_TIME } = require("./constants.js") as typeof import("./constants.js");
+
+const TICK_MS = 25;
+const VIEWPORT_W = 40;
+const VIEWPORT_H = 15;
+const HUD_LINES = 2;
+const SAVE_TYPE = "mario-not-save";
+const FRAME_INNER_WIDTH = 36;
+const START_X = 1;
+const START_Y = 13;
+
+// Level metadata: name and theme color
+const LEVEL_META: { name: string; frameColor: string; textColor: string }[] = [
+	{ name: "WORLD 1-1", frameColor: COLORS.yellow, textColor: COLORS.cyan },
+	{ name: "WORLD 1-2", frameColor: COLORS.yellow, textColor: COLORS.cyan },
+	{ name: "WORLD 1-3", frameColor: COLORS.yellow, textColor: COLORS.cyan },
+	{ name: "BOWSER'S CASTLE", frameColor: COLORS.red, textColor: COLORS.red },
+];
+
+class MarioNotComponent {
+	private readonly tui: any;
+	private readonly onClose: () => void;
+	private readonly onSave: (state: any) => void;
+	private interval: NodeJS.Timeout | null = null;
+	private state: any;
+	private version = 0;
+	private cache = { lines: [] as string[], width: 0, version: -1 };
+	private moveDir = 0;
+	private runHeld = true;
+	private jumpQueued = false;
+	private autosaveTimer = 0;
+	private levelClearTimer = 0;
+	private introTimer = 0;
+	private shownHazardAdvice = false;
+	private readonly config: any;
+
+	constructor(tui: any, onClose: () => void, onSave: (state: any) => void, saved?: any) {
+		this.tui = tui;
+		this.onClose = onClose;
+		this.onSave = onSave;
+
+		// Override default config with game-specific values
+		this.config = {
+			...DEFAULT_CONFIG,
+			dt: TICK_MS / 1000,
+			viewportWidth: VIEWPORT_W,
+			walkSpeed: 5.2,
+			runSpeed: 9.0,
+			groundAccel: 70,
+			groundDecel: 56,
+			airAccel: 48,
+			gravity: 35,
+			maxFall: 15,
+			jumpVel: 15,
+		};
+		const restored = saved ? loadState(saved, { config: this.config }) : null;
+		if (restored) {
+			this.state = restored;
+		} else {
+			this.state = createGame({ level: makeLevel(ALL_LEVELS[0]), startX: START_X, startY: START_Y, config: this.config, levelIndex: 1 });
+			this.state.mode = "level_intro";
+			this.introTimer = 0;
+		}
+
+		this.interval = setInterval(() => this.tick(), TICK_MS);
+	}
+
+	private tick(): void {
+		// Handle level intro
+		if (this.state.mode === "level_intro") {
+			this.introTimer += TICK_MS / 1000;
+			if (this.introTimer >= LEVEL_INTRO_TIME) {
+				this.state.mode = "playing";
+				this.introTimer = 0;
+			}
+			this.version += 1;
+			this.tui.requestRender();
+			return;
+		}
+
+		const input: any = {};
+		if (this.moveDir < 0) input.left = true;
+		if (this.moveDir > 0) input.right = true;
+		if (this.runHeld) input.run = true;
+		if (this.jumpQueued) input.jump = true;
+		this.jumpQueued = false;
+
+		const wasPlaying = this.state.mode === "playing";
+		const prevSize = this.state.player.size;
+		stepGame(this.state, input);
+
+		// Show hazard advice on first death/damage in level 4 (castle with lava/fireballs)
+		if (!this.shownHazardAdvice && this.state.levelIndex === 4 && wasPlaying) {
+			const tookDamage = this.state.mode === "dead" || (prevSize === "big" && this.state.player.size === "small");
+			if (tookDamage) {
+				this.shownHazardAdvice = true;
+				this.state.cue = { text: "TIP: [X] Walk  [S/Down/J] Stop", ttl: 3.0, persist: false };
+			}
+		}
+
+		if (this.state.mode === "playing") {
+			this.autosaveTimer += TICK_MS / 1000;
+			if (this.autosaveTimer >= 5) {
+				this.onSave(saveState(this.state));
+				this.autosaveTimer = 0;
+			}
+		}
+
+		// Handle level transition
+		if (this.state.mode === "level_clear") {
+			this.levelClearTimer += TICK_MS / 1000;
+			if (this.levelClearTimer >= 2) {
+				const nextLevel = this.state.levelIndex + 1;
+				if (nextLevel <= ALL_LEVELS.length) {
+					this.goToLevel(nextLevel, true);
+				} else {
+					this.state.mode = "victory";
+				}
+			}
+		}
+
+		this.version += 1;
+		this.tui.requestRender();
+	}
+
+	private goToLevel(levelNum: number, keepProgress = false): void {
+		if (levelNum < 1 || levelNum > ALL_LEVELS.length) return;
+		const prev = this.state;
+		this.state = createGame({
+			level: makeLevel(ALL_LEVELS[levelNum - 1]),
+			startX: START_X,
+			startY: START_Y,
+			config: this.config,
+			levelIndex: levelNum,
+		});
+		if (keepProgress) {
+			this.state.score = prev.score;
+			this.state.coins = prev.coins;
+			this.state.lives = prev.lives;
+			this.state.player.size = prev.player.size;
+		}
+		this.state.mode = "level_intro";
+		this.introTimer = 0;
+		this.levelClearTimer = 0;
+		this.version += 1;
+		this.tui.requestRender();
+	}
+
+	private restart(): void {
+		this.goToLevel(this.state.levelIndex);
+	}
+
+	handleInput(key: string): boolean {
+		if (matchesKey(key, "escape") || key === "q" || key === "Q") {
+			this.onSave(saveState(this.state));
+			this.onClose();
+		} else if (key >= "1" && key <= "9") {
+			this.goToLevel(parseInt(key, 10));
+		} else if (key === "r" || key === "R") {
+			this.restart();
+		} else if (key === "p" || key === "P") {
+			const paused = this.state.mode === "paused";
+			setPaused(this.state, !paused);
+			if (this.state.mode === "paused") this.onSave(saveState(this.state));
+			this.version += 1;
+			this.tui.requestRender();
+		} else if (key === "x" || key === "X") {
+			this.runHeld = !this.runHeld;
+		} else if (matchesKey(key, "up") || key === " " || key === "z" || key === "Z" || key === "k" || key === "K") {
+			this.jumpQueued = true;
+		} else if (matchesKey(key, "left") || key === "a" || key === "A" || key === "h" || key === "H") {
+			this.moveDir = -1;
+		} else if (matchesKey(key, "right") || key === "d" || key === "l" || key === "D" || key === "L") {
+			this.moveDir = 1;
+		} else if (matchesKey(key, "down") || key === "s" || key === "S" || key === "j" || key === "J") {
+			this.moveDir = 0;
+		}
+		return true;
+	}
+
+	render(width: number, height: number): string[] {
+		const pad = (line: string) => {
+			const truncated = truncateToWidth(line, width);
+			const padding = Math.max(0, width - visibleWidth(truncated));
+			return truncated + " ".repeat(padding);
+		};
+
+		const minWidth = VIEWPORT_W * 2;
+		const minHeight = VIEWPORT_H + HUD_LINES + 2;
+		if (width < minWidth || height < minHeight) {
+			return [
+				"",
+				pad("MARIO-NOT"),
+				"",
+				pad("Terminal too small"),
+				pad(`Need ${minWidth} cols, ${minHeight} rows`),
+				"",
+				pad("[Q] Quit"),
+			];
+		}
+
+		if (this.cache.version === this.version && this.cache.width === width) return this.cache.lines;
+
+		const lines: string[] = [];
+
+		// Level intro screen with cool frame
+		if (this.state.mode === "level_intro") {
+			const levelNum = this.state.levelIndex;
+			const levelId = `1-${levelNum}`;
+			const meta = LEVEL_META[levelNum - 1] || LEVEL_META[0];
+			const { name: levelName, frameColor, textColor } = meta;
+			const emptyRow = " ".repeat(FRAME_INNER_WIDTH);
+
+			const livesDisplay = `${textColor}<>  x ${this.state.lives}${COLORS.reset}`;
+			const livesLen = 6 + this.state.lives.toString().length;
+
+			// Center content in frame (accounting for color codes)
+			const centerText = (text: string, visLen: number) => {
+				const leftPad = Math.floor((FRAME_INNER_WIDTH - visLen) / 2);
+				const rightPad = FRAME_INNER_WIDTH - visLen - leftPad;
+				return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+			};
+
+			// Build retro frame
+			lines.push("");
+			lines.push("");
+			lines.push(pad(`${frameColor}╔${"═".repeat(FRAME_INNER_WIDTH)}╗${COLORS.reset}`));
+			lines.push(pad(`${frameColor}║${COLORS.reset}${emptyRow}${frameColor}║${COLORS.reset}`));
+			lines.push(pad(`${frameColor}║${COLORS.reset}${centerText(`${textColor}${levelName}${COLORS.reset}`, levelName.length)}${frameColor}║${COLORS.reset}`));
+			lines.push(pad(`${frameColor}║${COLORS.reset}${emptyRow}${frameColor}║${COLORS.reset}`));
+			lines.push(pad(`${frameColor}║${COLORS.reset}${centerText(`${textColor}${levelId}${COLORS.reset}`, 3)}${frameColor}║${COLORS.reset}`));
+			lines.push(pad(`${frameColor}║${COLORS.reset}${emptyRow}${frameColor}║${COLORS.reset}`));
+			lines.push(pad(`${frameColor}║${COLORS.reset}${centerText(livesDisplay, livesLen)}${frameColor}║${COLORS.reset}`));
+			lines.push(pad(`${frameColor}║${COLORS.reset}${emptyRow}${frameColor}║${COLORS.reset}`));
+			lines.push(pad(`${frameColor}╚${"═".repeat(FRAME_INNER_WIDTH)}╝${COLORS.reset}`));
+			lines.push("");
+			lines.push(pad(`${COLORS.gray}[1-4] Select level${COLORS.reset}`));
+			lines.push("");
+
+			this.cache = { lines, width, version: this.version };
+			return lines;
+		}
+
+		lines.push(...renderHud(this.state, minWidth).split("\n").map(pad));
+		lines.push(...renderViewport(this.state, VIEWPORT_W, VIEWPORT_H).split("\n").map(pad));
+		lines.push("");
+		const toggleHint = this.runHeld ? "[X] Walk" : "[X] Run";
+		lines.push(pad(`[Arrows/HJKL] Move  [Space/K] Jump  ${toggleHint}  [P] Pause  [R] Restart  [1-4] Level  [Q] Quit`));
+		if (this.state.mode === "game_over") lines.push(pad("GAME OVER - [Q] Quit"));
+		if (this.state.mode === "victory") lines.push(pad("YOU WIN! Final Score: " + this.state.score + " - [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("mario-not", {
+		description: "Play Mario-Not (Mario-style platformer)!",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("Mario-Not 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 any | undefined;
+
+			await ctx.ui.custom((tui, _theme, _kb, done) =>
+				new MarioNotComponent(tui, () => done(undefined), (state) => api.appendEntry(SAVE_TYPE, state), saved)
+			);
+		},
+	});
+}

package/arcade/mario-not/player.js

@@ -0,0 +1,244 @@
+// @ts-check
+"use strict";
+
+const { getTile, setTile, isHazardAt } = require("./tiles.js");
+const { spawnParticles, setCue } = require("./effects.js");
+const { enterDeath } = require("./death.js");
+const { moveHorizontal, resolveVertical, overlaps } = require("./collision.js");
+const {
+	SCORE_VALUES,
+	PLAYER_W,
+	PLAYER_H_SMALL,
+	PLAYER_H_BIG,
+	ITEM_W,
+	ITEM_H,
+	ITEM_SPEED,
+	INVULN_TIME,
+	GAME_MODES,
+} = require("./constants.js");
+
+/** @typedef {import("./types").GameState} GameState */
+/** @typedef {import("./types").InputState} InputState */
+/** @typedef {import("./types").PlayerState} PlayerState */
+
+/** @param {PlayerState} player @returns {number} */
+function getPlayerHeight(player) {
+	return player.size === "big" ? PLAYER_H_BIG : PLAYER_H_SMALL;
+}
+
+/** @param {GameState} state @param {InputState} [input] @returns {{ prevY: number, height: number }} */
+function stepPlayerMovement(state, input) {
+	const cfg = state.config;
+	const dt = cfg.dt;
+	const player = state.player;
+	const prevY = player.y;
+
+	if (player.invuln > 0) {
+		player.invuln = Math.max(0, player.invuln - dt);
+	}
+
+	const moveLeft = !!(input && input.left);
+	const moveRight = !!(input && input.right);
+	const jump = !!(input && input.jump);
+	const run = !!(input && input.run);
+	let move = 0;
+	if (moveLeft) move -= 1;
+	if (moveRight) move += 1;
+	if (move !== 0) player.facing = move;
+
+	const accel = player.onGround ? cfg.groundAccel : cfg.airAccel;
+	const maxSpeed = run ? cfg.runSpeed : cfg.walkSpeed;
+	if (move !== 0) {
+		const target = move * maxSpeed;
+		const delta = accel * dt;
+		if (player.vx < target) player.vx = Math.min(player.vx + delta, target);
+		else if (player.vx > target) player.vx = Math.max(player.vx - delta, target);
+	} else if (player.onGround) {
+		const delta = cfg.groundDecel * dt;
+		if (Math.abs(player.vx) <= delta) player.vx = 0;
+		else player.vx -= Math.sign(player.vx) * delta;
+	}
+
+	if (jump && player.onGround) {
+		player.vy = -cfg.jumpVel;
+		player.onGround = false;
+	}
+
+	player.vy = Math.min(player.vy + cfg.gravity * dt, cfg.maxFall);
+
+	const height = getPlayerHeight(player);
+	const blocked = moveHorizontal(state.level, player, dt, PLAYER_W, height);
+	if (blocked) player.vx = 0;
+
+	/** @param {number} tileX @param {number} tileY */
+	const onHeadBump = (tileX, tileY) => {
+		handleHeadBump(state, tileX, tileY);
+	};
+	resolveVertical(state.level, player, dt, onHeadBump, height, PLAYER_W, true);
+
+	return { prevY, height };
+}
+
+/** @param {GameState} state */
+function collectCoin(state) {
+	const tileX = Math.floor(state.player.x);
+	const tileY = Math.floor(state.player.y);
+	if (getTile(state.level, tileX, tileY) === "o") {
+		setTile(state.level, tileX, tileY, " ");
+		awardCoin(state);
+	}
+}
+
+/** @param {GameState} state */
+function collectItems(state) {
+	const player = state.player;
+	const height = getPlayerHeight(player);
+
+	state.items = state.items.filter((item) => {
+		if (!item.alive) return false;
+		if (!overlaps(player.x, player.y, PLAYER_W, height, item.x, item.y, ITEM_W, ITEM_H)) {
+			return true; // Keep item
+		}
+		// Collected - apply effect
+		if (player.size === "small") {
+			player.size = /** @type {"small" | "big"} */ ("big");
+			player.invuln = INVULN_TIME;
+			setCue(state, "POWER UP", 0.6, false);
+		} else {
+			awardScore(state, SCORE_VALUES.mushroom);
+		}
+		spawnParticles(state, player.x, player.y - 0.2, 4);
+		return false; // Remove item
+	});
+}
+
+/** @param {GameState} state @param {number} tileX @param {number} tileY */
+function handleHeadBump(state, tileX, tileY) {
+	const tile = getTile(state.level, tileX, tileY);
+	if (tile === "?") {
+		setTile(state.level, tileX, tileY, "U");
+		spawnMushroom(state, tileX, tileY);
+	}
+}
+
+/** @param {GameState} state @param {number} prevY */
+function resolveEnemyCollisions(state, prevY) {
+	const player = state.player;
+	const height = getPlayerHeight(player);
+	const prevBottom = prevY + height;
+	const currBottom = player.y + height;
+	const falling = currBottom > prevBottom + 0.0001;
+	for (const enemy of state.enemies) {
+		if (!enemy.alive) continue;
+		if (overlaps(player.x, player.y, PLAYER_W, height, enemy.x, enemy.y, 1, 1)) {
+			const stomp = falling && prevBottom <= enemy.y + 0.01 && currBottom >= enemy.y;
+			if (stomp) {
+				enemy.alive = false;
+				player.vy = -state.config.jumpVel * 0.6;
+				awardScore(state, SCORE_VALUES.stomp);
+				spawnParticles(state, enemy.x, enemy.y - 0.2, 4);
+			} else {
+				applyPlayerDamage(state);
+			}
+		}
+	}
+}
+
+/** @param {GameState} state @param {boolean} [forceDeath] */
+function applyPlayerDamage(state, forceDeath) {
+	const player = state.player;
+	if (state.mode !== GAME_MODES.playing) return;
+	if (player.invuln > 0) return;
+	if (!forceDeath && player.size === "big") {
+		player.size = /** @type {"small" | "big"} */ ("small");
+		player.invuln = INVULN_TIME;
+		return;
+	}
+	enterDeath(state);
+}
+
+/** @param {GameState} state @param {number} height */
+function checkGoal(state, height) {
+	if (state.mode !== GAME_MODES.playing) return;
+	const player = state.player;
+	const leftX = player.x + 0.001;
+	const rightX = player.x + PLAYER_W - 0.001;
+	const topY = player.y - (height - 1);
+	/** @param {string} tile */
+	const isGoal = (tile) => tile === "G" || tile === "F";
+
+	// Find which position touched the goal
+	let touchX = -1;
+	let touchY = -1;
+	if (isGoal(getTile(state.level, leftX, player.y))) { touchX = Math.floor(leftX); touchY = Math.floor(player.y); }
+	else if (isGoal(getTile(state.level, rightX, player.y))) { touchX = Math.floor(rightX); touchY = Math.floor(player.y); }
+	else if (isGoal(getTile(state.level, leftX, topY))) { touchX = Math.floor(leftX); touchY = Math.floor(topY); }
+	else if (isGoal(getTile(state.level, rightX, topY))) { touchX = Math.floor(rightX); touchY = Math.floor(topY); }
+
+	if (touchX < 0) return;
+
+	// Find top and bottom of flagpole
+	let poleTop = touchY;
+	let poleBottom = touchY;
+	while (poleTop > 0 && isGoal(getTile(state.level, touchX, poleTop - 1))) poleTop--;
+	while (poleBottom < state.level.height - 1 && isGoal(getTile(state.level, touchX, poleBottom + 1))) poleBottom++;
+
+	// Calculate flagpole score: higher = more points (100-5000)
+	const poleHeight = poleBottom - poleTop + 1;
+	const touchHeight = poleBottom - touchY; // 0 at bottom, poleHeight-1 at top
+	const heightRatio = poleHeight > 1 ? touchHeight / (poleHeight - 1) : 1;
+	const flagScore = Math.floor(100 + heightRatio * 4900);
+
+	// Time bonus: 10 points per second remaining
+	const timeBonus = Math.floor(state.time) * 10;
+
+	const totalBonus = flagScore + timeBonus;
+	state.score += totalBonus;
+
+	player.vx = 0;
+	player.vy = 0;
+	setCue(state, `+${totalBonus}`, 0, true);
+	state.mode = GAME_MODES.levelClear;
+}
+
+/** @param {GameState} state @returns {boolean} */
+function checkHazard(state) {
+	return isHazardAt(state.level, state.player.x, state.player.y);
+}
+
+/** @param {GameState} state @param {number} tileX @param {number} tileY */
+function spawnMushroom(state, tileX, tileY) {
+	const spawnX = tileX;
+	const spawnY = tileY - 1;
+	state.items.push({
+		x: spawnX,
+		y: spawnY,
+		vx: ITEM_SPEED,
+		vy: 0,
+		alive: true,
+		onGround: false,
+	});
+}
+
+/** @param {GameState} state */
+function awardCoin(state) {
+	state.coins += 1;
+	state.score += SCORE_VALUES.coin;
+	spawnParticles(state, state.player.x, state.player.y - 0.2, 4);
+}
+
+/** @param {GameState} state @param {number} value */
+function awardScore(state, value) {
+	state.score += value;
+}
+
+module.exports = {
+	applyPlayerDamage,
+	checkGoal,
+	checkHazard,
+	collectCoin,
+	collectItems,
+	getPlayerHeight,
+	resolveEnemyCollisions,
+	stepPlayerMovement,
+};