small plugin changes + make minesweeper and snake plugin

2026-07-30 21:35:17 -05:00
parent 9700647279
commit 6c208da75f
13 changed files with 1299 additions and 2 deletions
@@ -0,0 +1,257 @@
+const DIFFICULTIES = {
+  beginner: { width: 9, height: 9, mines: 10 },
+  intermediate: { width: 16, height: 16, mines: 40 },
+  expert: { width: 30, height: 16, mines: 99 },
+};
+const GAME_TTL_MS = 24 * 60 * 60 * 1000;
+
+function parseSet(json) {
+  try {
+    const values = JSON.parse(json || "[]");
+    return new Set(Array.isArray(values) ? values.map(Number).filter(Number.isInteger) : []);
+  } catch {
+    return new Set();
+  }
+}
+
+function adjacent(index, width, height) {
+  const x = index % width;
+  const y = Math.floor(index / width);
+  const result = [];
+  for (let dy = -1; dy <= 1; dy += 1) {
+    for (let dx = -1; dx <= 1; dx += 1) {
+      if (dx === 0 && dy === 0) continue;
+      const nx = x + dx;
+      const ny = y + dy;
+      if (nx >= 0 && ny >= 0 && nx < width && ny < height) result.push(ny * width + nx);
+    }
+  }
+  return result;
+}
+
+function generateMines(width, height, mineCount, firstIndex) {
+  const excluded = new Set([firstIndex, ...adjacent(firstIndex, width, height)]);
+  const candidates = [];
+  for (let index = 0; index < width * height; index += 1) {
+    if (!excluded.has(index)) candidates.push(index);
+  }
+  const random = crypto.getRandomValues(new Uint32Array(candidates.length));
+  for (let index = candidates.length - 1; index > 0; index -= 1) {
+    const swapIndex = random[index] % (index + 1);
+    [candidates[index], candidates[swapIndex]] = [candidates[swapIndex], candidates[index]];
+  }
+  return new Set(candidates.slice(0, mineCount));
+}
+
+function cellValue(index, mines, width, height) {
+  let count = 0;
+  for (const neighbor of adjacent(index, width, height)) {
+    if (mines.has(neighbor)) count += 1;
+  }
+  return count;
+}
+
+function revealArea(firstIndex, revealed, mines, width, height) {
+  const pending = [firstIndex];
+  while (pending.length) {
+    const index = pending.pop();
+    if (revealed.has(index) || mines.has(index)) continue;
+    revealed.add(index);
+    if (cellValue(index, mines, width, height) !== 0) continue;
+    for (const neighbor of adjacent(index, width, height)) {
+      if (!revealed.has(neighbor) && !mines.has(neighbor)) pending.push(neighbor);
+    }
+  }
+}
+
+function visibleCells(revealed, mines, width, height, showMines) {
+  const cells = [];
+  for (const index of revealed) {
+    cells.push({
+      x: index % width,
+      y: Math.floor(index / width),
+      value: cellValue(index, mines, width, height),
+    });
+  }
+  if (showMines) {
+    for (const index of mines) {
+      cells.push({ x: index % width, y: Math.floor(index / width), mine: true });
+    }
+  }
+  return cells;
+}
+
+function leaderboard(ctx, difficulty) {
+  return ctx.db.prepare(`
+    SELECT caller_id AS callerId, username, time_ms AS timeMs, moves, played_at AS playedAt
+    FROM minesweeper_scores
+    WHERE difficulty = ?
+    ORDER BY time_ms ASC, moves ASC, played_at ASC
+    LIMIT 10
+  `).all(difficulty).map((row) => ({
+    player: String(row.username || `Player #${row.callerId}`),
+    timeMs: Number(row.timeMs),
+    moves: Number(row.moves),
+    playedAt: Number(row.playedAt),
+  }));
+}
+
+function getDifficulty(value) {
+  const key = typeof value === "string" ? value : "beginner";
+  if (!DIFFICULTIES[key]) throw new Error("Unknown difficulty");
+  return { key, ...DIFFICULTIES[key] };
+}
+
+export default {
+  setup(ctx) {
+    ctx.db.exec(`
+      CREATE TABLE IF NOT EXISTS minesweeper_games (
+        id TEXT PRIMARY KEY,
+        caller_id INTEGER NOT NULL,
+        difficulty TEXT NOT NULL,
+        width INTEGER NOT NULL,
+        height INTEGER NOT NULL,
+        mine_count INTEGER NOT NULL,
+        mines_json TEXT,
+        revealed_json TEXT NOT NULL DEFAULT '[]',
+        moves INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        started_at INTEGER,
+        finished INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS minesweeper_scores (
+        caller_id INTEGER NOT NULL,
+        username TEXT,
+        difficulty TEXT NOT NULL,
+        time_ms INTEGER NOT NULL,
+        moves INTEGER NOT NULL,
+        played_at INTEGER NOT NULL,
+        PRIMARY KEY (caller_id, difficulty)
+      );
+      CREATE INDEX IF NOT EXISTS minesweeper_games_created_at ON minesweeper_games(created_at);
+    `);
+    const scoreColumns = ctx.db.prepare("PRAGMA table_info(minesweeper_scores)").all();
+    if (!scoreColumns.some((column) => column.name === "username")) {
+      ctx.db.exec("ALTER TABLE minesweeper_scores ADD COLUMN username TEXT");
+    }
+    ctx.db.prepare("DELETE FROM minesweeper_games WHERE created_at < ?").run(Date.now() - GAME_TTL_MS);
+    ctx.log.info("Minesweeper ready");
+  },
+
+  rpc: {
+    start(ctx, params, meta) {
+      const difficulty = getDifficulty(params?.difficulty);
+      const callerId = Number(meta.caller.id);
+      const gameId = crypto.randomUUID();
+      ctx.db.prepare("DELETE FROM minesweeper_games WHERE caller_id = ? AND finished = 0").run(callerId);
+      ctx.db.prepare(`
+        INSERT INTO minesweeper_games
+          (id, caller_id, difficulty, width, height, mine_count, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(gameId, callerId, difficulty.key, difficulty.width, difficulty.height, difficulty.mines, Date.now());
+      return {
+        gameId,
+        difficulty: difficulty.key,
+        width: difficulty.width,
+        height: difficulty.height,
+        mines: difficulty.mines,
+      };
+    },
+
+    leaderboard(ctx, params, meta) {
+      const difficulty = getDifficulty(params?.difficulty);
+      const username = String(meta.caller.username || `Player #${meta.caller.id}`).trim();
+      ctx.db.prepare("UPDATE minesweeper_scores SET username = ? WHERE caller_id = ? AND difficulty = ?")
+        .run(username, Number(meta.caller.id), difficulty.key);
+      return { difficulty: difficulty.key, entries: leaderboard(ctx, difficulty.key) };
+    },
+
+    reveal(ctx, params, meta) {
+      const gameId = typeof params?.gameId === "string" ? params.gameId : "";
+      const x = Number(params?.x);
+      const y = Number(params?.y);
+      const game = ctx.db.prepare(`
+        SELECT id, caller_id AS callerId, difficulty, width, height,
+          mine_count AS mineCount, mines_json AS minesJson,
+          revealed_json AS revealedJson, moves, started_at AS startedAt, finished
+        FROM minesweeper_games WHERE id = ?
+      `).get(gameId);
+      if (!game || Number(game.callerId) !== Number(meta.caller.id)) throw new Error("Game not found");
+      if (Number(game.finished) !== 0) throw new Error("Game is already finished");
+
+      const width = Number(game.width);
+      const height = Number(game.height);
+      if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= width || y >= height) {
+        throw new Error("Invalid cell");
+      }
+
+      const index = y * width + x;
+      const revealed = parseSet(game.revealedJson);
+      let mines = game.minesJson ? parseSet(game.minesJson) : null;
+      const startedAt = game.startedAt ? Number(game.startedAt) : Date.now();
+      if (!mines) mines = generateMines(width, height, Number(game.mineCount), index);
+
+      if (revealed.has(index)) {
+        return {
+          status: "playing",
+          cells: visibleCells(revealed, mines, width, height, false),
+          moves: Number(game.moves),
+          elapsedMs: Date.now() - startedAt,
+        };
+      }
+
+      const moves = Number(game.moves) + 1;
+      if (mines.has(index)) {
+        ctx.db.prepare(`
+          UPDATE minesweeper_games
+          SET mines_json = ?, started_at = ?, moves = ?, finished = 2
+          WHERE id = ?
+        `).run(JSON.stringify([...mines]), startedAt, moves, gameId);
+        return {
+          status: "lost",
+          cells: visibleCells(revealed, mines, width, height, true),
+          hit: { x, y },
+          moves,
+          elapsedMs: Date.now() - startedAt,
+        };
+      }
+
+      revealArea(index, revealed, mines, width, height);
+      const won = revealed.size === width * height - Number(game.mineCount);
+      const elapsedMs = Date.now() - startedAt;
+      ctx.db.prepare(`
+        UPDATE minesweeper_games
+        SET mines_json = ?, revealed_json = ?, started_at = ?, moves = ?, finished = ?
+        WHERE id = ?
+      `).run(JSON.stringify([...mines]), JSON.stringify([...revealed]), startedAt, moves, won ? 1 : 0, gameId);
+
+      let entries;
+      if (won) {
+        const playedAt = Date.now();
+        const username = String(meta.caller.username || `Player #${meta.caller.id}`).trim();
+        ctx.db.prepare("UPDATE minesweeper_scores SET username = ? WHERE caller_id = ? AND difficulty = ?")
+          .run(username, Number(meta.caller.id), game.difficulty);
+        ctx.db.prepare(`
+          INSERT INTO minesweeper_scores (caller_id, username, difficulty, time_ms, moves, played_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+          ON CONFLICT(caller_id, difficulty) DO UPDATE SET
+            time_ms = excluded.time_ms,
+            moves = excluded.moves,
+            played_at = excluded.played_at
+          WHERE excluded.time_ms < minesweeper_scores.time_ms
+             OR (excluded.time_ms = minesweeper_scores.time_ms AND excluded.moves < minesweeper_scores.moves)
+        `).run(Number(meta.caller.id), username, game.difficulty, elapsedMs, moves, playedAt);
+        entries = leaderboard(ctx, game.difficulty);
+        ctx.broadcast("leaderboard", { difficulty: game.difficulty, entries });
+      }
+
+      return {
+        status: won ? "won" : "playing",
+        cells: visibleCells(revealed, mines, width, height, won),
+        moves,
+        elapsedMs,
+        entries,
+      };
+    },
+  },
+};