pi-extensions 0.1.9

package/arcade/mario-not/constants.js

@@ -0,0 +1,97 @@
+// @ts-check
+"use strict";
+
+/** @type {import("./types").Config} */
+const DEFAULT_CONFIG = {
+	dt: 1 / 60,
+	gravity: 22,
+	maxFall: 9,
+	jumpVel: 12,
+	walkSpeed: 3,
+	runSpeed: 4.2,
+	groundAccel: 35,
+	groundDecel: 30,
+	airAccel: 22,
+	enemySpeed: 1,
+	mushroomScore: 1000,
+	viewportWidth: 40,
+};
+
+const SCORE_VALUES = {
+	coin: 100,
+	stomp: 50,
+	mushroom: 1000,
+	flagMin: 100,
+	flagMax: 5000,
+	timeBonus: 10,  // per second remaining
+};
+
+const PLAYER_W = 1;
+const PLAYER_H_SMALL = 1;
+const PLAYER_H_BIG = 2;
+const ENEMY_W = 1;
+const ENEMY_H = 1;
+const ITEM_W = 1;
+const ITEM_H = 1;
+const ITEM_SPEED = 1.2;
+const INVULN_TIME = 1.2;
+const START_LIVES = 3;
+const START_TIME = 300;
+const DEATH_WAIT = 1.2;
+const DEATH_JUMP_VEL = 14;
+
+/** @type {{ playing: "playing", paused: "paused", dead: "dead", levelClear: "level_clear", gameOver: "game_over", levelIntro: "level_intro" }} */
+const GAME_MODES = {
+	playing: "playing",
+	paused: "paused",
+	dead: "dead",
+	levelClear: "level_clear",
+	gameOver: "game_over",
+	levelIntro: "level_intro",
+};
+
+const LEVEL_INTRO_TIME = 2.0;
+
+// Fireball constants
+const FIREBALL_SPEED = 4;
+const FIREBALL_WAVE_AMP = 1.5;
+const FIREBALL_WAVE_FREQ = 4;
+const FIREBALL_SPAWN_INTERVAL = 3.0;
+
+// Boss constants
+const BOSS_W = 2;
+const BOSS_H = 2;
+const BOSS_SPEED = 1.5;
+const BOSS_HEALTH = 5;
+const BOSS_INVULN_TIME = 0.8;
+const BOSS_SCORE = 5000;
+
+module.exports = {
+	DEFAULT_CONFIG,
+	SCORE_VALUES,
+	PLAYER_W,
+	PLAYER_H_SMALL,
+	PLAYER_H_BIG,
+	ENEMY_W,
+	ENEMY_H,
+	ITEM_W,
+	ITEM_H,
+	ITEM_SPEED,
+	INVULN_TIME,
+	START_LIVES,
+	START_TIME,
+	DEATH_WAIT,
+	DEATH_JUMP_VEL,
+	GAME_MODES,
+	LEVEL_INTRO_TIME,
+	FIREBALL_SPEED,
+	FIREBALL_WAVE_AMP,
+	FIREBALL_WAVE_FREQ,
+	FIREBALL_SPAWN_INTERVAL,
+	BOSS_W,
+	BOSS_H,
+	BOSS_SPEED,
+	BOSS_HEALTH,
+	BOSS_INVULN_TIME,
+	BOSS_SCORE,
+};

package/arcade/mario-not/core.js

@@ -0,0 +1,39 @@
+// @ts-check
+"use strict";
+
+/** @typedef {import("./types").Level} Level */
+
+/** @param {number} seed @returns {() => number} */
+function createRng(seed) {
+	let t = seed >>> 0;
+	return function next() {
+		t += 0x6D2B79F5;
+		let r = t;
+		r = Math.imul(r ^ (r >>> 15), r | 1);
+		r ^= r + Math.imul(r ^ (r >>> 7), r | 61);
+		return ((r ^ (r >>> 14)) >>> 0) / 4294967296;
+	};
+}
+
+/** @param {string[]} lines @returns {Level} */
+function makeLevel(lines) {
+	if (!Array.isArray(lines) || lines.length === 0) {
+		throw new Error("Level must be a non-empty array of strings.");
+	}
+	const width = lines[0].length;
+	for (const line of lines) {
+		if (line.length !== width) {
+			throw new Error("All level rows must be the same width.");
+		}
+	}
+	return {
+		width,
+		height: lines.length,
+		tiles: lines.map((line) => line.split("")),
+	};
+}
+
+module.exports = {
+	createRng,
+	makeLevel,
+};

