moshcode 0.41.0 → 0.43.0

package/src/games-pong.mjs

@@ -0,0 +1,147 @@
+// Pong. The oldest one in the cabinet, and still the one that explains itself
+// fastest: you are the left paddle, the ball is going that way, do something.
+//
+// The machine on the right is deliberately not perfect. It waits until the ball
+// crosses the halfway line before it starts tracking, and then it moves slowly
+// enough that it cannot reach a corner from the middle in the time it has left.
+// A flat return it will always get; one taken off the end of your paddle it will
+// not. That is the whole game, and it is why the angle off the paddle depends on
+// where the ball hit it.
+import { acid, bone, danger, dim } from "./ui.mjs";
+
+export const WIDTH = 44;
+export const HEIGHT = 16;
+
+/** A row is worth two columns, so the ball travels at the angle it looks like. */
+const ASPECT = 0.5;
+
+export const PADDLE = 4;          // rows tall
+export const YOU_COL = 2;
+export const THEM_COL = WIDTH - 3;
+export const TARGET = 7;          // first to this many
+
+const SERVE_SPEED = 0.85;
+const MAX_SPEED = 1.7;
+const SPIN = 0.55;                // how much the edge of the paddle bends the ball
+const THEM_SPEED = 0.3;           // slow enough that a ball into the corner beats it
+const YOU_STEP = 1;
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+/** A ball in the middle, heading at whoever just lost the point. */
+export function serve(state, toward) {
+  state.ball = {
+    x: WIDTH / 2,
+    y: HEIGHT / 2,
+    vx: toward * SERVE_SPEED,
+    // Never dead flat: a ball with no angle is a rally nobody can lose.
+    vy: (state.rng() < 0.5 ? -1 : 1) * (0.15 + state.rng() * 0.2),
+  };
+  return state;
+}
+
+/** Where a paddle's rows are, given its top row. */
+export const paddleRows = (top) => Array.from({ length: PADDLE }, (_, i) => Math.round(top) + i);
+
+const catches = (top, y) => y >= top - 0.5 && y <= top + PADDLE - 0.5;
+
+/**
+ * Bounce off a paddle, steeper the further from its middle you take it. This is
+ * the only way a player gets to aim, so it does more work than the physics.
+ */
+function returned(ball, top, dir) {
+  const offset = (ball.y - (top + (PADDLE - 1) / 2)) / (PADDLE / 2);
+  ball.vx = dir * Math.min(MAX_SPEED, Math.abs(ball.vx) * 1.06);
+  ball.vy = clamp(offset * SPIN * ASPECT + ball.vy * 0.3, -0.5, 0.5);
+  // Never let a rally go flat. A ball with no angle is one the machine can park
+  // in front of forever, and a rally that cannot end is not a game.
+  if (Math.abs(ball.vy) < 0.08) ball.vy = (ball.vy < 0 ? -1 : 1) * 0.12;
+  return ball;
+}
+
+/** One tick of rally. Exported so a test can play a whole match with no clock. */
+export function step(state) {
+  const ball = state.ball;
+  ball.x += ball.vx;
+  ball.y += ball.vy;
+
+  // The top and bottom are walls, and the ball is put back inside rather than
+  // just reflected — at speed, a reflection alone can leave it outside.
+  if (ball.y < 0) { ball.y = -ball.y; ball.vy = Math.abs(ball.vy); }
+  if (ball.y > HEIGHT - 1) { ball.y = 2 * (HEIGHT - 1) - ball.y; ball.vy = -Math.abs(ball.vy); }
+
+  if (ball.vx < 0 && ball.x <= YOU_COL) {
+    if (catches(state.you, ball.y)) { ball.x = YOU_COL; returned(ball, state.you, 1); }
+  } else if (ball.vx > 0 && ball.x >= THEM_COL) {
+    if (catches(state.them, ball.y)) { ball.x = THEM_COL; returned(ball, state.them, -1); }
+  }
+
+  if (ball.x < 0) { state.theirs++; point(state, 1); }
+  else if (ball.x > WIDTH - 1) { state.yours++; point(state, -1); }
+
+  // The machine: idle in the middle until the ball is on its half, then chase
+  // the ball's row. Perfect tracking here would make the game unloseable for it,
+  // which is the same thing as unplayable.
+  const chasing = state.ball.vx > 0 && state.ball.x > WIDTH * 0.4;
+  const want = chasing ? state.ball.y - (PADDLE - 1) / 2 : (HEIGHT - PADDLE) / 2;
+  const move = clamp(want - state.them, -THEM_SPEED, chasing ? THEM_SPEED : THEM_SPEED / 2);
+  state.them = clamp(state.them + move, 0, HEIGHT - PADDLE);
+
+  return state;
+}
+
+function point(state, toward) {
+  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}`;
+  else serve(state, toward);
+}
+
+export const PONG = {
+  key: "pong",
+  aliases: ["tennis", "paddle"],
+  title: "PONG",
+  blurb: "first to seven, and the angle is all in where you hit it",
+  keys: "↑ ↓ move · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    const state = {
+      you: (HEIGHT - PADDLE) / 2,
+      them: (HEIGHT - PADDLE) / 2,
+      yours: 0,
+      theirs: 0,
+      over: null,
+      rng,
+    };
+    return serve(state, rng() < 0.5 ? -1 : 1);
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    if (key === "up") state.you = clamp(state.you - YOU_STEP, 0, HEIGHT - PADDLE);
+    if (key === "down") state.you = clamp(state.you + YOU_STEP, 0, HEIGHT - PADDLE);
+    return state;
+  },
+
+  status(state) {
+    return state.over ? state.over : `you ${state.yours} · machine ${state.theirs}`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const row of paddleRows(state.you)) put(YOU_COL, row, acid("█"));
+    for (const row of paddleRows(state.them)) put(THEM_COL, row, danger("█"));
+    put(Math.round(state.ball.x), Math.round(state.ball.y), bone("●"));
+
+    return grid.map((row, y) => row.map((cell, x) => (
+      // The net, which is only there so the middle of the table has a middle.
+      cell ?? (x === Math.floor(WIDTH / 2) && y % 2 === 0 ? dim("┊") : " ")
+    )).join(""));
+  },
+};

package/src/games-spyhunter.mjs

@@ -0,0 +1,230 @@
+// Spy Hunter. A road that will not hold still, traffic that will not get out of
+// the way, and a gun. Stay on the tarmac, shoot the ones shooting back, and do
+// not shoot the ones just driving home.
+//
+// The road is a list of rows, each one a left and a right edge, scrolled down
+// under a car that only ever moves sideways. Generating the next row from the
+// last one — rather than from a function of distance — is what makes the verge
+// bend instead of zig-zag, and it is the only reason it reads as a road.
+import { acid, amber, ash, bone, danger, dim } from "./ui.mjs";
+
+export const WIDTH = 40;
+export const HEIGHT = 18;
+
+/** The row your car is on. It never changes; the road comes to you. */
+export const CAR_ROW = HEIGHT - 3;
+export const CAR_W = 2;
+
+const MIN_ROAD = 13;
+const MAX_ROAD = 24;
+const BASE_SPEED = 0.34;   // rows of road per tick
+const MAX_SPEED = 0.75;
+const LIVES = 3;
+const GRACE = 25;          // ticks of "the road is clear" after a wreck
+const SHOT_SPEED = 1.6;    // rows per tick, travelled in halves so nothing is skipped
+
+/** The cars that are not you. */
+export const TRAFFIC = {
+  enemy: { art: "▜▛", paint: danger, points: 50, homing: 0.06 },
+  civilian: { art: "▐▌", paint: bone, points: -100, homing: 0 },
+};
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+/**
+ * The next row of road, bent a little from the one before it.
+ *
+ * The bend is random but pulled towards the middle of the screen, in proportion
+ * to how far out it already is. A drift with no pull is a random walk, and a
+ * random walk parks the road against one edge and leaves it there — which looks
+ * less like a road than like a bug.
+ */
+export function nextRow(prev, rng) {
+  const width = clamp(prev.right - prev.left + (rng() < 0.3 ? (rng() < 0.5 ? -1 : 1) : 0), MIN_ROAD, MAX_ROAD);
+  const centre = (prev.left + prev.right) / 2;
+  const pull = clamp((WIDTH / 2 - centre) / 8, -0.45, 0.45);
+  const roll = rng() * 2 - 1 + pull;
+  const drift = Math.abs(roll) < 0.55 ? 0 : Math.sign(roll);
+  // One cell of verge on each side always stays on screen, so "the road bends"
+  // never reads as "the road ends".
+  const left = clamp(prev.left + drift, 1, WIDTH - width - 2);
+  return { left, right: left + width };
+}
+
+/** A straight run of road to start on, so the first thing you meet is not a bend. */
+export function openRoad() {
+  const left = Math.floor((WIDTH - 20) / 2);
+  return Array.from({ length: HEIGHT }, () => ({ left, right: left + 20 }));
+}
+
+export const onRoad = (row, x) => row && x >= row.left && x + CAR_W - 1 <= row.right;
+
+/** Whether two cars, each CAR_W wide, are in the same place. */
+export const overlaps = (ax, bx) => Math.abs(Math.round(ax) - Math.round(bx)) < CAR_W;
+
+function wreck(state, why) {
+  state.lives--;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `${why} · ${state.score} points`;
+    return state;
+  }
+  // A wreck clears the road ahead, or you respawn straight into the car that
+  // just got you and lose the rest of your lives in three ticks.
+  state.traffic = [];
+  state.grace = GRACE;
+  const row = state.road[CAR_ROW];
+  state.car = Math.round((row.left + row.right) / 2) - 1;
+  return state;
+}
+
+/** One tick of road. Exported so a test can drive a whole run with no clock. */
+export function step(state) {
+  const { rng } = state;
+  state.dist += state.speed;
+  state.speed = Math.min(MAX_SPEED, BASE_SPEED + state.dist / 900);
+  if (state.grace > 0) state.grace--;
+
+  // Scroll: the road only shifts on whole rows, so the verge never shimmers.
+  state.scroll += state.speed;
+  while (state.scroll >= 1) {
+    state.scroll -= 1;
+    state.road.pop();
+    state.road.unshift(nextRow(state.road[0], rng));
+    for (const car of state.traffic) car.y += 1;
+    for (const shot of state.shots) shot.y += 1;
+  }
+
+  // Shots move faster than a car is tall, so they travel in half-steps and are
+  // checked against the traffic after each one. Moving the whole way in one go
+  // lets a shot pass clean through a car that was between the two positions.
+  for (let half = 0; half < 2; half++) {
+    for (const shot of state.shots) shot.y -= SHOT_SPEED / 2;
+    hitTraffic(state);
+  }
+  state.shots = state.shots.filter((shot) => shot.y > -1);
+
+  for (const car of state.traffic) {
+    car.y += state.speed - car.speed;
+    // An enemy leans towards you; traffic just drives.
+    if (TRAFFIC[car.kind].homing) {
+      car.x += Math.sign(state.car - car.x) * TRAFFIC[car.kind].homing;
+    }
+    const row = state.road[Math.round(car.y)];
+    if (row) car.x = clamp(car.x, row.left, row.right - CAR_W + 1);
+  }
+  state.traffic = state.traffic.filter((car) => car.y < HEIGHT + 1 && car.y > -3);
+
+  if (!state.grace) {
+    const row = state.road[CAR_ROW];
+    if (!onRoad(row, state.car)) return wreck(state, "off the road");
+    const rammed = state.traffic.find((car) => Math.round(car.y) === CAR_ROW && overlaps(car.x, state.car));
+    if (rammed) return wreck(state, `rammed ${rammed.kind === "enemy" ? "an enemy" : "a civilian"}`);
+  }
+
+  if (!state.grace && state.traffic.length < 4 && rng() < 0.05) {
+    const row = state.road[0];
+    const kind = rng() < 0.6 ? "enemy" : "civilian";
+    state.traffic.push({
+      kind,
+      x: row.left + Math.floor(rng() * (row.right - row.left - CAR_W + 1)),
+      y: 0,
+      // Slower than you, or the road behind would never catch anybody up.
+      speed: 0.1 + rng() * 0.18,
+    });
+  }
+
+  state.score += Math.floor(state.dist / 10) - state.miles;
+  state.miles = Math.floor(state.dist / 10);
+  return state;
+}
+
+/** Shots meet traffic. A civilian you shoot is a civilian you pay for. */
+function hitTraffic(state) {
+  for (const shot of [...state.shots]) {
+    const hit = state.traffic.find((car) => Math.abs(car.y - shot.y) < 0.9 && overlaps(car.x, shot.x - 0.5));
+    if (!hit) continue;
+    state.shots = state.shots.filter((s) => s !== shot);
+    state.traffic = state.traffic.filter((c) => c !== hit);
+    state.score = Math.max(0, state.score + TRAFFIC[hit.kind].points);
+  }
+  return state;
+}
+
+export const SPYHUNTER = {
+  key: "spyhunter",
+  aliases: ["spy", "chase", "hunter"],
+  title: "SPY HUNTER",
+  blurb: "keep it on the tarmac, shoot the ones shooting back",
+  keys: "← → steer · space fire · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    const road = openRoad();
+    return {
+      road,
+      traffic: [],
+      shots: [],
+      car: Math.round((road[CAR_ROW].left + road[CAR_ROW].right) / 2) - 1,
+      speed: BASE_SPEED,
+      scroll: 0,
+      dist: 0,
+      miles: 0,
+      score: 0,
+      lives: LIVES,
+      grace: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    if (key === "left") state.car -= 1;
+    else if (key === "right") state.car += 1;
+    else if (key === "space" || key === "up" || key === "enter") {
+      if (state.shots.length < 3) state.shots.push({ x: state.car + 0.5, y: CAR_ROW - 1 });
+    }
+    // Steering off the edge of the screen is a wreck like any other, so the car
+    // is only kept on the board, not on the road.
+    state.car = clamp(state.car, 0, WIDTH - CAR_W);
+    return state;
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    return `${state.score} · ${state.miles} mi · ${"▲".repeat(state.lives)}`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const car of state.traffic) {
+      const kind = TRAFFIC[car.kind];
+      [...kind.art].forEach((c, i) => put(Math.round(car.x) + i, Math.round(car.y), kind.paint(c)));
+    }
+    for (const shot of state.shots) put(Math.round(shot.x), Math.round(shot.y), amber("•"));
+    if (state.over) {
+      [...("✷✷")].forEach((c, i) => put(state.car + i, CAR_ROW, danger(c)));
+    } else if (!state.grace || Math.floor(state.grace / 3) % 2) {
+      [...("▟▙")].forEach((c, i) => put(state.car + i, CAR_ROW, acid(c)));
+    }
+
+    return grid.map((row, y) => {
+      const edge = state.road[y];
+      return row.map((cell, x) => {
+        if (cell) return cell;
+        if (x < edge.left || x > edge.right) return ash("▒");
+        // The centre line, dashed, and moving — without it the road is a
+        // stationary corridor and you cannot tell you are going anywhere.
+        const middle = Math.round((edge.left + edge.right) / 2);
+        return x === middle && (y + Math.floor(state.dist)) % 4 < 2 ? dim("┆") : " ";
+      }).join("");
+    });
+  },
+};

package/src/games-stagedive.mjs

@@ -0,0 +1,206 @@
+// Stagedive. You are running the barricade, the stage is coming at you, and it
+// does not stop. Hop the monitor wedges and the amp stacks, duck the
+// crowdsurfers, take the picks. One mistake is the whole run.
+//
+// A side-scroller in a terminal is really a scrolling list: the runner never
+// moves along the x axis at all. Everything else slides left past a fixed
+// column, which is why `speed` is measured in columns per tick and why the gap
+// between hazards is multiplied by it — a jump lasts a fixed number of ticks, so
+// a fair gap has to get longer as the stage gets faster.
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 50;
+export const HEIGHT = 9;
+
+/** The row the runner's feet are on, and the stage edge under it. */
+export const GROUND = 7;
+const FLOOR = GROUND + 1;
+
+/** The runner's column. It never changes — the stage moves, not you. */
+export const RUNNER = 8;
+
+const BASE_SPEED = 0.85;
+const MAX_SPEED = 1.75;
+const GRAVITY = 0.15;
+const JUMP = -1.3;    // ~5 rows up and ~17 ticks in the air
+const DUCK_TICKS = 8; // a tap of ↓ stays crouched this long, so a repeat holds it
+const SLAM = 0.7;     // ↓ in mid-air comes down early, which is how you save a bad jump
+
+const crowd = rgb(255, 120, 180);
+
+/**
+ * What is on the stage. `art` is one row's worth of cells and `rows` is which
+ * rows it fills, so its width and its hitbox are the same number by
+ * construction — a hazard that is drawn wider than it hits is the oldest bug in
+ * the genre. `death` is what the status line says when it gets you.
+ */
+export const HAZARDS = {
+  wedge: { art: "██", rows: [GROUND], paint: ash, death: "tripped over a monitor wedge" },
+  stack: { art: "███", rows: [GROUND - 1, GROUND], paint: bone, death: "ran into an amp stack" },
+  // Head height: a standing runner wears it, a crouched one does not.
+  surfer: { art: "╾●╼", rows: [GROUND - 1], paint: crowd, death: "wore a crowdsurfer" },
+};
+
+const PICK = amber("♦");
+
+/** The cells a thing covers, so a hit is decided by what the screen showed. */
+export function cells(thing) {
+  const x = Math.round(thing.x);
+  if (thing.kind === "pick") return { cols: [x, x], rows: [thing.row] };
+  const { art, rows } = HAZARDS[thing.kind];
+  return { cols: [x, x + art.length - 1], rows };
+}
+
+/** The runner: two rows standing, one crouched — which is the whole point of ↓. */
+export function runnerRows(state) {
+  const y = Math.round(state.y);
+  if (state.duck > 0 && !state.airborne) return [GROUND];
+  return [y - 1, y];
+}
+
+const hits = (thing, rows) => {
+  const { cols, rows: theirs } = cells(thing);
+  return RUNNER >= cols[0] && RUNNER <= cols[1] && theirs.some((r) => rows.includes(r));
+};
+
+/**
+ * Put the next thing on the far edge, and decide how far behind it the one
+ * after that will be. The gap scales with speed because a jump is a fixed
+ * number of ticks: without that, the stage eventually outruns the jump and the
+ * game stops being losable-by-mistake and starts being unfair.
+ */
+export function spawn(state) {
+  const { rng } = state;
+  const edge = WIDTH + 2;
+  const roll = rng();
+
+  if (roll < 0.3) {
+    // A line of picks. Low ones are free; a high arc is paid for with a jump.
+    const high = rng() < 0.55;
+    const count = 3 + Math.floor(rng() * 3);
+    for (let i = 0; i < count; i++) {
+      state.things.push({ kind: "pick", x: edge + i * 2, row: high ? (i === 0 || i === count - 1 ? 5 : 4) : GROUND });
+    }
+    state.next = (10 + rng() * 8) * state.speed;
+    return state;
+  }
+
+  const kind = roll < 0.55 ? "wedge" : roll < 0.8 ? "stack" : "surfer";
+  state.things.push({ kind, x: edge });
+  state.next = (16 + rng() * 14) * state.speed;
+  return state;
+}
+
+export const meters = (state) => Math.floor(state.dist / 2);
+
+/** One tick of stage. Exported so a test can run the whole set without a clock. */
+export function step(state) {
+  state.dist += state.speed;
+  state.speed = Math.min(MAX_SPEED, BASE_SPEED + state.dist / 2200);
+
+  if (state.airborne) {
+    state.vy += GRAVITY;
+    state.y += state.vy;
+    if (state.y >= GROUND) { state.y = GROUND; state.vy = 0; state.airborne = false; }
+  }
+  if (state.duck > 0) state.duck--;
+
+  for (const thing of state.things) thing.x -= state.speed;
+  state.things = state.things.filter((t) => !t.taken && t.x > -4);
+
+  state.next -= state.speed;
+  if (state.next <= 0) spawn(state);
+
+  const rows = runnerRows(state);
+  for (const thing of state.things) {
+    if (!hits(thing, rows)) continue;
+    if (thing.kind === "pick") { thing.taken = true; state.picks++; continue; }
+    state.over = `${HAZARDS[thing.kind].death} · ${meters(state)} m`;
+    return state;
+  }
+  return state;
+}
+
+export const STAGEDIVE = {
+  key: "stagedive",
+  aliases: ["dive", "runner", "stage"],
+  title: "STAGEDIVE",
+  blurb: "run the barricade, hop the gear, duck the crowd, take the picks",
+  keys: "↑ jump · ↓ duck (and slam) · space jump · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      y: GROUND,
+      vy: 0,
+      airborne: false,
+      duck: 0,
+      dist: 0,
+      speed: BASE_SPEED,
+      picks: 0,
+      things: [],
+      next: 24, // a moment of clear stage before the first thing arrives
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    if (key === "up" || key === "space" || key === "enter") {
+      if (state.airborne) return state; // no second jump; the floor is the rule
+      state.vy = JUMP;
+      state.airborne = true;
+      state.duck = 0;
+      return state;
+    }
+    if (key === "down") {
+      // In the air this is a slam, on the ground it is a crouch. Both are the
+      // same key because both are "get low", and one key is easier to mean.
+      if (state.airborne) state.vy = Math.max(state.vy, SLAM);
+      else state.duck = DUCK_TICKS;
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over
+      ? `${state.over} · ${state.picks} picks`
+      : `${meters(state)} m · ${state.picks} picks`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const thing of state.things) {
+      const { cols, rows } = cells(thing);
+      if (thing.kind === "pick") { put(cols[0], rows[0], PICK); continue; }
+      const { art, paint } = HAZARDS[thing.kind];
+      for (const row of rows) [...art].forEach((c, i) => put(cols[0] + i, row, paint(c)));
+    }
+
+    const y = Math.round(state.y);
+    if (state.over) {
+      put(RUNNER, GROUND, danger("✷"));
+    } else if (state.duck > 0 && !state.airborne) {
+      put(RUNNER, GROUND, acid("▄"));
+    } else {
+      put(RUNNER, y - 1, acid("○"));
+      // The legs alternate with the stage, so standing still looks like running.
+      put(RUNNER, y, acid(state.airborne ? "⋏" : Math.floor(state.dist) % 2 ? "⋀" : "⋏"));
+    }
+
+    return grid.map((row, ry) => row.map((cell, x) => {
+      if (cell) return cell;
+      if (ry !== FLOOR) return " ";
+      // The stage edge, with a mark every few cells so the speed is visible even
+      // when nothing else is on screen.
+      return (x + Math.floor(state.dist)) % 7 === 0 ? dim("╪") : ash("═");
+    }).join(""));
+  },
+};