moshcode 0.41.0 → 0.43.0

package/src/games-tank.mjs

@@ -0,0 +1,230 @@
+// Tank. Two of them in a walled yard, one shell each in the air at a time, five
+// hits and it is over.
+//
+// Everything is on the grid and turned in quarter turns, because a tank you
+// cannot line up is a tank you cannot aim, and lining up *is* the shot. Your
+// keys are one action each — a press turns you or moves you one cell — so
+// holding an arrow drives, and tapping it nudges.
+import { acid, ash, bone, danger, dim } from "./ui.mjs";
+
+export const TARGET = 5;
+
+/**
+ * The yard. `#` is wall, and the outer ring is closed — a shell that leaves the
+ * board is a shell nobody saw stop.
+ */
+export const YARD = [
+  "##########################################",
+  "#                                        #",
+  "#    ####        ######        ####      #",
+  "#       #             #           #      #",
+  "#       #    ####     #    ####   #      #",
+  "#            #  #          #  #          #",
+  "#    #####   #  #   ####   #  #   ####   #",
+  "#            #  #          #  #          #",
+  "#       #    ####     #    ####   #      #",
+  "#       #             #           #      #",
+  "#    ####        ######        ####      #",
+  "#                                        #",
+  "##########################################",
+];
+
+export const isWall = (x, y) => (YARD[y]?.[x] ?? "#") === "#";
+
+// Derived from the yard rather than declared beside it, so the two can never
+// disagree about how big the board is.
+export const WIDTH = YARD[0].length;
+export const HEIGHT = YARD.length;
+
+/** Quarter turns, and the glyph a tank wears pointing that way. */
+export const HEADINGS = [
+  { dx: 0, dy: -1, glyph: "▲" },
+  { dx: 1, dy: 0, glyph: "▶" },
+  { dx: 0, dy: 1, glyph: "▼" },
+  { dx: -1, dy: 0, glyph: "◀" },
+];
+
+const SHELL_SPEED = 1;   // cells per tick
+const THEM_EVERY = 4;    // the machine gets a move every this many ticks
+
+const spawnYou = () => ({ x: 2, y: 6, dir: 1, cool: 0 });
+const spawnThem = () => ({ x: WIDTH - 3, y: 6, dir: 3, cool: 0 });
+
+/** Move a tank one cell if there is floor there. Walls simply refuse. */
+export function drive(tank, sign) {
+  const { dx, dy } = HEADINGS[tank.dir];
+  const x = tank.x + dx * sign;
+  const y = tank.y + dy * sign;
+  if (isWall(x, y)) return false;
+  tank.x = x;
+  tank.y = y;
+  return true;
+}
+
+export const fire = (tank, owner) => ({
+  x: tank.x + HEADINGS[tank.dir].dx,
+  y: tank.y + HEADINGS[tank.dir].dy,
+  dir: tank.dir,
+  owner,
+});
+
+/**
+ * Whether a tank can see another down the barrel: same row or column, nothing
+ * but floor in between. This is both how the machine decides to shoot and the
+ * only thing it is good at.
+ */
+export function lineOfSight(from, to) {
+  const { dx, dy } = HEADINGS[from.dir];
+  let x = from.x + dx;
+  let y = from.y + dy;
+  for (let i = 0; i < Math.max(WIDTH, HEIGHT); i++) {
+    if (isWall(x, y)) return false;
+    if (x === to.x && y === to.y) return true;
+    x += dx;
+    y += dy;
+  }
+  return false;
+}
+
+/**
+ * The next cell on the shortest way from one point to another, and the heading
+ * that gets there.
+ *
+ * This is a breadth-first search of the whole yard on every decision, which
+ * sounds extravagant for 546 cells and is not: it is the difference between a
+ * tank that comes around the block after you and one that drives into the same
+ * wall forever, which is what "just turn towards the enemy" does the moment
+ * there is anything between the two of you.
+ */
+export function stepToward(from, to) {
+  if (from.x === to.x && from.y === to.y) return null;
+  const seen = new Set([`${from.x},${from.y}`]);
+  const queue = [{ x: from.x, y: from.y, first: null }];
+  for (let head = 0; head < queue.length; head++) {
+    const cur = queue[head];
+    for (let dir = 0; dir < HEADINGS.length; dir++) {
+      const x = cur.x + HEADINGS[dir].dx;
+      const y = cur.y + HEADINGS[dir].dy;
+      const key = `${x},${y}`;
+      if (isWall(x, y) || seen.has(key)) continue;
+      seen.add(key);
+      const first = cur.first ?? { x, y, dir };
+      if (x === to.x && y === to.y) return first;
+      queue.push({ x, y, first });
+    }
+  }
+  return null;
+}
+
+/** One quarter turn from `dir` towards `want`, the short way round. */
+export const quarterTurn = (dir, want) => (dir + ((want - dir + 4) % 4 === 3 ? 3 : 1)) % 4;
+
+function hit(state, who) {
+  if (who === "you") state.yours++; else state.theirs++;
+  state.shells = [];
+  state.you = spawnYou();
+  state.them = spawnThem();
+  if (state.yours >= TARGET) state.over = `you take it ${state.yours}–${state.theirs} 🤘`;
+  else if (state.theirs >= TARGET) state.over = `the machine takes it ${state.theirs}–${state.yours}`;
+  return state;
+}
+
+/** One tick: shells first, then the machine takes its turn. */
+export function step(state) {
+  for (const shell of [...state.shells]) {
+    for (let i = 0; i < SHELL_SPEED; i++) {
+      const { dx, dy } = HEADINGS[shell.dir];
+      shell.x += dx;
+      shell.y += dy;
+      if (isWall(shell.x, shell.y)) { state.shells = state.shells.filter((s) => s !== shell); break; }
+      const target = shell.owner === "you" ? state.them : state.you;
+      if (shell.x === target.x && shell.y === target.y) {
+        state.shells = state.shells.filter((s) => s !== shell);
+        hit(state, shell.owner);
+        return state;
+      }
+    }
+  }
+  if (state.over) return state;
+
+  if (state.you.cool > 0) state.you.cool--;
+  if (state.them.cool > 0) state.them.cool--;
+
+  state.clock++;
+  if (state.clock % THEM_EVERY) return state;
+
+  // The machine: shoot if it is looking at you, otherwise turn towards you, and
+  // drive when it is already pointed the right way. It is not clever, but it is
+  // relentless, and in a yard this size that is enough.
+  const them = state.them;
+  if (lineOfSight(them, state.you)) {
+    if (!them.cool && !state.shells.some((s) => s.owner === "them")) {
+      state.shells.push(fire(them, "them"));
+      them.cool = 6;
+    }
+    return state;
+  }
+  const next = stepToward(them, state.you);
+  if (!next) return state;
+  if (them.dir !== next.dir) them.dir = quarterTurn(them.dir, next.dir);
+  else drive(them, 1);
+  return state;
+}
+
+export const TANK = {
+  key: "tank",
+  aliases: ["tanks", "combat"],
+  title: "TANK",
+  blurb: "two tanks, one yard, five hits — line it up and let go",
+  keys: "← → turn · ↑ drive · ↓ reverse · space fire · q quit",
+  tickMs: 60,
+
+  create() {
+    return {
+      you: spawnYou(),
+      them: spawnThem(),
+      shells: [],
+      yours: 0,
+      theirs: 0,
+      clock: 0,
+      over: null,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    const you = state.you;
+    if (key === "left") you.dir = (you.dir + 3) % 4;
+    else if (key === "right") you.dir = (you.dir + 1) % 4;
+    else if (key === "up") drive(you, 1);
+    else if (key === "down") drive(you, -1);
+    else if (key === "space" || key === "enter") {
+      // One shell of yours in the air at a time, same as the machine. Two would
+      // turn a duel into a hosepipe.
+      if (you.cool || state.shells.some((s) => s.owner === "you")) return state;
+      const shell = fire(you, "you");
+      if (!isWall(shell.x, shell.y)) state.shells.push(shell);
+      you.cool = 4;
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over ? state.over : `you ${state.yours} · machine ${state.theirs}`;
+  },
+
+  render(state) {
+    const grid = YARD.map((row) => [...row].map((c) => (c === "#" ? ash("█") : null)));
+    const put = (x, y, glyph) => {
+      if (!grid[y] || x < 0 || x >= grid[y].length) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const shell of state.shells) put(shell.x, shell.y, (shell.owner === "you" ? bone : danger)("•"));
+    put(state.you.x, state.you.y, acid(HEADINGS[state.you.dir].glyph));
+    put(state.them.x, state.them.y, danger(HEADINGS[state.them.dir].glyph));
+
+    return grid.map((row) => row.map((cell) => cell ?? dim("·")).join(""));
+  },
+};

package/src/games.mjs

@@ -1,8 +1,8 @@
 // The moshcode arcade — `/games` in the pit, `moshcode games` from a shell.
 //
-// Six games, one frame. Every game here is the same shape (see GAME_SHAPE
+// Twenty-two games, one frame. Every game here is the same shape (see GAME_SHAPE
 // below) and is drawn by the same `frame()`, so they look like one arcade
-// rather than six weekend projects: a title, a status line, a boxed board, and
+// rather than twenty-two weekend projects: a title, a status line, a boxed board, and
 // one line of keys along the bottom. There is no menu, no options screen and no
 // difficulty prompt — `/games tetris` is already playing by the time the frame
 // lands, and `q` is always the way out.
@@ -18,6 +18,22 @@ import { PACMAN } from "./games-pacman.mjs";
 import { TICTACTOE } from "./games-tictactoe.mjs";
 import { HANGMAN } from "./games-hangman.mjs";
 import { CHESS } from "./games-chess.mjs";
+import { ASTEROIDS } from "./games-asteroids.mjs";
+import { BLACKJACK } from "./games-blackjack.mjs";
+import { STAGEDIVE } from "./games-stagedive.mjs";
+import { INVADERS } from "./games-invaders.mjs";
+import { BREAKOUT } from "./games-breakout.mjs";
+import { PONG } from "./games-pong.mjs";
+import { TANK } from "./games-tank.mjs";
+import { SPYHUNTER } from "./games-spyhunter.mjs";
+import { CENTIPEDE } from "./games-centipede.mjs";
+import { FROGGER } from "./games-frogger.mjs";
+import { DIGDUG } from "./games-digdug.mjs";
+import { KONG } from "./games-kong.mjs";
+import { PITFALL } from "./games-pitfall.mjs";
+import { CHOPLIFTER } from "./games-choplifter.mjs";
+import { EXCITEBIKE } from "./games-excitebike.mjs";
+import { OUTRUN } from "./games-outrun.mjs";
 
 /**
  * @typedef {object} Game  — the whole contract, so a seventh game is an import.
@@ -27,6 +43,8 @@ import { CHESS } from "./games-chess.mjs";
  * @property {string} blurb      one line, for /games list
  * @property {string} keys       the footer; the only place controls are ever explained
  * @property {number|Function} [tickMs]  real-time games only — a number, or (state) => number
+ * @property {boolean} [vim]     false when a game wants h/j/k/l as letters, not arrows
+ * @property {boolean} [restartable]  false when `r` is only a restart once the game is over
  * @property {Function} create   ({ rng }) => state
  * @property {Function} onKey    (state, key, { rng }) => state
  * @property {Function} [tick]   (state, { rng }) => state
@@ -35,7 +53,11 @@ import { CHESS } from "./games-chess.mjs";
  */
 
 /** The cabinet. Order is the order `/games` lists them. */
-export const GAMES = [TETRIS, SNAKE, PACMAN, TICTACTOE, CHESS, HANGMAN];
+export const GAMES = [
+  TETRIS, SNAKE, PACMAN, INVADERS, CENTIPEDE, ASTEROIDS, BREAKOUT, PONG, TANK, DIGDUG,
+  FROGGER, KONG, PITFALL, CHOPLIFTER, SPYHUNTER, OUTRUN, EXCITEBIKE, STAGEDIVE,
+  TICTACTOE, BLACKJACK, CHESS, HANGMAN,
+];
 
 /** Games by name, following aliases. Case- and slash-insensitive. */
 export function resolveGame(name) {
@@ -98,8 +120,12 @@ export function frame({ title = "", status = "", rows = [], keys = "" } = {}) {
  * Games never see an escape sequence; they see "up", "enter", "a". A chunk can
  * hold several keypresses (hold an arrow key down and they arrive in batches),
  * which is why this returns a list.
+ *
+ * `vim: false` is for the games that read letters — hangman cannot ask for a
+ * word with an `h` in it while `h` means left, and blackjack wants `h` to be
+ * hit. Arrows are unaffected either way; they arrive as escape sequences.
  */
-export function decodeKeys(chunk) {
+export function decodeKeys(chunk, { vim = true } = {}) {
   const input = String(chunk);
   const keys = [];
   for (let i = 0; i < input.length; i++) {
@@ -119,10 +145,10 @@ export function decodeKeys(chunk) {
     if (c === "\x03" || c === "\x04") { keys.push("quit"); continue; }
     if (c === "\x7f" || c === "\b") { keys.push("backspace"); continue; }
     if (c === "\t") { keys.push("tab"); continue; }
-    // vim keys, everywhere, for free — every game reads arrows, so mapping
-    // hjkl here means no game has to know about them.
-    const vim = { h: "left", j: "down", k: "up", l: "right" }[c];
-    if (vim) { keys.push(vim); continue; }
+    // vim keys, everywhere, for free — every game that reads arrows gets them
+    // without knowing about them. A game that reads letters opts out.
+    const vimKey = vim ? { h: "left", j: "down", k: "up", l: "right" }[c] : null;
+    if (vimKey) { keys.push(vimKey); continue; }
     if (c >= " " && c <= "~") keys.push(c.toLowerCase());
   }
   return keys;
@@ -241,7 +267,7 @@ export async function runGame(game, deps = {}) {
   const onSignal = () => { restore(); process.exit(130); };
 
   function onData(chunk) {
-    for (const key of decodeKeys(chunk)) {
+    for (const key of decodeKeys(chunk, { vim: game.vim !== false })) {
       if (key === "quit" || key === "q" || key === "escape") { restore(); resolve(); return; }
       if (key === "r" && (state.over || game.restartable !== false)) {
         state = game.create(ctx);

package/src/news-sources.mjs

@@ -0,0 +1,154 @@
+// Where `/news` gets its headlines when nobody has subscribed to anything yet.
+//
+// These are not invented: they are the sources the two profullstack properties
+// that already do this in production use, lifted so the pit answers the same
+// way they do.
+//
+//   brisk.news — apps/web/src/lib/news/fetch-feed.ts builds Google News feeds,
+//     top stories for the front page and one per category, and
+//     scripts/import-opml-feeds.ts seeds its publisher table from four public
+//     OPML lists. Both are represented here: the Google feeds as the defaults,
+//     the OPML lists as named bundles `/news add` accepts by name.
+//
+//   advis0r.com — src/providers/news/rss.ts pairs a Google News query feed with
+//     a Bing one (Google's links are interstitials, Bing's carry the publisher
+//     URL in a `url=` parameter), and reads two newswires directly. The search
+//     pairing is why `/news <keyword>` queries both, and the wires are here
+//     under `markets`.
+//
+// Deliberately small. A default list is a claim that every entry works, so it
+// holds feeds with stable well-known URLs and defers everything else to the
+// OPML bundles, where the list is somebody else's to maintain.
+
+/** Google News locale. One place, because every builder below needs it. */
+const GOOGLE_LOCALE = "hl=en-US&gl=US&ceid=US:en";
+
+/**
+ * Google News category feeds, keyed the way brisk.news keys them.
+ *
+ * `general` is null there and means "top stories", which is a different URL
+ * rather than a search for the word "general" — the same distinction is kept.
+ */
+export const GOOGLE_NEWS_CATEGORIES = {
+  general: null,
+  science: "science",
+  sports: "sports",
+  business: "business",
+  health: "health",
+  entertainment: "entertainment",
+  tech: "technology",
+  politics: "politics",
+  food: "food",
+  travel: "travel",
+};
+
+/** Google News top stories, or one category from the map above. */
+export function googleNewsFeed(category = null) {
+  const mapped = category ? GOOGLE_NEWS_CATEGORIES[category] ?? null : null;
+  if (!mapped) return `https://news.google.com/rss?${GOOGLE_LOCALE}`;
+  return `https://news.google.com/rss/search?q=${encodeURIComponent(mapped)}&${GOOGLE_LOCALE}`;
+}
+
+/**
+ * Google News query feed. `when:7d` style windows keep results recent —
+ * advis0r's googleNewsFeed() does the same, for the same reason.
+ */
+export function googleNewsSearch(query, { window = "7d" } = {}) {
+  const q = window ? `${query} when:${window}` : String(query);
+  return `https://news.google.com/rss/search?q=${encodeURIComponent(q)}&${GOOGLE_LOCALE}`;
+}
+
+/** Bing News query feed — the half of a search whose links are real articles. */
+export function bingNewsSearch(query) {
+  return `https://www.bing.com/news/search?q=${encodeURIComponent(query)}&format=RSS`;
+}
+
+/**
+ * Resolve a redirect wrapper to the publisher URL it carries.
+ *
+ * Lifted from advis0r's unwrapRedirect for the same reason it exists there:
+ * aggregator feeds link to themselves, and a reader that opens
+ * `news.google.com/rss/articles/CBM…` shows an interstitial instead of the
+ * story. Only decodes what is already in the link — it never follows a
+ * redirect, so it costs no request and cannot be led somewhere unexpected.
+ */
+export function unwrapRedirect(url) {
+  try {
+    const parsed = new URL(url);
+    const inner = parsed.searchParams.get("url") ?? parsed.searchParams.get("u");
+    if (!inner) return url;
+    const decoded = decodeURIComponent(inner);
+    return /^https?:\/\//i.test(decoded) ? decoded : url;
+  } catch {
+    return url;
+  }
+}
+
+/**
+ * The feeds a fresh install reads.
+ *
+ * Google News carries the general desks because that is exactly what brisk.news
+ * serves its front page from, and it means one URL shape covers ten sections
+ * without ten publisher relationships to keep working. The named publishers are
+ * tier-1 hosts from advis0r's own tiering table that publish a stable feed, and
+ * they earn their place by being readable end to end — a Google News item is a
+ * headline behind an interstitial, theirs is the article.
+ */
+export const DEFAULT_FEEDS = [
+  { name: "top-stories", title: "Google News — Top Stories", url: googleNewsFeed(), site: "https://news.google.com", category: "" },
+  { name: "world", title: "Google News — World", url: googleNewsSearch("world news", { window: "2d" }), site: "https://news.google.com", category: "" },
+
+  { name: "tech", title: "Google News — Technology", url: googleNewsFeed("tech"), site: "https://news.google.com", category: "tech" },
+  { name: "ars-technica", title: "Ars Technica", url: "https://feeds.arstechnica.com/arstechnica/index", site: "https://arstechnica.com", category: "tech" },
+  { name: "techcrunch", title: "TechCrunch", url: "https://techcrunch.com/feed/", site: "https://techcrunch.com", category: "tech" },
+  { name: "the-register", title: "The Register", url: "https://www.theregister.com/headlines.atom", site: "https://www.theregister.com", category: "tech" },
+  { name: "hacker-news", title: "Hacker News — Front Page", url: "https://hnrss.org/frontpage", site: "https://news.ycombinator.com", category: "tech" },
+
+  { name: "business", title: "Google News — Business", url: googleNewsFeed("business"), site: "https://news.google.com", category: "markets" },
+  { name: "marketwatch", title: "MarketWatch — Top Stories", url: "https://feeds.content.dowjones.io/public/rss/mw_topstories", site: "https://www.marketwatch.com", category: "markets" },
+  // The two newswires advis0r reads directly. Tier 0 there: issuers speaking
+  // for themselves rather than a publication speaking about them.
+  { name: "pr-newswire", title: "PR Newswire — Financial Services", url: "https://www.prnewswire.com/rss/financial-services-latest-news/financial-services-latest-news-list.rss", site: "https://www.prnewswire.com", category: "markets" },
+  { name: "globenewswire", title: "GlobeNewswire — Public Companies", url: "https://www.globenewswire.com/RssFeed/orgclass/1/feedTitle/GlobeNewswire%20-%20News%20about%20Public%20Companies", site: "https://www.globenewswire.com", category: "markets" },
+
+  { name: "science", title: "Google News — Science", url: googleNewsFeed("science"), site: "https://news.google.com", category: "science" },
+  { name: "politics", title: "Google News — Politics", url: googleNewsFeed("politics"), site: "https://news.google.com", category: "politics" },
+];
+
+/**
+ * The public OPML lists brisk.news imports its publisher table from.
+ *
+ * Offered by name (`/news add journalists`) rather than only by URL because
+ * these are long, exact raw.githubusercontent paths that nobody is going to
+ * retype, and importing one is the fastest way from an empty reader to a real
+ * one. They are somebody else's lists, and that is the point: the feeds inside
+ * them stay current without moshcode shipping a release.
+ */
+export const OPML_BUNDLES = [
+  {
+    name: "journalists",
+    description: "Dave Winer's feedsForJournalists — mainstream desks",
+    url: "https://raw.githubusercontent.com/scripting/feedsForJournalists/master/list.opml",
+  },
+  {
+    name: "web3",
+    description: "ChainFeeds RSSAggregatorforWeb3 — crypto and web3",
+    url: "https://raw.githubusercontent.com/chainfeeds/RSSAggregatorforWeb3/main/RAW.opml",
+  },
+  {
+    name: "blockchain",
+    description: "CoinFabrik decentralized-and-blockchain-feeds",
+    url: "https://raw.githubusercontent.com/CoinFabrik/resources/master/decentralized-and-blockchain-feeds.opml",
+  },
+];
+
+/** Resolve a bundle name to its OPML URL, or null. */
+export function resolveBundle(name) {
+  const wanted = String(name ?? "").trim().toLowerCase();
+  return OPML_BUNDLES.find((b) => b.name === wanted) ?? null;
+}
+
+/** A fresh copy of the defaults — callers mutate feed lists. */
+export function defaultFeeds() {
+  return DEFAULT_FEEDS.map((feed) => ({ ...feed }));
+}