package/arcade/mario-not/death.js

@@ -0,0 +1,77 @@
+// @ts-check
+"use strict";
+
+const { isSolidAt } = require("./tiles.js");
+const { setCue } = require("./effects.js");
+const { INVULN_TIME, DEATH_WAIT, DEATH_JUMP_VEL, GAME_MODES } = require("./constants.js");
+
+/** @typedef {import("./types").GameState} GameState */
+
+/** @param {GameState} state */
+function enterDeath(state) {
+	if (state.mode === GAME_MODES.dead || state.mode === GAME_MODES.gameOver) return;
+	state.mode = GAME_MODES.dead;
+	state.lives = Math.max(0, state.lives - 1);
+	state.deathTimer = 0;
+	state.deathJumped = false;
+	state.player.vx = 0;
+	state.player.vy = 0;
+	state.player.onGround = false;
+}
+
+/** @param {GameState} state */
+function respawnPlayer(state) {
+	const player = state.player;
+	player.x = state.spawnX;
+	player.y = state.spawnY;
+	player.vx = 0;
+	player.vy = 0;
+	player.facing = 1;
+	player.onGround = isSolidAt(state.level, player.x, player.y + 1);
+	player.invuln = INVULN_TIME;
+	state.deathTimer = 0;
+	state.deathJumped = false;
+	state.mode = GAME_MODES.playing;
+}
+
+/** @param {GameState} state */
+function setGameOver(state) {
+	state.mode = GAME_MODES.gameOver;
+	state.deathTimer = 0;
+	state.deathJumped = false;
+	state.player.vx = 0;
+	state.player.vy = 0;
+	setCue(state, "GAME OVER", 0, true);
+}
+
+/** @param {GameState} state @param {number} dt @returns {GameState} */
+function stepDeath(state, dt) {
+	const player = state.player;
+	state.deathTimer += dt;
+	if (state.deathTimer < DEATH_WAIT) {
+		state.tick += 1;
+		return state;
+	}
+	if (!state.deathJumped) {
+		state.deathJumped = true;
+		player.vy = -DEATH_JUMP_VEL;
+	}
+	player.vy = Math.min(player.vy + state.config.gravity * dt, state.config.maxFall);
+	player.y += player.vy * dt;
+	if (player.y > state.level.height + 2) {
+		if (state.lives <= 0) {
+			setGameOver(state);
+		} else {
+			respawnPlayer(state);
+		}
+	}
+	state.tick += 1;
+	return state;
+}
+
+module.exports = {
+	enterDeath,
+	respawnPlayer,
+	setGameOver,
+	stepDeath,
+};

package/arcade/mario-not/effects.js

