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,200 @@
+const BOARD_SIZE = 24;
+const MAX_TICKS = 100_000;
+const SESSION_TTL_MS = 2 * 60 * 60 * 1000;
+const DIRECTIONS = {
+  up: { x: 0, y: -1, opposite: "down" },
+  down: { x: 0, y: 1, opposite: "up" },
+  left: { x: -1, y: 0, opposite: "right" },
+  right: { x: 1, y: 0, opposite: "left" },
+};
+
+function makeRng(seed) {
+  let value = seed >>> 0;
+  return () => {
+    value ^= value << 13;
+    value ^= value >>> 17;
+    value ^= value << 5;
+    return (value >>> 0) / 0x100000000;
+  };
+}
+
+function cellKey(cell) {
+  return `${cell.x},${cell.y}`;
+}
+
+function chooseFood(snake, rng) {
+  const occupied = new Set(snake.map(cellKey));
+  const free = [];
+  for (let y = 0; y < BOARD_SIZE; y += 1) {
+    for (let x = 0; x < BOARD_SIZE; x += 1) {
+      if (!occupied.has(`${x},${y}`)) free.push({ x, y });
+    }
+  }
+  return free.length ? free[Math.floor(rng() * free.length)] : null;
+}
+
+function initialState(seed) {
+  const snake = [{ x: 12, y: 12 }, { x: 11, y: 12 }, { x: 10, y: 12 }];
+  const rng = makeRng(seed);
+  return { snake, direction: "right", food: chooseFood(snake, rng), score: 0, rng };
+}
+
+function step(state) {
+  const vector = DIRECTIONS[state.direction];
+  const head = { x: state.snake[0].x + vector.x, y: state.snake[0].y + vector.y };
+  const ate = state.food && head.x === state.food.x && head.y === state.food.y;
+  const collisionBody = ate ? state.snake : state.snake.slice(0, -1);
+  const collided = head.x < 0 || head.y < 0 || head.x >= BOARD_SIZE || head.y >= BOARD_SIZE ||
+    collisionBody.some((cell) => cell.x === head.x && cell.y === head.y);
+  if (collided) return { dead: true, won: false };
+
+  state.snake.unshift(head);
+  if (ate) {
+    state.score += 1;
+    state.food = chooseFood(state.snake, state.rng);
+    if (!state.food) return { dead: true, won: true };
+  } else {
+    state.snake.pop();
+  }
+  return { dead: false, won: false };
+}
+
+function validateMoves(value, ticks) {
+  if (!Array.isArray(value) || value.length > ticks) throw new Error("Invalid move log");
+  let lastTick = 0;
+  return value.map((move) => {
+    const tick = Number(move?.tick);
+    const direction = move?.direction;
+    if (!Number.isInteger(tick) || tick <= lastTick || tick > ticks || !DIRECTIONS[direction]) {
+      throw new Error("Invalid move log");
+    }
+    lastTick = tick;
+    return { tick, direction };
+  });
+}
+
+function replay(seed, ticks, moves) {
+  const state = initialState(seed);
+  let moveIndex = 0;
+  for (let tick = 1; tick <= ticks; tick += 1) {
+    if (moveIndex < moves.length && moves[moveIndex].tick === tick) {
+      const next = moves[moveIndex].direction;
+      if (DIRECTIONS[state.direction].opposite === next) throw new Error("Invalid direction change");
+      state.direction = next;
+      moveIndex += 1;
+    }
+    const outcome = step(state);
+    if (outcome.dead) {
+      if (tick !== ticks) throw new Error("Run continued after game over");
+      return { score: state.score, won: outcome.won };
+    }
+  }
+  throw new Error("Run has not ended");
+}
+
+function leaderboard(ctx) {
+  return ctx.db.prepare(`
+    SELECT caller_id AS callerId, username, score, played_at AS playedAt
+    FROM snake_scores
+    ORDER BY score DESC, played_at ASC
+    LIMIT 10
+  `).all().map((row) => ({
+    player: String(row.username || `Player #${row.callerId}`),
+    score: Number(row.score),
+    playedAt: Number(row.playedAt),
+  }));
+}
+
+export default {
+  setup(ctx) {
+    ctx.db.exec(`
+      CREATE TABLE IF NOT EXISTS snake_games (
+        id TEXT PRIMARY KEY,
+        caller_id INTEGER NOT NULL,
+        seed INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        completed INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS snake_scores (
+        caller_id INTEGER PRIMARY KEY,
+        username TEXT,
+        score INTEGER NOT NULL,
+        played_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS snake_games_created_at ON snake_games(created_at);
+    `);
+    const scoreColumns = ctx.db.prepare("PRAGMA table_info(snake_scores)").all();
+    if (!scoreColumns.some((column) => column.name === "username")) {
+      ctx.db.exec("ALTER TABLE snake_scores ADD COLUMN username TEXT");
+    }
+    ctx.db.prepare("DELETE FROM snake_games WHERE created_at < ?").run(Date.now() - SESSION_TTL_MS);
+    ctx.log.info("Snake arcade ready");
+  },
+
+  rpc: {
+    start(ctx, _params, meta) {
+      const callerId = Number(meta.caller.id);
+      const id = crypto.randomUUID();
+      const seed = crypto.getRandomValues(new Uint32Array(1))[0];
+      const createdAt = Date.now();
+      ctx.db.prepare("DELETE FROM snake_games WHERE caller_id = ? AND completed = 0").run(callerId);
+      ctx.db.prepare("INSERT INTO snake_games (id, caller_id, seed, created_at) VALUES (?, ?, ?, ?)")
+        .run(id, callerId, seed, createdAt);
+      const state = initialState(seed);
+      return {
+        gameId: id,
+        seed,
+        boardSize: BOARD_SIZE,
+        snake: state.snake,
+        food: state.food,
+        direction: state.direction,
+        tickMs: 115,
+      };
+    },
+
+    leaderboard(ctx, _params, meta) {
+      const username = String(meta.caller.username || `Player #${meta.caller.id}`).trim();
+      ctx.db.prepare("UPDATE snake_scores SET username = ? WHERE caller_id = ?")
+        .run(username, Number(meta.caller.id));
+      return { entries: leaderboard(ctx) };
+    },
+
+    submit(ctx, params, meta) {
+      const gameId = typeof params?.gameId === "string" ? params.gameId : "";
+      const ticks = Number(params?.ticks);
+      if (!gameId || !Number.isInteger(ticks) || ticks < 1 || ticks > MAX_TICKS) {
+        throw new Error("Invalid completed run");
+      }
+
+      const game = ctx.db.prepare(
+        "SELECT id, caller_id AS callerId, seed, created_at AS createdAt, completed FROM snake_games WHERE id = ?",
+      ).get(gameId);
+      if (!game || Number(game.callerId) !== Number(meta.caller.id)) throw new Error("Game not found");
+      if (game.completed) throw new Error("Game was already submitted");
+      if (Date.now() - Number(game.createdAt) > SESSION_TTL_MS) throw new Error("Game expired");
+
+      const moves = validateMoves(params?.moves, ticks);
+      const result = replay(Number(game.seed), ticks, moves);
+      const username = String(meta.caller.username || `Player #${meta.caller.id}`).trim();
+      const playedAt = Date.now();
+      const save = ctx.db.transaction(() => {
+        const updated = ctx.db.prepare("UPDATE snake_games SET completed = 1 WHERE id = ? AND completed = 0").run(gameId);
+        if (updated.changes !== 1) throw new Error("Game was already submitted");
+        ctx.db.prepare("UPDATE snake_scores SET username = ? WHERE caller_id = ?")
+          .run(username, Number(meta.caller.id));
+        ctx.db.prepare(`
+          INSERT INTO snake_scores (caller_id, username, score, played_at) VALUES (?, ?, ?, ?)
+          ON CONFLICT(caller_id) DO UPDATE SET
+            score = excluded.score,
+            played_at = excluded.played_at
+          WHERE excluded.score > snake_scores.score
+        `).run(Number(meta.caller.id), username, result.score, playedAt);
+      });
+      save();
+
+      const entries = leaderboard(ctx);
+      ctx.broadcast("leaderboard", { entries });
+      return { score: result.score, won: result.won, entries };
+    },
+  },
+};