@@ -0,0 +1,84 @@
+// @ts-check
+"use strict";
+
+/**
+ * @typedef {Object} Particle
+ * @property {number} x
+ * @property {number} y
+ * @property {number} vx
+ * @property {number} vy
+ * @property {number} life
+ */
+
+/**
+ * @typedef {Object} Cue
+ * @property {string} text
+ * @property {number} ttl
+ * @property {boolean} persist
+ */
+
+/**
+ * @typedef {Object} Config
+ * @property {number} gravity
+ */
+
+/**
+ * @typedef {Object} GameState
+ * @property {Config} config
+ * @property {Particle[]} particles
+ * @property {Cue | null} cue
+ */
+
+const PARTICLE_VELOCITIES = [
+	{ vx: -0.5, vy: -1.0 },
+	{ vx: 0.5, vy: -1.0 },
+	{ vx: -0.3, vy: -0.6 },
+	{ vx: 0.3, vy: -0.6 },
+];
+const PARTICLE_LIFE = 0.35;
+
+/** @param {GameState} state @param {number} x @param {number} y @param {number} count */
+function spawnParticles(state, x, y, count) {
+	for (let i = 0; i < count; i += 1) {
+		const vel = PARTICLE_VELOCITIES[i % PARTICLE_VELOCITIES.length];
+		state.particles.push({
+			x,
+			y,
+			vx: vel.vx,
+			vy: vel.vy,
+			life: PARTICLE_LIFE,
+		});
+	}
+}
+
+/** @param {GameState} state @param {number} dt */
+function updateParticles(state, dt) {
+	const gravity = state.config.gravity * 0.2;
+	for (let i = state.particles.length - 1; i >= 0; i -= 1) {
+		const p = state.particles[i];
+		p.vy += gravity * dt;
+		p.x += p.vx * dt;
+		p.y += p.vy * dt;
+		p.life -= dt;
+		if (p.life <= 0) state.particles.splice(i, 1);
+	}
+}
+
+/** @param {GameState} state @param {string} text @param {number} ttl @param {boolean} persist */
+function setCue(state, text, ttl, persist) {
+	state.cue = { text, ttl, persist };
+}
+
+/** @param {GameState} state @param {number} dt */
+function updateCue(state, dt) {
+	if (!state.cue || state.cue.persist) return;
+	state.cue.ttl -= dt;
+	if (state.cue.ttl <= 0) state.cue = null;
+}
+
+module.exports = {
+	spawnParticles,
+	updateParticles,
+	setCue,
+	updateCue,
+};

package/arcade/mario-not/enemies.js

@@ -0,0 +1,31 @@
+// @ts-check
+"use strict";
+
+const { moveHorizontal, resolveVertical } = require("./collision.js");
+const { ENEMY_W, ENEMY_H } = require("./constants.js");
+
+/** @typedef {import("./types").GameState} GameState */
+/** @typedef {import("./types").Level} Level */
+/** @typedef {import("./types").EnemyState} EnemyState */
+
+/** @param {GameState} state */
+function updateEnemies(state) {
+	const cfg = state.config;
+	for (const enemy of state.enemies) {
+		if (!enemy.alive) continue;
+		updateEnemy(state.level, enemy, cfg);
+	}
+}
+
+/** @param {Level} level @param {EnemyState} enemy @param {import("./types").Config} cfg */
+function updateEnemy(level, enemy, cfg) {
+	enemy.vy = Math.min(enemy.vy + cfg.gravity * cfg.dt, cfg.maxFall);
+	const blocked = moveHorizontal(level, enemy, cfg.dt, ENEMY_W, ENEMY_H);
+	if (blocked) enemy.vx = -enemy.vx;
+	resolveVertical(level, enemy, cfg.dt, undefined, ENEMY_H, ENEMY_W, true);
+	if (enemy.y >= level.height + 1) enemy.alive = false;
+}
+
+module.exports = {
+	updateEnemies,
+};

package/arcade/mario-not/engine.js

@@ -0,0 +1,171 @@
+// @ts-check
+"use strict";
+
+const { createRng, makeLevel } = require("./core.js");
+const { DEFAULT_CONFIG, START_LIVES, START_TIME, GAME_MODES, FIREBALL_SPAWN_INTERVAL } = require("./constants.js");
+const { renderFrame, renderViewport, renderHud } = require("./render.js");
+const { getCameraX, updateCamera } = require("./camera.js");
+const { stepGame, setPaused } = require("./logic.js");
+const { saveState, loadState, snapshotState } = require("./state.js");
+const { isSolidAt } = require("./tiles.js");
+
+/** @typedef {import("./types").GameState} GameState */
+/** @typedef {import("./types").GameOptions} GameOptions */
+/** @typedef {import("./types").Level} Level */
+
+/**
+ * @param {Level} level
+ * @returns {{
+ *   level: Level,
+ *   enemies: import("./types").EnemyState[],
+ *   fireballSpawners: import("./types").FireballSpawner[],
+ *   boss: import("./types").BossState | null
+ * }}
+ */
+function extractEntities(level) {
+	const tiles = level.tiles.map((row) => row.slice());
+	/** @type {import("./types").EnemyState[]} */
+	const enemies = [];
+	/** @type {import("./types").FireballSpawner[]} */
+	const fireballSpawners = [];
+	/** @type {import("./types").BossState | null} */
+	let boss = null;
+
+	for (let y = 0; y < level.height; y += 1) {
+		for (let x = 0; x < level.width; x += 1) {
+			const tile = tiles[y][x];
+			if (tile === "E") {
+				enemies.push({
+					x,
+					y,
+					vx: -1,
+					vy: 0,
+					alive: true,
+					onGround: false,
+				});
+				tiles[y][x] = " ";
+			} else if (tile === "<") {
+				// Fireball spawner shooting left
+				fireballSpawners.push({
+					x,
+					y,
+					timer: 0,
+					interval: FIREBALL_SPAWN_INTERVAL,
+					direction: -1,
+				});
+				tiles[y][x] = " ";
+			} else if (tile === ">") {
+				// Fireball spawner shooting right
+				fireballSpawners.push({
+					x,
+					y,
+					timer: 0,
+					interval: FIREBALL_SPAWN_INTERVAL,
+					direction: 1,
+				});
+				tiles[y][x] = " ";
+			} else if (tile === "W") {
+				// Boss (Bowser)
+				boss = {
+					x,
+					y,
+					vx: -1.5,
+					vy: 0,
+					alive: true,
+					health: 5,
+					maxHealth: 5,
+					invuln: 0,
+					onGround: false,
+				};
+				tiles[y][x] = " ";
+			}
+		}
+	}
+	return {
+		level: {
+			width: level.width,
+			height: level.height,
+			tiles,
+		},
+		enemies,
+		fireballSpawners,
+		boss,
+	};
+}
+
+/** @param {GameOptions} options @returns {GameState} */
+function createGame(options) {
+	const opts = options || {};
+	const level = opts.level;
+	if (!level) throw new Error("createGame requires a level.");
+	const config = { ...DEFAULT_CONFIG, ...(opts.config || {}) };
+	const rng = createRng(opts.seed || 1);
+	const startX = typeof opts.startX === "number" ? opts.startX : 1;
+	const startY = typeof opts.startY === "number" ? opts.startY : 1;
+	const extracted = extractEntities(level);
+	const enemies = extracted.enemies.map((enemy) => {
+		const seeded = { ...enemy, vx: -config.enemySpeed };
+		seeded.onGround = isSolidAt(extracted.level, seeded.x, seeded.y + 1);
+		return seeded;
+	});
+	// Initialize boss if present
+	const boss = extracted.boss;
+	if (boss) {
+		boss.onGround = isSolidAt(extracted.level, boss.x, boss.y + 1);
+	}
+	/** @type {GameState} */
+	const state = {
+		level: extracted.level,
+		rng,
+		config,
+		tick: 0,
+		score: 0,
+		coins: 0,
+		lives: START_LIVES,
+		time: START_TIME,
+		levelIndex: typeof opts.levelIndex === "number" ? opts.levelIndex : 1,
+		mushroomSpawned: false,
+		mode: GAME_MODES.playing,
+		cameraX: 0,
+		particles: [],
+		cue: null,
+		spawnX: startX,
+		spawnY: startY,
+		deathTimer: 0,
+		deathJumped: false,
+		player: {
+			x: startX,
+			y: startY,
+			vx: 0,
+			vy: 0,
+			facing: 1,
+			onGround: false,
+			size: /** @type {"small" | "big"} */ ("small"),
+			invuln: 0,
+		},
+		enemies,
+		items: [],
+		fireballs: [],
+		fireballSpawners: extracted.fireballSpawners,
+		boss,
+	};
+	state.player.onGround = isSolidAt(state.level, startX, startY + 1);
+	return state;
+}
+
+module.exports = {
+	DEFAULT_CONFIG,
+	createRng,
+	makeLevel,
+	createGame,
+	stepGame,
+	renderFrame,
+	renderViewport,
+	renderHud,
+	getCameraX,
+	updateCamera,
+	setPaused,
+	saveState,
+	loadState,
+	snapshotState,
+};

package/arcade/mario-not/fireballs.js

@@ -0,0 +1,98 @@
+// @ts-check
+"use strict";
+
+const { FIREBALL_SPEED, FIREBALL_WAVE_AMP, FIREBALL_WAVE_FREQ } = require("./constants.js");
+
+/** @typedef {import("./types").GameState} GameState */
+/** @typedef {import("./types").FireballState} FireballState */
+
+/** @param {GameState} state */
+function updateFireballSpawners(state) {
+	const dt = state.config.dt;
+	const cameraX = state.cameraX || 0;
+	const viewportWidth = state.config.viewportWidth || 40;
+
+	for (const spawner of state.fireballSpawners) {
+		// Only spawn fireballs if spawner is near the viewport
+		const distanceFromCamera = spawner.x - cameraX;
+		const isNearViewport = distanceFromCamera > -10 && distanceFromCamera < viewportWidth + 10;
+
+		if (!isNearViewport) {
+			spawner.timer = 0; // Reset timer when off-screen
+			continue;
+		}
+
+		spawner.timer += dt;
+		if (spawner.timer >= spawner.interval) {
+			spawner.timer = 0;
+			// Spawn a fireball
+			state.fireballs.push({
+				x: spawner.x,
+				y: spawner.y,
+				vx: FIREBALL_SPEED * spawner.direction,
+				vy: 0,
+				alive: true,
+				pattern: "wave",
+				startY: spawner.y,
+			});
+		}
+	}
+}
+
+/** @param {GameState} state */
+function updateFireballs(state) {
+	const dt = state.config.dt;
+	const level = state.level;
+
+	for (let i = state.fireballs.length - 1; i >= 0; i--) {
+		const fb = state.fireballs[i];
+		if (!fb.alive) {
+			state.fireballs.splice(i, 1);
+			continue;
+		}
+
+		// Move fireball
+		fb.x += fb.vx * dt;
+
+		// Wave pattern movement
+		if (fb.pattern === "wave") {
+			const elapsed = Math.abs(fb.x - (fb.startY + fb.vx * 0)); // Use x position for wave
+			fb.y = fb.startY + Math.sin(fb.x * FIREBALL_WAVE_FREQ) * FIREBALL_WAVE_AMP * 0.3;
+		}
+
+		// Remove if out of bounds
+		if (fb.x < -2 || fb.x > level.width + 2 || fb.y < -2 || fb.y > level.height + 2) {
+			state.fireballs.splice(i, 1);
+		}
+	}
+}
+
+/** @param {GameState} state @returns {boolean} */
+function checkFireballCollision(state) {
+	const player = state.player;
+	const playerW = 1;
+	const playerH = player.size === "big" ? 2 : 1;
+
+	for (const fb of state.fireballs) {
+		if (!fb.alive) continue;
+
+		// Simple AABB collision
+		const fbW = 0.5;
+		const fbH = 0.5;
+		if (
+			player.x < fb.x + fbW &&
+			player.x + playerW > fb.x &&
+			player.y < fb.y + fbH &&
+			player.y + playerH > fb.y - (playerH - 1)
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
+module.exports = {
+	updateFireballSpawners,
+	updateFireballs,
+	checkFireballCollision,
+};

package/arcade/mario-not/items.js

@@ -0,0 +1,24 @@
+// @ts-check
+"use strict";
+
+const { moveHorizontal, resolveVertical } = require("./collision.js");
+const { ITEM_W, ITEM_H } = require("./constants.js");
+
+/** @typedef {import("./types").GameState} GameState */
+
+/** @param {GameState} state */
+function updateItems(state) {
+	const cfg = state.config;
+	for (const item of state.items) {
+		if (!item.alive) continue;
+		item.vy = Math.min(item.vy + cfg.gravity * cfg.dt, cfg.maxFall);
+		const blocked = moveHorizontal(state.level, item, cfg.dt, ITEM_W, ITEM_H);
+		if (blocked) item.vx = -item.vx;
+		resolveVertical(state.level, item, cfg.dt, undefined, ITEM_H, ITEM_W, true);
+		if (item.y >= state.level.height + 1) item.alive = false;
+	}
+}
+
+module.exports = {
+	updateItems,
+};