@sodiumlabs/gamecord 0.1.1

package/dist/index.mjs

@@ -0,0 +1,2561 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/games/2048.ts
+import z2 from "zod/v4";
+import { createCanvas } from "@napi-rs/canvas";
+import { ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle, MessageFlags } from "discord.js";
+
+// src/core/Game.ts
+import { EventEmitter } from "events";
+import {
+  Message
+} from "discord.js";
+var Game = class extends EventEmitter {
+  static {
+    __name(this, "Game");
+  }
+  /**
+   * The initial context that started this game, either an interaction or a message.
+   */
+  context;
+  /**
+   * If the {@link Game#context} is a `Message` or not.
+   */
+  isMessage;
+  /**
+   * The player that started the game.
+   */
+  player;
+  /**
+   * The timestamp at which the class was instantiated. Not when {@link Game#start} was called.
+   */
+  gameStartedAt;
+  constructor(context) {
+    super();
+    this.context = context;
+    const isMessage = context instanceof Message;
+    this.isMessage = isMessage;
+    this.player = isMessage ? context.author : context.user;
+    this.gameStartedAt = Date.now();
+    if (isMessage && !context.channel.isSendable()) {
+      throw new Error("The context channel must be a sendable channel");
+    }
+  }
+  /**
+   * Returns the current duration of the game.
+   */
+  getGameDuration() {
+    return Date.now() - this.gameStartedAt;
+  }
+  async sendMessage(options) {
+    if (this.isMessage) {
+      const message = this.context;
+      const channel = message.channel;
+      return await channel.send(options);
+    } else {
+      const interaction = this.context;
+      if (interaction.deferred || interaction.replied) {
+        return await interaction.editReply(options);
+      } else {
+        const result = await interaction.reply({ ...options, withResponse: true });
+        return result.resource.message;
+      }
+    }
+  }
+  /**
+   * Edit the context message if it was an interaction,
+   * or edit the given message.
+   *
+   * Since the original context is only valid 15 minutes,
+   * we need the message reference if the interaction died.
+   */
+  async editContextOrMessage(message, options) {
+    if (!this.isMessage) {
+      const interaction = this.context;
+      if (Date.now() - interaction.createdTimestamp < 6e4 * 15) {
+        return await interaction.editReply(options);
+      }
+    }
+    return await message.edit(options);
+  }
+  /**
+   * Utility to build an embed from the options.
+   */
+  async buildEmbed(embed, props) {
+    return typeof embed === "function" ? await embed(this) : {
+      author: {
+        name: this.player.displayName,
+        icon_url: this.player.displayAvatarURL()
+      },
+      ...props,
+      ...embed
+    };
+  }
+  /**
+   * Utility to build an end embed from the options.
+   */
+  async buildEndEmbed(embed, endEmbed, result, props) {
+    let built;
+    if (endEmbed) {
+      built = typeof endEmbed === "function" ? await endEmbed(this, result) : endEmbed;
+    } else {
+      built = typeof embed === "function" ? await embed(this) : {
+        author: {
+          name: this.player.displayName,
+          icon_url: this.player.displayAvatarURL()
+        },
+        ...embed,
+        ...props
+      };
+    }
+    return built;
+  }
+  /**
+   * Utility to build the result of a game.
+   */
+  result(data) {
+    return {
+      player: this.player,
+      gameStartedAt: this.gameStartedAt,
+      gameDuration: this.getGameDuration(),
+      ...data
+    };
+  }
+};
+
+// src/utils/games.ts
+import assert from "assert";
+var numberEmojis = ["0\uFE0F\u20E3", "1\uFE0F\u20E3", "2\uFE0F\u20E3", "3\uFE0F\u20E3", "4\uFE0F\u20E3", "5\uFE0F\u20E3", "6\uFE0F\u20E3", "7\uFE0F\u20E3", "8\uFE0F\u20E3", "9\uFE0F\u20E3", "\u{1F51F}"];
+var getNumberEmoji = /* @__PURE__ */ __name((number) => {
+  assert(number >= 0 && number <= 9);
+  return numberEmojis[number];
+}, "getNumberEmoji");
+var removeEmoji = /* @__PURE__ */ __name((button) => {
+  if ("emoji" in button.data) {
+    button.data.emoji = void 0;
+  }
+  return button;
+}, "removeEmoji");
+var moveInDirection = /* @__PURE__ */ __name((pos, direction) => {
+  if (direction === "up") return { x: pos.x, y: pos.y - 1 };
+  if (direction === "down") return { x: pos.x, y: pos.y + 1 };
+  if (direction === "left") return { x: pos.x - 1, y: pos.y };
+  if (direction === "right") return { x: pos.x + 1, y: pos.y };
+  return pos;
+}, "moveInDirection");
+var getOppositeDirection = /* @__PURE__ */ __name((direction) => {
+  if (direction === "up") return "down";
+  if (direction === "down") return "up";
+  if (direction === "left") return "right";
+  return "left";
+}, "getOppositeDirection");
+
+// src/utils/schemas.ts
+import z from "zod/v4";
+var apiEmbed = /* @__PURE__ */ __name(() => z.object({
+  author: z.object({
+    name: z.string(),
+    url: z.string().optional(),
+    icon_url: z.string().optional()
+  }),
+  thumbnail: z.object({
+    url: z.string()
+  }),
+  title: z.string(),
+  color: z.union([
+    z.string().transform((val) => {
+      return parseInt(val.slice(1), 16);
+    }),
+    z.number().int()
+  ]),
+  description: z.string(),
+  image: z.object({
+    url: z.string()
+  }),
+  footer: z.object({
+    text: z.string(),
+    icon_url: z.string().optional()
+  })
+}).partial(), "apiEmbed");
+var functionable = /* @__PURE__ */ __name((schema) => () => z.union([schema, z.custom()]), "functionable");
+var embedBuilder = /* @__PURE__ */ __name(() => functionable(apiEmbed())(), "embedBuilder");
+var gameMessage = /* @__PURE__ */ __name(() => z.union([z.string().transform((val) => () => val), z.custom()]), "gameMessage");
+var resultMessage = /* @__PURE__ */ __name(() => z.union([z.string().transform((val) => () => val), z.custom()]), "resultMessage");
+var var2Message = /* @__PURE__ */ __name(() => z.union([z.string().transform((val) => () => val), z.custom()]), "var2Message");
+
+// src/utils/constants.ts
+var colors = {
+  green: 2600544,
+  red: 15158332,
+  yellow: 16236389,
+  blue: 2719929,
+  blurple: 5793266
+};
+
+// src/utils/random.ts
+var getRandomInt = /* @__PURE__ */ __name((max, min = 0) => {
+  if (min >= max) throw new RangeError("`min` should be less than `max`");
+  return Math.floor(Math.random() * (min ? max + 1 - min : max + 1)) + min;
+}, "getRandomInt");
+var getRandomElement = /* @__PURE__ */ __name((array) => {
+  if (!array.length) throw new RangeError("The array should not be empty");
+  return array[Math.floor(Math.random() * array.length)];
+}, "getRandomElement");
+var shuffleArray = /* @__PURE__ */ __name((array) => {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}, "shuffleArray");
+
+// src/games/2048.ts
+var defaultOptions = {
+  embed: {
+    title: "2048",
+    color: colors.blurple
+  },
+  notPlayerMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} can use this menu.`, "notPlayerMessage"),
+  timeout: 6e4,
+  buttonStyle: ButtonStyle.Secondary,
+  emojis: {
+    up: "\u{1F53C}",
+    down: "\u{1F53D}",
+    right: "\u25B6\uFE0F",
+    left: "\u25C0\uFE0F"
+  }
+};
+var game2048Options = z2.object({
+  embed: embedBuilder().optional().default(defaultOptions.embed),
+  endEmbed: embedBuilder().optional(),
+  notPlayerMessage: gameMessage().optional().default(() => defaultOptions.notPlayerMessage),
+  timeout: z2.number().int().optional().default(defaultOptions.timeout),
+  buttonStyle: z2.number().int().optional().default(ButtonStyle.Secondary),
+  emojis: z2.object({
+    up: z2.string().optional().default(defaultOptions.emojis.up),
+    down: z2.string().optional().default(defaultOptions.emojis.down),
+    right: z2.string().optional().default(defaultOptions.emojis.right),
+    left: z2.string().optional().default(defaultOptions.emojis.left)
+  }).optional().default(defaultOptions.emojis)
+});
+var Game2048 = class extends Game {
+  static {
+    __name(this, "Game2048");
+  }
+  options;
+  /**
+   * The numbers are stored as exponents (1 => 2, 2 => 4, etc.).
+   */
+  gameboard = [];
+  length = 4;
+  score = 0;
+  message = null;
+  mergedPos = [];
+  constructor(context, options) {
+    super(context);
+    this.options = game2048Options.parse(options || {});
+    for (let y = 0; y < this.length; y++) {
+      for (let x = 0; x < this.length; x++) {
+        this.gameboard[y * this.length + x] = 0;
+      }
+    }
+  }
+  async start() {
+    this.placeRandomTile();
+    this.placeRandomTile();
+    const embed = await this.buildEmbed(this.options.embed, {
+      image: {
+        url: "attachment://board.png"
+      },
+      fields: [
+        {
+          name: "Current Score",
+          value: this.score.toString()
+        }
+      ]
+    });
+    this.message = await this.sendMessage({
+      embeds: [embed],
+      components: this.getComponents(),
+      files: [await this.getBoardAttachment()]
+    });
+    this.handleButtons(this.message);
+  }
+  handleButtons(message) {
+    const collector = message.createMessageComponentCollector({ idle: this.options.timeout });
+    collector.on("collect", async (i) => {
+      if (!i.customId.startsWith("$gamecord")) return;
+      if (i.user.id !== this.player.id) {
+        if (this.options.notPlayerMessage) {
+          try {
+            await i.reply({
+              content: this.options.notPlayerMessage(this),
+              flags: MessageFlags.Ephemeral
+            });
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+        return;
+      }
+      let moved = false;
+      this.mergedPos = [];
+      const direction = i.customId.split("-").at(-1);
+      try {
+        await i.deferUpdate();
+      } catch (err) {
+        this.emit("error", err);
+        return;
+      }
+      if (direction === "up" || direction === "down") moved = this.shiftVertical(direction);
+      if (direction === "left" || direction === "right") moved = this.shiftHorizontal(direction);
+      if (moved) this.placeRandomTile();
+      if (this.isGameOver()) return collector.stop("$over");
+      const embed = await this.buildEmbed(this.options.embed, {
+        image: {
+          url: "attachment://board.png"
+        },
+        fields: [
+          {
+            name: "Current Score",
+            value: this.score.toString()
+          }
+        ]
+      });
+      try {
+        await i.editReply({ embeds: [embed], files: [await this.getBoardAttachment()] });
+      } catch (err) {
+        this.emit("error", err);
+      }
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "idle" || reason === "$over") {
+        await this.gameOver(message, reason === "$over" ? "over" : "timeout");
+      }
+    });
+  }
+  async gameOver(message, outcome) {
+    const result = this.result({ outcome, score: this.score, hasWon: !!this.gameboard.find((n) => n >= 11) });
+    this.emit("gameOver", result);
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      image: {
+        url: "attachment://board.png"
+      },
+      fields: [
+        {
+          name: "Total Score",
+          value: this.score.toString()
+        }
+      ]
+    });
+    try {
+      await this.editContextOrMessage(message, {
+        embeds: [embed],
+        components: this.getComponents(true),
+        files: [await this.getBoardAttachment()]
+      });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  isGameOver() {
+    let boardFull = true;
+    let numMoves = 0;
+    for (let y = 0; y < this.length; y++) {
+      for (let x = 0; x < this.length; x++) {
+        if (this.gameboard[y * this.length + x] === 0) boardFull = false;
+        const posNum = this.gameboard[y * this.length + x];
+        for (const dir of ["down", "left", "right", "up"]) {
+          const newPos = moveInDirection({ x, y }, dir);
+          if (this.isInsideBlock(newPos) && (this.gameboard[newPos.y * this.length + newPos.x] === 0 || this.gameboard[newPos.y * this.length + newPos.x] === posNum)) {
+            numMoves++;
+          }
+        }
+      }
+    }
+    return boardFull && numMoves === 0;
+  }
+  placeRandomTile() {
+    let tilePos = { x: 0, y: 0 };
+    do {
+      tilePos = { x: getRandomInt(this.length), y: getRandomInt(this.length) };
+    } while (this.gameboard[tilePos.y * this.length + tilePos.x] != 0);
+    this.gameboard[tilePos.y * this.length + tilePos.x] = Math.random() > 0.8 ? 2 : 1;
+  }
+  /**
+   * @returns Has moved
+   */
+  shiftVertical(dir) {
+    let moved = false;
+    for (let x = 0; x < this.length; x++) {
+      if (dir === "up") {
+        for (let y = 1; y < this.length; y++) moved = this.shift({ x, y }, "up") || moved;
+      } else {
+        for (let y = this.length - 2; y >= 0; y--) moved = this.shift({ x, y }, "down") || moved;
+      }
+    }
+    return moved;
+  }
+  /**
+   * @returns Has moved
+   */
+  shiftHorizontal(dir) {
+    let moved = false;
+    for (let y = 0; y < this.length; y++) {
+      if (dir === "left") {
+        for (let x = 1; x < this.length; x++) {
+          moved = this.shift({ x, y }, "left") || moved;
+        }
+      } else {
+        for (let x = this.length - 2; x >= 0; x--) {
+          moved = this.shift({ x, y }, "right") || moved;
+        }
+      }
+    }
+    return moved;
+  }
+  isInsideBlock(pos) {
+    return pos.x >= 0 && pos.y >= 0 && pos.x < this.length && pos.y < this.length;
+  }
+  /**
+   * @returns Has moved
+   */
+  shift(pos, dir) {
+    let moved = false;
+    const movingTile = this.gameboard[pos.y * this.length + pos.x];
+    if (movingTile === 0) return false;
+    let set = false;
+    let moveTo = pos;
+    while (!set) {
+      moveTo = moveInDirection(moveTo, dir);
+      const moveToTile = this.gameboard[moveTo.y * this.length + moveTo.x];
+      if (!this.isInsideBlock(moveTo) || moveToTile !== 0 && moveToTile !== movingTile || !!this.mergedPos.find((p) => p.x === moveTo.x && p.y === moveTo.y)) {
+        const moveBack = moveInDirection(moveTo, getOppositeDirection(dir));
+        if (!(moveBack.x === pos.x && moveBack.y === pos.y)) {
+          this.gameboard[pos.y * this.length + pos.x] = 0;
+          this.gameboard[moveBack.y * this.length + moveBack.x] = movingTile;
+          moved = true;
+        }
+        set = true;
+      } else if (moveToTile === movingTile) {
+        moved = true;
+        this.gameboard[moveTo.y * this.length + moveTo.x] += 1;
+        this.score += Math.floor(Math.pow(this.gameboard[moveTo.y * this.length + moveTo.x], 2));
+        this.gameboard[pos.y * this.length + pos.x] = 0;
+        this.mergedPos.push(moveTo);
+        set = true;
+      }
+    }
+    return moved;
+  }
+  getComponents(disabled = false) {
+    const row1 = new ActionRowBuilder().setComponents(
+      new ButtonBuilder().setDisabled(true).setLabel("\u200B").setStyle(this.options.buttonStyle).setCustomId("$gamecord-2048-none1"),
+      new ButtonBuilder().setDisabled(disabled).setEmoji(this.options.emojis.up).setStyle(this.options.buttonStyle).setCustomId("$gamecord-2048-up"),
+      new ButtonBuilder().setDisabled(true).setLabel("\u200B").setStyle(this.options.buttonStyle).setCustomId("$gamecord-2048-none2")
+    );
+    const row2 = new ActionRowBuilder().setComponents(
+      new ButtonBuilder().setDisabled(disabled).setEmoji(this.options.emojis.left).setStyle(this.options.buttonStyle).setCustomId("$gamecord-2048-left"),
+      new ButtonBuilder().setDisabled(disabled).setEmoji(this.options.emojis.down).setStyle(this.options.buttonStyle).setCustomId("$gamecord-2048-down"),
+      new ButtonBuilder().setDisabled(disabled).setEmoji(this.options.emojis.right).setStyle(this.options.buttonStyle).setCustomId("$gamecord-2048-right")
+    );
+    return [row1, row2];
+  }
+  async getBoardAttachment() {
+    return new AttachmentBuilder(await this.getBoardImage(), { name: "board.png" });
+  }
+  async getBoardImage() {
+    const rows = this.length;
+    const cols = this.length;
+    const tile = 88;
+    const gap = 12;
+    const padding = 20;
+    const width = padding * 2 + cols * tile + (cols - 1) * gap;
+    const height = padding * 2 + rows * tile + (rows - 1) * gap;
+    const canvas = createCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    const PALETTE = {
+      bg: "#faf8ef",
+      board: "#bbada0",
+      empty: "#cdc1b4",
+      textDark: "#776e65",
+      textLight: "#f9f6f2",
+      tiles: /* @__PURE__ */ new Map([
+        [2, "#eee4da"],
+        [4, "#ede0c8"],
+        [8, "#f2b179"],
+        [16, "#f59563"],
+        [32, "#f67c5f"],
+        [64, "#f65e3b"],
+        [128, "#edcf72"],
+        [256, "#edcc61"],
+        [512, "#edc850"],
+        [1024, "#edc53f"],
+        [2048, "#edc22e"]
+      ])
+    };
+    ctx.fillStyle = PALETTE.bg;
+    ctx.fillRect(0, 0, width, height);
+    const boardRadius = 8;
+    const boardX = padding - 8;
+    const boardY = padding - 8;
+    const boardWidth = cols * tile + (cols - 1) * gap + 16;
+    const boardHeight = rows * tile + (rows - 1) * gap + 16;
+    function roundRect(x, y, w, h, r) {
+      ctx.beginPath();
+      ctx.moveTo(x + r, y);
+      ctx.lineTo(x + w - r, y);
+      ctx.quadraticCurveTo(x + w, y, x + w, y + r);
+      ctx.lineTo(x + w, y + h - r);
+      ctx.quadraticCurveTo(x + w, y + h, x + w - r, y + h);
+      ctx.lineTo(x + r, y + h);
+      ctx.quadraticCurveTo(x, y + h, x, y + h - r);
+      ctx.lineTo(x, y + r);
+      ctx.quadraticCurveTo(x, y, x + r, y);
+      ctx.closePath();
+    }
+    __name(roundRect, "roundRect");
+    ctx.fillStyle = PALETTE.board;
+    roundRect(boardX, boardY, boardWidth, boardHeight, boardRadius);
+    ctx.fill();
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        const x = padding + c * (tile + gap);
+        const y = padding + r * (tile + gap);
+        const exponent = this.gameboard[r * this.length + c] ?? 0;
+        const value = exponent > 0 ? 2 ** exponent : 0;
+        const bgColor = value === 0 ? PALETTE.empty : PALETTE.tiles.get(value) ?? "#3c3a32";
+        const radius = 6;
+        ctx.fillStyle = bgColor;
+        roundRect(x, y, tile, tile, radius);
+        ctx.fill();
+        ctx.lineWidth = 2;
+        ctx.strokeStyle = value === 0 ? "rgba(0,0,0,0.06)" : "rgba(0,0,0,0.08)";
+        ctx.stroke();
+        if (value !== 0) {
+          const digits = value.toString().length;
+          let fontSize = Math.floor(tile * 0.54);
+          if (digits >= 3) fontSize = Math.floor(tile * 0.46);
+          if (digits >= 4) fontSize = Math.floor(tile * 0.36);
+          ctx.font = `700 ${fontSize}px sans-serif`;
+          ctx.fillStyle = value <= 4 ? PALETTE.textDark : PALETTE.textLight;
+          ctx.fillText(value.toString(), x + tile / 2, y + tile / 2 + 2);
+        }
+      }
+    }
+    return canvas.toBuffer("image/png");
+  }
+};
+
+// src/games/Connect4.ts
+import z4 from "zod/v4";
+import { ActionRowBuilder as ActionRowBuilder3, ButtonBuilder as ButtonBuilder3, ButtonStyle as ButtonStyle3, MessageFlags as MessageFlags2 } from "discord.js";
+
+// src/core/VersusGame.ts
+import z3 from "zod";
+import { ActionRowBuilder as ActionRowBuilder2, ButtonBuilder as ButtonBuilder2, ButtonStyle as ButtonStyle2, User as User2 } from "discord.js";
+var defaultOptions2 = {
+  timeout: 6e4,
+  requestEmbed: /* @__PURE__ */ __name((name) => ({ player }) => ({
+    color: colors.blue,
+    description: `${player} has invited you for a round of **${name}**.`
+  }), "requestEmbed"),
+  rejectEmbed: /* @__PURE__ */ __name((name) => ({ opponent }) => ({
+    color: colors.red,
+    description: `The player ${opponent} denied your request for a round of **${name}**.`
+  }), "rejectEmbed"),
+  timeoutEmbed: /* @__PURE__ */ __name(({ opponent }) => ({
+    color: colors.yellow,
+    description: `Dropped the game as the player ${opponent} did not respond.`
+  }), "timeoutEmbed"),
+  buttons: {
+    accept: "Accept",
+    reject: "Reject"
+  }
+};
+var versusOptions = /* @__PURE__ */ __name((name) => z3.object({
+  opponent: z3.custom((val) => val instanceof User2, {
+    error: "The opponent must be an instance of a discord.js User"
+  }),
+  timeout: z3.number().int().optional().default(defaultOptions2.timeout),
+  requestEmbed: z3.custom().optional().default(() => defaultOptions2.requestEmbed(name)),
+  rejectEmbed: z3.custom().optional().default(() => defaultOptions2.rejectEmbed(name)),
+  timeoutEmbed: z3.custom().optional().default(() => defaultOptions2.timeoutEmbed),
+  buttons: z3.object({
+    accept: z3.string().optional().default(defaultOptions2.buttons.accept),
+    reject: z3.string().optional().default(defaultOptions2.buttons.reject)
+  }).optional().default(defaultOptions2.buttons)
+}), "versusOptions");
+var VersusGame = class extends Game {
+  static {
+    __name(this, "VersusGame");
+  }
+  versusOptions;
+  /**
+   * The opponent user.
+   */
+  opponent;
+  constructor(context, options) {
+    super(context);
+    this.versusOptions = options;
+    this.opponent = options.opponent;
+  }
+  async requestVersus() {
+    const players = { player: this.player, opponent: this.opponent };
+    return new Promise(async (resolve) => {
+      const row = new ActionRowBuilder2().setComponents(
+        new ButtonBuilder2().setLabel(this.versusOptions.buttons.accept).setCustomId("$gamecord-versus-accept").setStyle(ButtonStyle2.Success),
+        new ButtonBuilder2().setLabel(this.versusOptions.buttons.reject).setCustomId("$gamecord-versus-reject").setStyle(ButtonStyle2.Danger)
+      );
+      const msg = await this.sendMessage({
+        content: this.opponent.toString(),
+        embeds: [this.versusOptions.requestEmbed(players)],
+        components: [row],
+        allowedMentions: { parse: ["users"] }
+      });
+      const collector = msg.createMessageComponentCollector({ time: this.versusOptions.timeout });
+      collector.on("collect", async (i) => {
+        try {
+          await i.deferUpdate();
+        } catch (err) {
+          this.emit("error", err);
+        }
+        if (i.user.id === this.opponent.id) {
+          collector.stop(i.customId.split("-").at(-1));
+        }
+      });
+      collector.on("end", async (_, reason) => {
+        if (reason === "accept") return resolve(msg);
+        const isTime = reason === "time";
+        const embed = isTime ? this.versusOptions.timeoutEmbed : this.versusOptions.rejectEmbed;
+        this.emit("versusReject", isTime);
+        this.emit("end");
+        try {
+          for (const btn of row.components) {
+            btn.setDisabled(true);
+          }
+          await this.editContextOrMessage(msg, {
+            embeds: [embed(players)],
+            components: [row]
+          });
+        } catch (err) {
+          this.emit("error", err);
+        }
+        return resolve(null);
+      });
+    });
+  }
+  /**
+   * Utility to build an embed from the options.
+   */
+  async buildEmbed(embed, props) {
+    return await super.buildEmbed(embed, {
+      author: void 0,
+      footer: {
+        text: `${this.player.displayName} vs ${this.opponent.displayName}`
+      },
+      ...props
+    });
+  }
+  /**
+   * Utility to build an end embed from the options.
+   */
+  async buildEndEmbed(embed, endEmbed, result, props) {
+    return await super.buildEndEmbed(embed, endEmbed, result, {
+      author: void 0,
+      footer: {
+        text: `${this.player.displayName} vs ${this.opponent.displayName}`
+      },
+      ...props
+    });
+  }
+};
+
+// src/games/Connect4.ts
+var defaultOptions3 = {
+  embed: {
+    title: "Connect 4",
+    color: colors.blurple
+  },
+  winMessage: /* @__PURE__ */ __name((res) => `${res.winnerEmoji} | **${res.winner}** won the TicTacToe Game.`, "winMessage"),
+  tieMessage: /* @__PURE__ */ __name(() => "The Game tied! No one won the Game!", "tieMessage"),
+  timeoutMessage: /* @__PURE__ */ __name(() => "The Game went unfinished! No one won the Game!", "timeoutMessage"),
+  turnMessage: /* @__PURE__ */ __name((turn) => `${turn.emoji} | It's player **${turn.player.displayName}**'s turn.`, "turnMessage"),
+  notPlayerMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} and ${game.opponent} can use this menu.`, "notPlayerMessage"),
+  statusText: "Game Status",
+  emojis: {
+    board: "\u26AB",
+    player1: "\u{1F534}",
+    player2: "\u{1F7E1}"
+  },
+  buttonStyle: ButtonStyle3.Secondary,
+  timeout: 6e4
+};
+var connect4Options = z4.object({
+  versus: versusOptions("Connect 4"),
+  embed: embedBuilder().optional().default(defaultOptions3.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions3.winMessage),
+  tieMessage: resultMessage().optional().default(() => defaultOptions3.tieMessage),
+  timeoutMessage: resultMessage().optional().default(() => defaultOptions3.timeoutMessage),
+  turnMessage: var2Message().optional().default(() => defaultOptions3.turnMessage),
+  notPlayerMessage: gameMessage().optional().default(() => defaultOptions3.notPlayerMessage),
+  statusText: z4.string().optional().default(defaultOptions3.statusText),
+  emojis: z4.object({
+    board: z4.string().optional().default(defaultOptions3.emojis.board),
+    player1: z4.string().optional().default(defaultOptions3.emojis.player1),
+    player2: z4.string().optional().default(defaultOptions3.emojis.player2)
+  }).optional().default(defaultOptions3.emojis),
+  buttonStyle: z4.number().int().optional().default(defaultOptions3.buttonStyle),
+  timeout: z4.number().int().optional().default(defaultOptions3.timeout)
+});
+var Connect4 = class extends VersusGame {
+  static {
+    __name(this, "Connect4");
+  }
+  options;
+  /**
+   * A 6*7 elements array.
+   *
+   * - `0` : empty
+   * - `1` : player 1
+   * - `2` : player 2
+   */
+  gameboard = [];
+  isPlayer1Turn = true;
+  message = null;
+  locked = false;
+  constructor(context, options) {
+    const parsed = connect4Options.parse(options || {});
+    super(context, parsed.versus);
+    this.options = parsed;
+    for (let y = 0; y < 6; y++) {
+      for (let x = 0; x < 7; x++) {
+        this.gameboard[y * 7 + x] = 0;
+      }
+    }
+  }
+  async start() {
+    this.message = await this.requestVersus();
+    if (this.message) this.runGame(this.message);
+  }
+  async runGame(message) {
+    try {
+      const embed = await this.buildEmbed(this.options.embed, {
+        description: this.getBoardContent(),
+        fields: [
+          {
+            name: this.options.statusText,
+            value: this.options.turnMessage(this.getPlayerTurnData(), this)
+          }
+        ]
+      });
+      await this.editContextOrMessage(message, {
+        content: null,
+        embeds: [embed],
+        components: this.getComponents()
+      });
+    } catch (err) {
+      this.emit("fatalError", err);
+      this.emit("end");
+      return;
+    }
+    this.handleButtons(message);
+  }
+  handleButtons(message) {
+    const collector = message.createMessageComponentCollector({ idle: this.options.timeout });
+    collector.on("collect", async (i) => {
+      if (!i.customId.startsWith("$gamecord")) return;
+      if (i.user.id !== this.player.id && i.user.id !== this.opponent.id) {
+        if (this.options.notPlayerMessage) {
+          try {
+            await i.reply({
+              content: this.options.notPlayerMessage(this),
+              flags: MessageFlags2.Ephemeral
+            });
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+        return;
+      }
+      try {
+        await i.deferUpdate();
+      } catch (err) {
+        this.emit("error", err);
+        return;
+      }
+      if (this.locked) return;
+      this.locked = true;
+      try {
+        if (i.user.id !== (this.isPlayer1Turn ? this.player : this.opponent).id) return;
+        const column = Number(i.customId.split("-").at(-1));
+        const block = { x: -1, y: -1 };
+        for (let y = 6 - 1; y >= 0; y--) {
+          const number = this.gameboard[column + y * 7];
+          if (number === 0) {
+            this.gameboard[column + y * 7] = this.getPlayerNumber();
+            block.x = column;
+            block.y = y;
+            break;
+          }
+        }
+        if (this.isWinAt(block.x, block.y)) return collector.stop("$win");
+        if (this.isBoardFull()) return collector.stop("$tie");
+        this.isPlayer1Turn = !this.isPlayer1Turn;
+        const embed = await this.buildEmbed(this.options.embed, {
+          description: this.getBoardContent(),
+          fields: [
+            {
+              name: this.options.statusText,
+              value: this.options.turnMessage(this.getPlayerTurnData(), this)
+            }
+          ]
+        });
+        try {
+          await i.editReply({ embeds: [embed], components: this.getComponents() });
+        } catch (err) {
+          this.emit("error", err);
+        }
+      } finally {
+        this.locked = false;
+      }
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "$win" || reason === "$tie") {
+        return await this.gameOver(message, reason === "$win" ? "win" : "tie");
+      }
+      if (reason === "idle") {
+        return await this.gameOver(message, "timeout");
+      }
+    });
+  }
+  async gameOver(message, outcome) {
+    const winner = this.isPlayer1Turn ? this.player : this.opponent;
+    const winnerEmoji = this.isPlayer1Turn ? this.options.emojis.player1 : this.options.emojis.player2;
+    const result = this.result({
+      opponent: this.opponent,
+      outcome,
+      winner: outcome === "win" ? winner : null,
+      winnerEmoji: outcome === "win" ? winnerEmoji : null
+    });
+    this.emit("gameOver", result);
+    let getMessage;
+    switch (outcome) {
+      case "win": {
+        getMessage = this.options.winMessage;
+        break;
+      }
+      case "tie": {
+        getMessage = this.options.tieMessage;
+        break;
+      }
+      case "timeout": {
+        getMessage = this.options.timeoutMessage;
+        break;
+      }
+    }
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      description: this.getBoardContent(),
+      fields: [
+        {
+          name: this.options.statusText,
+          value: getMessage(result, this)
+        }
+      ]
+    });
+    try {
+      await this.editContextOrMessage(message, {
+        embeds: [embed],
+        components: this.getComponents(true)
+      });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  getPlayerTurnData() {
+    return this.isPlayer1Turn ? { player: this.player, emoji: this.options.emojis.player1 } : { player: this.opponent, emoji: this.options.emojis.player2 };
+  }
+  getBoardContent() {
+    let board = "";
+    for (let y = 0; y < 6; y++) {
+      for (let x = 0; x < 7; x++) {
+        board += this.getEmoji(this.gameboard[y * 7 + x]);
+      }
+      board += "\n";
+    }
+    board += "1\uFE0F\u20E32\uFE0F\u20E33\uFE0F\u20E34\uFE0F\u20E35\uFE0F\u20E36\uFE0F\u20E37\uFE0F\u20E3";
+    return board;
+  }
+  /**
+   * Get the current player number (`1` or `2`).
+   */
+  getPlayerNumber() {
+    return this.isPlayer1Turn ? 1 : 2;
+  }
+  isBoardFull() {
+    for (let y = 0; y < 6; y++) {
+      for (let x = 0; x < 7; x++) {
+        if (this.gameboard[y * 7 + x] === 0) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get the emoji of a number of the game board (`0`, `1` or `2`).
+   */
+  getEmoji(number) {
+    if (number === 1) return this.options.emojis.player1;
+    if (number === 2) return this.options.emojis.player2;
+    return this.options.emojis.board;
+  }
+  isWinAt(x, y) {
+    const number = this.getPlayerNumber();
+    for (let i = Math.max(0, x - 3); i <= x; i++) {
+      const adj = i + y * 7;
+      if (i + 3 < 7) {
+        if (this.gameboard[adj] === number && this.gameboard[adj + 1] === number && this.gameboard[adj + 2] === number && this.gameboard[adj + 3] === number)
+          return true;
+      }
+    }
+    for (let i = Math.max(0, y - 3); i <= y; i++) {
+      const adj = x + i * 7;
+      if (i + 3 < 6) {
+        if (this.gameboard[adj] === number && this.gameboard[adj + 7] === number && this.gameboard[adj + 2 * 7] === number && this.gameboard[adj + 3 * 7] === number)
+          return true;
+      }
+    }
+    for (let i = -3; i <= 0; i++) {
+      const block = { x: x + i, y: y + i };
+      const adj = block.x + block.y * 7;
+      if (block.x + 3 < 7 && block.y + 3 < 6) {
+        if (this.gameboard[adj] === number && this.gameboard[adj + 7 + 1] === number && this.gameboard[adj + 2 * 7 + 2] === number && this.gameboard[adj + 3 * 7 + 3] === number)
+          return true;
+      }
+    }
+    for (let i = -3; i <= 0; i++) {
+      const block = { x: x + i, y: y - i };
+      const adj = block.x + block.y * 7;
+      if (block.x + 3 < 7 && block.y - 3 >= 0 && block.x >= 0) {
+        if (this.gameboard[adj] === number && this.gameboard[adj - 7 + 1] === number && this.gameboard[adj - 2 * 7 + 2] === number && this.gameboard[adj - 3 * 7 + 3] === number)
+          return true;
+      }
+    }
+    return false;
+  }
+  isColumnFilled(x) {
+    return this.gameboard[x] !== 0;
+  }
+  getComponents(disabled = false) {
+    const row1 = new ActionRowBuilder3().setComponents(
+      ["1\uFE0F\u20E3", "2\uFE0F\u20E3", "3\uFE0F\u20E3", "4\uFE0F\u20E3"].map(
+        (e, i) => new ButtonBuilder3().setStyle(this.options.buttonStyle).setEmoji(e).setCustomId(`$gamecord-connect4-${i}`).setDisabled(disabled || this.isColumnFilled(i))
+      )
+    );
+    const row2 = new ActionRowBuilder3().setComponents(
+      ["5\uFE0F\u20E3", "6\uFE0F\u20E3", "7\uFE0F\u20E3"].map(
+        (e, i) => new ButtonBuilder3().setStyle(this.options.buttonStyle).setEmoji(e).setCustomId(`$gamecord-connect4-${i + 4}`).setDisabled(disabled || this.isColumnFilled(i + 4))
+      )
+    );
+    return [row1, row2];
+  }
+};
+
+// src/games/FastType.ts
+import z5 from "zod/v4";
+var defaultOptions4 = {
+  embed: {
+    title: "Fast Type",
+    color: colors.blurple,
+    description: `You have 30 seconds to type the sentence below.`
+  },
+  winMessage: /* @__PURE__ */ __name((res) => `You won! You finished the type race in ${res.secondsTaken} seconds with word per minute of ${res.wpm}.`, "winMessage"),
+  loseMessage: /* @__PURE__ */ __name(() => "You lost! You didn't type the correct sentence in time.", "loseMessage"),
+  sentence: "Some really cool sentence to fast type.",
+  timeout: 3e4
+};
+var fastTypeOptions = z5.object({
+  embed: embedBuilder().optional().default(() => defaultOptions4.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions4.winMessage),
+  loseMessage: resultMessage().optional().default(() => defaultOptions4.loseMessage),
+  sentence: z5.string().optional().default(defaultOptions4.sentence),
+  timeout: z5.number().int().optional().default(defaultOptions4.timeout)
+});
+var FastType = class extends Game {
+  static {
+    __name(this, "FastType");
+  }
+  options;
+  timeTaken = 0;
+  wpm = 0;
+  constructor(context, options) {
+    super(context);
+    this.options = fastTypeOptions.parse(options || {});
+  }
+  async start() {
+    const embed = typeof this.options.embed === "function" ? await this.options.embed(this) : {
+      author: {
+        name: this.player.displayName,
+        icon_url: this.player.displayAvatarURL()
+      },
+      fields: [
+        {
+          name: "Sentence",
+          value: this.options.sentence.split(" ").map((e) => "`" + e.split("").join(" ") + "`").join(" ")
+        }
+      ],
+      ...this.options.embed
+    };
+    const message = await this.sendMessage({ embeds: [embed] });
+    if (!message.channel.isSendable()) return;
+    const startTime = Date.now();
+    const collector = message.channel.createMessageCollector({
+      time: this.options.timeout,
+      filter: /* @__PURE__ */ __name((m) => m.author.id === this.player.id, "filter")
+    });
+    collector.on("collect", async (msg) => {
+      this.timeTaken = Math.floor(Date.now() - startTime);
+      this.wpm = Math.floor(msg.content.trim().length / (this.timeTaken / 6e4 % 60) / 5);
+      const hasWon = msg.content?.toLowerCase().trim() === this.options.sentence.toLowerCase();
+      collector.stop(hasWon ? "$win" : "$lose");
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (!this.timeTaken) {
+        this.timeTaken = Math.floor(Date.now() - startTime);
+      }
+      if (reason === "$win" || reason === "$lose" || reason === "time") {
+        await this.gameOver(message, reason === "$win" ? "win" : reason === "$lose" ? "lose" : "timeout");
+      }
+    });
+  }
+  async gameOver(message, outcome) {
+    const result = this.result({
+      outcome,
+      timeTaken: this.timeTaken,
+      secondsTaken: Math.floor(this.timeTaken / 1e3),
+      wpm: this.wpm
+    });
+    this.emit("gameOver", result);
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      description: result.outcome === "win" ? this.options.winMessage(result, this) : this.options.loseMessage(result, this)
+    });
+    try {
+      await this.editContextOrMessage(message, { embeds: [embed] });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+};
+
+// src/games/Flood.ts
+import z6 from "zod/v4";
+import { ActionRowBuilder as ActionRowBuilder4, ButtonBuilder as ButtonBuilder4, ButtonStyle as ButtonStyle4, MessageFlags as MessageFlags3 } from "discord.js";
+var defaultOptions5 = {
+  embed: {
+    title: "Flood",
+    color: colors.blurple
+  },
+  winMessage: /* @__PURE__ */ __name((res) => `You won! You took **${res.turns}** turns.`, "winMessage"),
+  loseMessage: /* @__PURE__ */ __name((res) => `You lost! You took **${res.turns}** turns.`, "loseMessage"),
+  notPlayerMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} can use these buttons.`, "notPlayerMessage"),
+  size: 13,
+  maxTurns: 25,
+  timeout: 12e4,
+  buttonStyle: ButtonStyle4.Primary,
+  emojis: ["\u{1F7E5}", "\u{1F7E6}", "\u{1F7E7}", "\u{1F7EA}", "\u{1F7E9}"]
+};
+var floodOptions = z6.object({
+  embed: embedBuilder().optional().default(defaultOptions5.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions5.winMessage),
+  loseMessage: resultMessage().optional().default(() => defaultOptions5.loseMessage),
+  notPlayerMessage: gameMessage().optional().default(() => defaultOptions5.notPlayerMessage),
+  size: z6.number().int().optional().default(defaultOptions5.size),
+  maxTurns: z6.number().int().optional().default(defaultOptions5.maxTurns),
+  timeout: z6.number().int().optional().default(defaultOptions5.timeout),
+  buttonStyle: z6.number().int().optional().default(defaultOptions5.buttonStyle),
+  emojis: z6.array(z6.string()).length(5).optional().default(defaultOptions5.emojis)
+});
+var Flood = class extends Game {
+  static {
+    __name(this, "Flood");
+  }
+  options;
+  board = [];
+  turns = 0;
+  message = null;
+  constructor(context, options) {
+    super(context);
+    this.options = floodOptions.parse(options || {});
+    for (let y = 0; y < this.options.size; y++) {
+      for (let x = 0; x < this.options.size; x++) {
+        this.board[y * this.options.size + x] = getRandomInt(this.options.emojis.length - 1);
+      }
+    }
+  }
+  async start() {
+    this.message = await this.sendMessage({ embeds: [await this.getEmbed()], components: [this.getActionRow()] });
+    this.handleButtons(this.message);
+  }
+  handleButtons(message) {
+    const collector = message.createMessageComponentCollector({ idle: this.options.timeout });
+    collector.on("collect", async (i) => {
+      if (!i.customId.startsWith("$gamecord")) return;
+      if (i.user.id !== this.player.id) {
+        if (this.options.notPlayerMessage) {
+          try {
+            await i.reply({
+              content: this.options.notPlayerMessage(this),
+              flags: MessageFlags3.Ephemeral
+            });
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+        return;
+      }
+      try {
+        await i.deferUpdate();
+      } catch (err) {
+        this.emit("error", err);
+        return;
+      }
+      const index = Number(i.customId.split("-").at(-1));
+      const updateResult = this.updateGame(index);
+      if (updateResult === "win") return collector.stop("$win");
+      if (updateResult === "lose") return collector.stop("$lose");
+      try {
+        await i.editReply({ embeds: [await this.getEmbed()], components: [this.getActionRow()] });
+      } catch (err) {
+        this.emit("error", err);
+      }
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "$win" || reason == "$lose" || reason === "idle") {
+        await this.gameOver(message, reason === "$win" ? "win" : reason === "$lose" ? "lose" : "timeout");
+      }
+    });
+  }
+  getBoardContent() {
+    let board = "";
+    for (let y = 0; y < this.options.size; y++) {
+      for (let x = 0; x < this.options.size; x++) {
+        const index = this.board[y * this.options.size + x];
+        board += this.options.emojis[index];
+      }
+      board += "\n";
+    }
+    return board;
+  }
+  getActionRow(disabled = false) {
+    const row = new ActionRowBuilder4();
+    for (let i = 0; i < 5; i++) {
+      row.addComponents(
+        new ButtonBuilder4().setStyle(this.options.buttonStyle).setEmoji(this.options.emojis[i]).setCustomId(`$gamecord-flood-${i}`).setDisabled(disabled)
+      );
+    }
+    return row;
+  }
+  async getEmbed() {
+    return typeof this.options.embed === "function" ? await this.options.embed(this) : {
+      author: {
+        name: this.player.displayName,
+        icon_url: this.player.displayAvatarURL()
+      },
+      fields: [{ name: "Turns", value: `${this.turns}/${this.options.maxTurns}` }],
+      ...this.options.embed,
+      description: this.getBoardContent()
+    };
+  }
+  async gameOver(message, outcome) {
+    const result = this.result({
+      outcome,
+      turns: this.turns,
+      maxTurns: this.options.maxTurns,
+      boardEmojiIndex: this.board[0]
+    });
+    this.emit("gameOver", result);
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      description: this.getBoardContent(),
+      fields: [
+        {
+          name: "Game Over",
+          value: result.outcome === "win" ? this.options.winMessage(result, this) : this.options.loseMessage(result, this)
+        }
+      ]
+    });
+    try {
+      await this.editContextOrMessage(message, { embeds: [embed], components: [this.getActionRow(true)] });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  updateGame(selected) {
+    if (selected === this.board[0]) return "none";
+    const firstBlock = this.board[0];
+    const queue = [{ x: 0, y: 0 }];
+    const visited = [];
+    this.turns += 1;
+    while (queue.length > 0) {
+      const block = queue.shift();
+      if (!block || visited.some((v) => v.x === block.x && v.y === block.y)) continue;
+      const index = block.y * this.options.size + block.x;
+      visited.push(block);
+      if (this.board[index] === firstBlock) {
+        this.board[index] = selected;
+        const up = { x: block.x, y: block.y - 1 };
+        if (!visited.some((v) => v.x === up.x && v.y === up.y) && up.y >= 0) queue.push(up);
+        const down = { x: block.x, y: block.y + 1 };
+        if (!visited.some((v) => v.x === down.x && v.y === down.y) && down.y < this.options.size)
+          queue.push(down);
+        const left = { x: block.x - 1, y: block.y };
+        if (!visited.some((v) => v.x === left.x && v.y === left.y) && left.x >= 0) queue.push(left);
+        const right = { x: block.x + 1, y: block.y };
+        if (!visited.some((v) => v.x === right.x && v.y === right.y) && right.x < this.options.size)
+          queue.push(right);
+      }
+    }
+    let gameOver = true;
+    for (let y = 0; y < this.options.size; y++) {
+      for (let x = 0; x < this.options.size; x++) {
+        if (this.board[y * this.options.size + x] !== selected) gameOver = false;
+      }
+    }
+    if (this.turns >= this.options.maxTurns && !gameOver) return "lose";
+    if (gameOver) return "win";
+    return "none";
+  }
+};
+
+// src/games/Memory.ts
+import z7 from "zod/v4";
+import { ActionRowBuilder as ActionRowBuilder5, ButtonBuilder as ButtonBuilder5, ButtonStyle as ButtonStyle5, MessageFlags as MessageFlags4 } from "discord.js";
+var jokerEmoji = "\u{1F0CF}";
+var defaultOptions6 = {
+  embed: {
+    title: "Memory",
+    color: colors.blurple,
+    description: "**Click on the buttons to match emojis with their pairs.**"
+  },
+  winMessage: /* @__PURE__ */ __name((res) => `**You won the Game! You turned a total of \`${res.tilesTurned}\` tiles.**`, "winMessage"),
+  loseMessage: /* @__PURE__ */ __name((res) => `**You lost the Game! You turned a total of \`${res.tilesTurned}\` tiles.**`, "loseMessage"),
+  notPlayerMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} can use this menu.`, "notPlayerMessage"),
+  timeout: 12e4,
+  emojis: [
+    "\u{1F349}",
+    "\u{1F347}",
+    "\u{1F34A}",
+    "\u{1F34B}",
+    "\u{1F96D}",
+    "\u{1F34E}",
+    "\u{1F34F}",
+    "\u{1F95D}",
+    "\u{1F965}",
+    "\u{1F353}",
+    "\u{1F352}",
+    "\u{1FAD0}",
+    "\u{1F34D}",
+    "\u{1F345}",
+    "\u{1F350}",
+    "\u{1F954}",
+    "\u{1F33D}",
+    "\u{1F955}",
+    "\u{1F96C}",
+    "\u{1F966}"
+  ]
+};
+var memoryOptions = z7.object({
+  embed: embedBuilder().optional().default(defaultOptions6.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions6.winMessage),
+  loseMessage: resultMessage().optional().default(() => defaultOptions6.loseMessage),
+  notPlayerMessage: gameMessage().optional().default(() => defaultOptions6.notPlayerMessage),
+  timeout: z7.number().int().optional().default(defaultOptions6.timeout),
+  emojis: z7.array(z7.string()).length(20).optional().default(defaultOptions6.emojis)
+});
+var Memory = class extends Game {
+  static {
+    __name(this, "Memory");
+  }
+  options;
+  emojis;
+  components = [];
+  selected = null;
+  remainingPairs = 12;
+  tilesTurned = 0;
+  size = 5;
+  message = null;
+  constructor(context, options) {
+    super(context);
+    this.options = memoryOptions.parse(options || {});
+    this.emojis = [...this.options.emojis];
+    this.emojis = shuffleArray(this.emojis).slice(0, 12);
+    this.emojis.push(...this.emojis, jokerEmoji);
+    this.emojis = shuffleArray(this.emojis);
+  }
+  async start() {
+    this.components = this.getComponents();
+    const embed = await this.buildEmbed(this.options.embed);
+    this.message = await this.sendMessage({ embeds: [embed], components: this.components });
+    this.handleButtons(this.message);
+  }
+  /**
+   * Get the positions of this emoji.
+   */
+  getPairEmojiPositions(emoji) {
+    const emojis = [];
+    for (let y = 0; y < this.size; y++) {
+      for (let x = 0; x < this.size; x++) {
+        const index = y * this.size + x;
+        if (this.emojis[index] === emoji) emojis.push({ x, y, index });
+      }
+    }
+    return emojis;
+  }
+  getComponents() {
+    const components = [];
+    for (let y = 0; y < this.size; y++) {
+      const row = new ActionRowBuilder5();
+      for (let x = 0; x < this.size; x++) {
+        row.addComponents(
+          new ButtonBuilder5().setStyle(ButtonStyle5.Secondary).setLabel("\u200B").setCustomId(`$gamecord-memory-${x}-${y}`)
+        );
+      }
+      components.push(row);
+    }
+    return components;
+  }
+  async gameOver(message, hasTimedOut) {
+    const result = this.result({
+      outcome: hasTimedOut ? "timeout" : "win",
+      tilesTurned: this.tilesTurned,
+      remainingPairs: this.remainingPairs
+    });
+    this.emit("gameOver", result);
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      description: result.outcome === "win" ? this.options.winMessage(result, this) : this.options.loseMessage(result, this)
+    });
+    try {
+      for (const btn of this.components[0].components) {
+        btn.setDisabled(true);
+      }
+      await this.editContextOrMessage(message, {
+        embeds: [embed],
+        components: this.components
+      });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  async handleButtons(message) {
+    const collector = message.createMessageComponentCollector({ idle: this.options.timeout });
+    collector.on("collect", async (i) => {
+      if (!i.customId.startsWith("$gamecord")) return;
+      if (i.user.id !== this.player.id) {
+        if (this.options.notPlayerMessage) {
+          try {
+            await i.reply({
+              content: this.options.notPlayerMessage(this),
+              flags: MessageFlags4.Ephemeral
+            });
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+        return;
+      }
+      const x = Number(i.customId.split("-").at(-2));
+      const y = Number(i.customId.split("-").at(-1));
+      const index = y * this.size + x;
+      try {
+        await i.deferUpdate();
+      } catch (err) {
+        this.emit("error", err);
+        return;
+      }
+      const emoji = this.emojis[index];
+      const emojiBtn = this.components[y].components[x];
+      this.tilesTurned += 1;
+      if (!this.selected) {
+        this.selected = { x, y, index };
+        emojiBtn.setEmoji(emoji).setStyle(ButtonStyle5.Primary);
+      } else if (this.selected.index === index) {
+        this.selected = null;
+        removeEmoji(emojiBtn).setStyle(ButtonStyle5.Secondary);
+      } else {
+        const selectedEmoji = this.emojis[this.selected.index];
+        const selectedBtn = this.components[this.selected.y].components[this.selected.x];
+        const matched = emoji === selectedEmoji || selectedEmoji === jokerEmoji || emoji === jokerEmoji;
+        if (selectedEmoji === jokerEmoji || emoji === jokerEmoji) {
+          const joker = emoji === jokerEmoji ? this.selected : { x, y, index };
+          const pair = this.getPairEmojiPositions(this.emojis[joker.index]).filter(
+            (b) => b.index !== joker.index
+          )[0];
+          const pairBtn = this.components[pair.y].components[pair.x];
+          pairBtn.setEmoji(this.emojis[pair.index]).setStyle(ButtonStyle5.Success).setDisabled(true);
+        }
+        emojiBtn.setEmoji(emoji).setStyle(matched ? ButtonStyle5.Success : ButtonStyle5.Danger).setDisabled(matched);
+        selectedBtn.setEmoji(selectedEmoji).setStyle(matched ? ButtonStyle5.Success : ButtonStyle5.Danger).setDisabled(matched);
+        if (!matched) {
+          try {
+            await i.editReply({ components: this.components });
+          } catch (err) {
+            this.emit("error", err);
+          }
+          removeEmoji(emojiBtn).setStyle(ButtonStyle5.Secondary);
+          removeEmoji(selectedBtn).setStyle(ButtonStyle5.Secondary);
+          this.selected = null;
+          return;
+        }
+        this.remainingPairs -= 1;
+        this.selected = null;
+      }
+      if (this.remainingPairs === 0) return collector.stop("$win");
+      try {
+        await i.editReply({ components: this.components });
+      } catch (err) {
+        this.emit("error", err);
+      }
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "$win" || reason === "idle") {
+        await this.gameOver(message, reason === "idle");
+      }
+    });
+  }
+};
+
+// src/games/Minesweeper.ts
+import z8 from "zod/v4";
+import { ActionRowBuilder as ActionRowBuilder6, ButtonBuilder as ButtonBuilder6, ButtonStyle as ButtonStyle6, MessageFlags as MessageFlags5 } from "discord.js";
+var defaultOptions7 = {
+  embed: {
+    title: "Minesweeper",
+    color: colors.blurple,
+    description: "Click on the buttons to reveal the blocks except mines."
+  },
+  timeout: 12e4,
+  winMessage: /* @__PURE__ */ __name(() => "You won the Game! You successfully avoided all the mines.", "winMessage"),
+  loseMessage: /* @__PURE__ */ __name(() => "You lost the Game! Beaware of the mines next time.", "loseMessage"),
+  notPlayerMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} can use this menu.`, "notPlayerMessage"),
+  mines: 5,
+  emojis: {
+    flag: "\u{1F6A9}",
+    mine: "\u{1F4A3}"
+  }
+};
+var minesweeperOptions = z8.object({
+  embed: embedBuilder().optional().default(defaultOptions7.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions7.winMessage),
+  loseMessage: resultMessage().optional().default(() => defaultOptions7.loseMessage),
+  notPlayerMessage: gameMessage().optional().default(() => defaultOptions7.notPlayerMessage),
+  timeout: z8.number().int().optional().default(defaultOptions7.timeout),
+  mines: z8.number().int().min(1).max(24).optional().default(defaultOptions7.mines),
+  emojis: z8.object({
+    flag: z8.string().optional().default(defaultOptions7.emojis.flag),
+    mine: z8.string().optional().default(defaultOptions7.emojis.mine)
+  }).optional().default(defaultOptions7.emojis)
+});
+var Minesweeper = class extends Game {
+  static {
+    __name(this, "Minesweeper");
+  }
+  options;
+  /**
+   * The board of the game.
+   *
+   * - `true` : empty
+   * - `false` : mine
+   * - `number` : empty, with `n` mines around it
+   */
+  board = [];
+  /**
+   * The width/height of the board
+   */
+  size = 5;
+  message = null;
+  constructor(context, options) {
+    super(context);
+    this.options = minesweeperOptions.parse(options || {});
+    for (let y = 0; y < this.size; y++) {
+      for (let x = 0; x < this.size; x++) {
+        this.board[y * this.size + x] = false;
+      }
+    }
+  }
+  async start() {
+    this.plantMines();
+    this.showFirstBlock();
+    const embed = await this.buildEmbed(this.options.embed);
+    this.message = await this.sendMessage({ embeds: [embed], components: this.getComponents() });
+    this.handleButtons(this.message);
+  }
+  handleButtons(message) {
+    const collector = message.createMessageComponentCollector({ idle: this.options.timeout });
+    collector.on("collect", async (i) => {
+      if (!i.customId.startsWith("$gamecord")) return;
+      if (i.user.id !== this.player.id) {
+        if (this.options.notPlayerMessage) {
+          try {
+            await i.reply({
+              content: this.options.notPlayerMessage(this),
+              flags: MessageFlags5.Ephemeral
+            });
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+        return;
+      }
+      const x = Number(i.customId.split("-").at(-2));
+      const y = Number(i.customId.split("-").at(-1));
+      const index = y * this.size + x;
+      try {
+        await i.deferUpdate();
+      } catch (err) {
+        this.emit("error", err);
+        return;
+      }
+      if (this.board[index] === true) return collector.stop("$end");
+      const mines = this.getMinesAround(x, y);
+      this.board[index] = mines;
+      if (this.hasFoundAllMines()) return collector.stop("$end");
+      try {
+        await i.editReply({ components: this.getComponents() });
+      } catch (err) {
+        this.emit("error", err);
+      }
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "$end" || reason === "idle") {
+        await this.gameOver(message, reason === "idle");
+      }
+    });
+  }
+  async gameOver(message, hasTimedOut) {
+    const result = this.result({
+      outcome: hasTimedOut ? "timeout" : this.hasFoundAllMines() ? "win" : "lose",
+      tilesTurned: this.board.filter(Number.isInteger).length
+    });
+    this.emit("gameOver", result);
+    for (let y = 0; y < this.size; y++) {
+      for (let x = 0; x < this.size; x++) {
+        const index = y * this.size + x;
+        if (this.board[index] !== true) this.board[index] = this.getMinesAround(x, y);
+      }
+    }
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      description: result.outcome === "win" ? this.options.winMessage(result, this) : this.options.loseMessage(result, this)
+    });
+    try {
+      await this.editContextOrMessage(message, {
+        embeds: [embed],
+        components: this.getComponents(true, result.outcome === "win", true)
+      });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  plantMines() {
+    for (let i = 0; i <= this.options.mines; i++) {
+      const x = Math.floor(Math.random() * 5);
+      const y = Math.floor(Math.random() * 5);
+      const index = y * this.size + x;
+      if (this.board[index] !== true) {
+        this.board[index] = true;
+      } else {
+        i -= 1;
+      }
+    }
+  }
+  getMinesAround(x, y) {
+    let minesAround = 0;
+    for (let row = -1; row < 2; row++) {
+      for (let col = -1; col < 2; col++) {
+        const block = { x: x + col, y: y + row };
+        if (block.x < 0 || block.x >= 5 || block.y < 0 || block.y >= 5) continue;
+        if (row === 0 && col === 0) continue;
+        if (this.board[block.y * this.size + block.x] === true) minesAround += 1;
+      }
+    }
+    return minesAround;
+  }
+  showFirstBlock() {
+    const emptyBlocks = [];
+    for (let y = 0; y < this.size; y++) {
+      for (let x = 0; x < this.size; x++) {
+        if (this.board[y * this.size + x] === true) emptyBlocks.push({ x, y });
+      }
+    }
+    const safeBlocks = emptyBlocks.filter((b) => !this.getMinesAround(b.x, b.y));
+    const blocks = safeBlocks.length ? safeBlocks : emptyBlocks;
+    const rBlock = blocks[Math.floor(Math.random() * blocks.length)];
+    this.board[rBlock.y * this.size + rBlock.x] = this.getMinesAround(rBlock.x, rBlock.y);
+  }
+  hasFoundAllMines() {
+    let found = true;
+    for (let y = 0; y < this.size; y++) {
+      for (let x = 0; x < this.size; x++) {
+        if (this.board[y * this.size + x] === false) found = false;
+      }
+    }
+    return found;
+  }
+  /**
+   * Build the minesweeper grid using buttons.
+   */
+  getComponents(showMines = false, found = false, disabled = false) {
+    const components = [];
+    for (let y = 0; y < this.size; y++) {
+      const row = new ActionRowBuilder6();
+      for (let x = 0; x < this.size; x++) {
+        const block = this.board[y * this.size + x];
+        const numberEmoji = typeof block === "number" && block > 0 ? getNumberEmoji(block) : null;
+        const displayMine = block === true && showMines;
+        const btn = new ButtonBuilder6().setStyle(
+          displayMine ? found ? ButtonStyle6.Success : ButtonStyle6.Danger : typeof block === "number" ? ButtonStyle6.Secondary : ButtonStyle6.Primary
+        ).setCustomId(`$gamecord-minesweeper-${x}-${y}`).setDisabled(disabled);
+        if (displayMine || numberEmoji)
+          btn.setEmoji(
+            displayMine ? found ? this.options.emojis.flag : this.options.emojis.mine : numberEmoji
+          );
+        else {
+          btn.setLabel("\u200B");
+        }
+        row.addComponents(btn);
+      }
+      components.push(row);
+    }
+    return components;
+  }
+};
+
+// src/games/RockPaperScissors.ts
+import z9 from "zod/v4";
+import { ActionRowBuilder as ActionRowBuilder7, ButtonBuilder as ButtonBuilder7, ButtonStyle as ButtonStyle7, MessageFlags as MessageFlags6 } from "discord.js";
+var defaultOptions8 = {
+  embed: {
+    title: "Rock Paper Scissors",
+    color: colors.blurple,
+    description: "Press a button below to make a choice."
+  },
+  winMessage: /* @__PURE__ */ __name((res) => `**${res.winner}** won the Game! Congratulations!`, "winMessage"),
+  tieMessage: /* @__PURE__ */ __name(() => "The Game tied! No one won the Game!", "tieMessage"),
+  timeoutMessage: /* @__PURE__ */ __name(() => "The Game went unfinished! No one won the Game!", "timeoutMessage"),
+  choiceMessage: /* @__PURE__ */ __name((emoji) => `You choose ${emoji}.`, "choiceMessage"),
+  notPlayerMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} and ${game.opponent} can use this menu.`, "notPlayerMessage"),
+  buttons: {
+    rock: "Rock",
+    paper: "Paper",
+    scissors: "Scissors"
+  },
+  emojis: {
+    rock: "\u{1F311}",
+    paper: "\u{1F4F0}",
+    scissors: "\u2702\uFE0F"
+  },
+  timeout: 6e4
+};
+var rockPaperScissorsOptions = z9.object({
+  versus: versusOptions("Rock Paper Scissors"),
+  embed: embedBuilder().optional().default(defaultOptions8.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions8.winMessage),
+  tieMessage: resultMessage().optional().default(() => defaultOptions8.tieMessage),
+  timeoutMessage: resultMessage().optional().default(() => defaultOptions8.timeoutMessage),
+  choiceMessage: var2Message().optional().default(() => defaultOptions8.choiceMessage),
+  notPlayerMessage: gameMessage().optional().default(() => defaultOptions8.notPlayerMessage),
+  buttonStyle: z9.number().int().optional().default(ButtonStyle7.Primary),
+  buttons: z9.object({
+    rock: z9.string().optional().default(defaultOptions8.buttons.rock),
+    paper: z9.string().optional().default(defaultOptions8.buttons.paper),
+    scissors: z9.string().optional().default(defaultOptions8.buttons.scissors)
+  }).optional().default(defaultOptions8.buttons),
+  emojis: z9.object({
+    rock: z9.string().optional().default(defaultOptions8.emojis.rock),
+    paper: z9.string().optional().default(defaultOptions8.emojis.paper),
+    scissors: z9.string().optional().default(defaultOptions8.emojis.scissors)
+  }).optional().default(defaultOptions8.emojis),
+  timeout: z9.number().int().optional().default(defaultOptions8.timeout)
+});
+var RockPaperScissors = class extends VersusGame {
+  static {
+    __name(this, "RockPaperScissors");
+  }
+  options;
+  playerChoice = null;
+  opponentChoice = null;
+  message = null;
+  constructor(context, options) {
+    const parsed = rockPaperScissorsOptions.parse(options || {});
+    super(context, parsed.versus);
+    this.options = parsed;
+  }
+  async start() {
+    this.message = await this.requestVersus();
+    if (this.message) this.runGame(this.message);
+  }
+  async runGame(message) {
+    try {
+      const embed = await this.buildEmbed(this.options.embed);
+      await this.editContextOrMessage(message, {
+        content: null,
+        embeds: [embed],
+        components: [this.getActionRow()]
+      });
+    } catch (err) {
+      this.emit("fatalError", err);
+      this.emit("end");
+      return;
+    }
+    this.handleButtons(message);
+  }
+  handleButtons(message) {
+    const collector = message.createMessageComponentCollector({ idle: this.options.timeout });
+    const emojis = this.options.emojis;
+    const choices = { r: emojis.rock, p: emojis.paper, s: emojis.scissors };
+    collector.on("collect", async (i) => {
+      if (!i.customId.startsWith("$gamecord")) return;
+      if (i.user.id !== this.player.id && i.user.id !== this.opponent.id) {
+        if (this.options.notPlayerMessage) {
+          try {
+            await i.reply({
+              content: this.options.notPlayerMessage(this),
+              flags: MessageFlags6.Ephemeral
+            });
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+        return;
+      }
+      const choice = choices[i.customId.split("-").at(-1)];
+      let replyChoice = false;
+      if (i.user.id === this.player.id && !this.playerChoice) {
+        this.playerChoice = choice;
+        replyChoice = true;
+      } else if (i.user.id === this.opponent.id && !this.opponentChoice) {
+        this.opponentChoice = choice;
+        replyChoice = true;
+      }
+      if (replyChoice) {
+        try {
+          await i.reply({
+            content: this.options.choiceMessage(choice, this),
+            flags: MessageFlags6.Ephemeral
+          });
+        } catch (err) {
+          this.emit("error", err);
+        }
+      }
+      if (!i.replied) {
+        try {
+          await i.deferUpdate();
+        } catch (err) {
+          this.emit("error", err);
+          return;
+        }
+      }
+      if (this.playerChoice && this.opponentChoice) return collector.stop("$end");
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "idle" || reason === "$end") {
+        await this.gameOver(message);
+      }
+    });
+  }
+  getResult() {
+    if (!this.playerChoice && !this.opponentChoice) return "timeout";
+    else if (this.playerChoice === this.opponentChoice) return "tie";
+    else return "win";
+  }
+  hasPlayer1Won() {
+    const { rock: r, paper: p, scissors: s } = this.options.emojis;
+    return this.playerChoice === s && this.opponentChoice === p || this.playerChoice === r && this.opponentChoice === s || this.playerChoice === p && this.opponentChoice === r;
+  }
+  getActionRow(disabled = false) {
+    return new ActionRowBuilder7().setComponents(
+      new ButtonBuilder7().setStyle(this.options.buttonStyle).setEmoji(this.options.emojis.rock).setCustomId("$gamecord-rps-r").setLabel(this.options.buttons.rock).setDisabled(disabled),
+      new ButtonBuilder7().setStyle(this.options.buttonStyle).setEmoji(this.options.emojis.paper).setCustomId("$gamecord-rps-p").setLabel(this.options.buttons.paper).setDisabled(disabled),
+      new ButtonBuilder7().setStyle(this.options.buttonStyle).setEmoji(this.options.emojis.scissors).setCustomId("$gamecord-rps-s").setLabel(this.options.buttons.scissors).setDisabled(disabled)
+    );
+  }
+  async gameOver(message) {
+    const outcome = this.getResult();
+    const result = this.result({
+      opponent: this.opponent,
+      outcome,
+      winner: outcome === "win" ? this.hasPlayer1Won() ? this.player : this.opponent : null,
+      playerChoice: this.playerChoice,
+      opponentChoice: this.opponentChoice
+    });
+    this.emit("gameOver", result);
+    let getMessage;
+    switch (outcome) {
+      case "win": {
+        getMessage = this.options.winMessage;
+        break;
+      }
+      case "tie": {
+        getMessage = this.options.tieMessage;
+        break;
+      }
+      case "timeout": {
+        getMessage = this.options.timeoutMessage;
+        break;
+      }
+    }
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      description: getMessage(result, this),
+      fields: [
+        {
+          name: this.player.displayName,
+          value: this.playerChoice ?? "\u2754",
+          inline: true
+        },
+        {
+          name: "VS",
+          value: "\u26A1",
+          inline: true
+        },
+        {
+          name: this.opponent.displayName,
+          value: this.opponentChoice ?? "\u2754",
+          inline: true
+        }
+      ]
+    });
+    try {
+      await this.editContextOrMessage(message, {
+        embeds: [embed],
+        components: [this.getActionRow(true)]
+      });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+};
+
+// src/games/TicTacToe.ts
+import z10 from "zod/v4";
+import { ActionRowBuilder as ActionRowBuilder8, ButtonBuilder as ButtonBuilder8, ButtonStyle as ButtonStyle8, MessageFlags as MessageFlags7 } from "discord.js";
+var defaultOptions9 = {
+  embed: {
+    title: "Tic Tac Toe",
+    color: colors.blurple
+  },
+  winMessage: /* @__PURE__ */ __name((res) => `${res.winnerEmoji} | **${res.winner}** won the TicTacToe Game.`, "winMessage"),
+  tieMessage: /* @__PURE__ */ __name(() => "The Game tied! No one won the Game!", "tieMessage"),
+  timeoutMessage: /* @__PURE__ */ __name(() => "The Game went unfinished! No one won the Game!", "timeoutMessage"),
+  turnMessage: /* @__PURE__ */ __name((turn) => `${turn.emoji} | It's player **${turn.player.displayName}**'s turn.`, "turnMessage"),
+  notPlayerMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} and ${game.opponent} can use this menu.`, "notPlayerMessage"),
+  emojis: {
+    xButton: "\u274C",
+    oButton: "\u{1F535}"
+  },
+  styles: {
+    xButton: ButtonStyle8.Secondary,
+    oButton: ButtonStyle8.Secondary
+  },
+  timeout: 6e4
+};
+var ticTacToeOptions = z10.object({
+  versus: versusOptions("Tic Tac Toe"),
+  embed: embedBuilder().optional().default(defaultOptions9.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions9.winMessage),
+  tieMessage: resultMessage().optional().default(() => defaultOptions9.tieMessage),
+  timeoutMessage: resultMessage().optional().default(() => defaultOptions9.timeoutMessage),
+  turnMessage: var2Message().optional().default(() => defaultOptions9.turnMessage),
+  notPlayerMessage: gameMessage().optional().default(() => defaultOptions9.notPlayerMessage),
+  emojis: z10.object({
+    xButton: z10.string().optional().default(defaultOptions9.emojis.xButton),
+    oButton: z10.string().optional().default(defaultOptions9.emojis.oButton)
+  }).optional().default(defaultOptions9.emojis),
+  styles: z10.object({
+    xButton: z10.number().int().optional().default(defaultOptions9.styles.xButton),
+    oButton: z10.number().int().optional().default(defaultOptions9.styles.oButton)
+  }).optional().default(defaultOptions9.styles),
+  timeout: z10.number().int().optional().default(defaultOptions9.timeout)
+});
+var TicTacToe = class extends VersusGame {
+  static {
+    __name(this, "TicTacToe");
+  }
+  options;
+  /**
+   * A 9-elements array.
+   *
+   * - `0` : empty
+   * - `1` : X (player 1)
+   * - `2` : O (player 2)
+   */
+  gameboard = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+  isPlayer1Turn = true;
+  message = null;
+  locked = false;
+  constructor(context, options) {
+    const parsed = ticTacToeOptions.parse(options || {});
+    super(context, parsed.versus);
+    this.options = parsed;
+  }
+  async start() {
+    this.message = await this.requestVersus();
+    if (this.message) this.runGame(this.message);
+  }
+  async runGame(message) {
+    try {
+      const embed = await this.buildEmbed(this.options.embed, {
+        description: this.options.turnMessage(this.getPlayerTurnData(), this)
+      });
+      await this.editContextOrMessage(message, {
+        content: null,
+        embeds: [embed],
+        components: this.getComponents()
+      });
+    } catch (err) {
+      this.emit("fatalError", err);
+      this.emit("end");
+      return;
+    }
+    this.handleButtons(message);
+  }
+  handleButtons(message) {
+    const collector = message.createMessageComponentCollector({ idle: this.options.timeout });
+    collector.on("collect", async (i) => {
+      if (!i.customId.startsWith("$gamecord")) return;
+      if (i.user.id !== this.player.id && i.user.id !== this.opponent.id) {
+        if (this.options.notPlayerMessage) {
+          try {
+            await i.reply({
+              content: this.options.notPlayerMessage(this),
+              flags: MessageFlags7.Ephemeral
+            });
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+        return;
+      }
+      try {
+        await i.deferUpdate();
+      } catch (err) {
+        this.emit("error", err);
+        return;
+      }
+      if (this.locked) return;
+      this.locked = true;
+      try {
+        if (i.user.id !== (this.isPlayer1Turn ? this.player : this.opponent).id) return;
+        const index = Number(i.customId.split("-").at(-1));
+        if (this.gameboard[index] !== 0) return;
+        this.gameboard[index] = this.isPlayer1Turn ? 1 : 2;
+        if (this.hasWonGame(1) || this.hasWonGame(2)) return collector.stop("$win");
+        if (!this.gameboard.includes(0)) return collector.stop("$tie");
+        this.isPlayer1Turn = !this.isPlayer1Turn;
+        const embed = await this.buildEmbed(this.options.embed, {
+          description: this.options.turnMessage(this.getPlayerTurnData(), this)
+        });
+        try {
+          await i.editReply({ embeds: [embed], components: this.getComponents() });
+        } catch (err) {
+          this.emit("error", err);
+        }
+      } finally {
+        this.locked = false;
+      }
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "$win" || reason === "$tie") {
+        return await this.gameOver(message, reason === "$win" ? "win" : "tie");
+      }
+      if (reason === "idle") {
+        return await this.gameOver(message, "timeout");
+      }
+    });
+  }
+  async gameOver(message, outcome) {
+    const winner = this.hasWonGame(1) ? this.player : this.opponent;
+    const winnerEmoji = this.hasWonGame(1) ? this.options.emojis.xButton : this.options.emojis.oButton;
+    const result = this.result({
+      opponent: this.opponent,
+      outcome,
+      winner: outcome === "win" ? winner : null,
+      winnerEmoji: outcome === "win" ? winnerEmoji : null
+    });
+    this.emit("gameOver", result);
+    let getMessage;
+    switch (outcome) {
+      case "win": {
+        getMessage = this.options.winMessage;
+        break;
+      }
+      case "tie": {
+        getMessage = this.options.tieMessage;
+        break;
+      }
+      case "timeout": {
+        getMessage = this.options.timeoutMessage;
+        break;
+      }
+    }
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      description: getMessage(result, this)
+    });
+    try {
+      await this.editContextOrMessage(message, {
+        embeds: [embed],
+        components: this.getComponents(true)
+      });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  hasWonGame(player) {
+    if (this.gameboard[0] === this.gameboard[4] && this.gameboard[0] === this.gameboard[8] && this.gameboard[0] === player) {
+      return true;
+    } else if (this.gameboard[6] === this.gameboard[4] && this.gameboard[6] === this.gameboard[2] && this.gameboard[6] === player) {
+      return true;
+    }
+    for (let i = 0; i < 3; ++i) {
+      if (this.gameboard[i * 3] === this.gameboard[i * 3 + 1] && this.gameboard[i * 3] === this.gameboard[i * 3 + 2] && this.gameboard[i * 3] === player) {
+        return true;
+      }
+      if (this.gameboard[i] === this.gameboard[i + 3] && this.gameboard[i] === this.gameboard[i + 6] && this.gameboard[i] === player) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getPlayerTurnData() {
+    return this.isPlayer1Turn ? { player: this.player, emoji: this.options.emojis.xButton } : { player: this.opponent, emoji: this.options.emojis.oButton };
+  }
+  getButtonData(player) {
+    if (player === 1) return { emoji: this.options.emojis.xButton, style: this.options.styles.xButton };
+    else if (player === 2) return { emoji: this.options.emojis.oButton, style: this.options.styles.oButton };
+    else return { emoji: null, style: ButtonStyle8.Secondary };
+  }
+  getComponents(disabled = false) {
+    const components = [];
+    for (let x = 0; x < 3; x++) {
+      const row = new ActionRowBuilder8();
+      for (let y = 0; y < 3; y++) {
+        const index = y * 3 + x;
+        const data = this.getButtonData(this.gameboard[index]);
+        const btn = new ButtonBuilder8().setStyle(data.style).setCustomId(`$gamecord-tictactoe-${index}`);
+        if (data.emoji) {
+          btn.setEmoji(data.emoji);
+        } else {
+          btn.setLabel("\u200B");
+        }
+        if (this.gameboard[y * 3 + x] !== 0) btn.setDisabled(true);
+        if (disabled) btn.setDisabled(true);
+        row.addComponents(btn);
+      }
+      components.push(row);
+    }
+    return components;
+  }
+};
+
+// src/games/Trivia.ts
+import z11 from "zod/v4";
+import { ActionRowBuilder as ActionRowBuilder9, ButtonBuilder as ButtonBuilder9, ButtonStyle as ButtonStyle9, MessageFlags as MessageFlags8 } from "discord.js";
+var triviaAPISchema = z11.object({
+  results: z11.array(
+    z11.object({
+      difficulty: z11.string(),
+      category: z11.string(),
+      question: z11.string(),
+      correct_answer: z11.string(),
+      incorrect_answers: z11.array(z11.string())
+    })
+  )
+});
+var difficulties = ["easy", "medium", "hard"];
+var defaultOptions10 = {
+  embed: {
+    title: "Trivia",
+    color: colors.blurple,
+    fields: [
+      {
+        name: "\u200B",
+        value: "You have 60 seconds to guess the answer."
+      }
+    ]
+  },
+  winMessage: /* @__PURE__ */ __name((res) => `You won! The correct answer was ${res.trivia.answer}.`, "winMessage"),
+  loseMessage: /* @__PURE__ */ __name((res) => `You lost! The correct answer was ${res.trivia.answer}.`, "loseMessage"),
+  errorMessage: /* @__PURE__ */ __name(() => "Unable to fetch question data! Please try again.", "errorMessage"),
+  notPlayerMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} can use this menu.`, "notPlayerMessage"),
+  mode: "multiple",
+  timeout: 6e4,
+  trueText: "True",
+  falseText: "False"
+};
+var triviaOptions = z11.object({
+  embed: embedBuilder().optional().default(defaultOptions10.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions10.winMessage),
+  loseMessage: resultMessage().optional().default(() => defaultOptions10.loseMessage),
+  errorMessage: gameMessage().optional().default(() => defaultOptions10.errorMessage),
+  notPlayerMessage: gameMessage().optional().default(() => defaultOptions10.notPlayerMessage),
+  mode: z11.enum(["multiple", "single"]).optional().default(defaultOptions10.mode),
+  difficulty: z11.enum(difficulties).optional(),
+  trivia: z11.custom().optional(),
+  timeout: z11.number().int().optional().default(defaultOptions10.timeout),
+  trueText: z11.string().optional().default(defaultOptions10.trueText),
+  falseText: z11.string().optional().default(defaultOptions10.falseText)
+});
+var Trivia = class extends Game {
+  static {
+    __name(this, "Trivia");
+  }
+  options;
+  difficulty;
+  selected = null;
+  trivia = null;
+  message = null;
+  constructor(context, options) {
+    super(context);
+    this.options = triviaOptions.parse(options || {});
+    this.difficulty = this.options.difficulty || getRandomElement(difficulties);
+  }
+  async start() {
+    this.trivia = await this.getTriviaQuestion();
+    if (!this.trivia) {
+      try {
+        await this.sendMessage({
+          content: this.options.errorMessage(this)
+        });
+      } catch (err) {
+        this.emit("error", err);
+      }
+      return;
+    }
+    const embed = await this.buildEmbed(this.options.embed, {
+      description: `**${this.trivia.question}**
+
+**Difficulty:** ${this.trivia.difficulty}
+**Category:** ${this.trivia.category}`
+    });
+    this.message = await this.sendMessage({ embeds: [embed], components: this.getComponents() });
+    this.handleButtons(this.message);
+  }
+  handleButtons(message) {
+    const trivia = this.trivia;
+    const collector = message.createMessageComponentCollector({ idle: this.options.timeout });
+    collector.on("collect", async (i) => {
+      if (!i.customId.startsWith("$gamecord")) return;
+      if (i.user.id !== this.player.id) {
+        if (this.options.notPlayerMessage) {
+          try {
+            await i.reply({
+              content: this.options.notPlayerMessage(this),
+              flags: MessageFlags8.Ephemeral
+            });
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+        return;
+      }
+      collector.stop();
+      this.selected = Number(i.customId.split("-").at(-1));
+      try {
+        await i.deferUpdate();
+      } catch (err) {
+        this.emit("error", err);
+      }
+      await this.gameOver(message, trivia.options[this.selected] === trivia.answer);
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "idle") {
+        await this.gameOver(message, false, true);
+      }
+    });
+  }
+  async gameOver(message, hasWon, hasTimedOut = false) {
+    const trivia = this.trivia;
+    const result = this.result({
+      outcome: hasTimedOut ? "timeout" : hasWon ? "win" : "lose",
+      trivia,
+      selected: this.selected
+    });
+    this.emit("gameOver", result);
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      description: `**${trivia.question}**
+
+**Difficulty:** ${trivia.difficulty}
+**Category:** ${trivia.category}`,
+      fields: [
+        {
+          name: "Game Over",
+          value: result.outcome === "win" ? this.options.winMessage(result, this) : this.options.loseMessage(result, this)
+        }
+      ]
+    });
+    try {
+      await this.editContextOrMessage(message, {
+        embeds: [embed],
+        components: this.getComponents(true)
+      });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Build the selection buttons.
+   */
+  getComponents(ended = false) {
+    const trivia = this.trivia;
+    const row = new ActionRowBuilder9();
+    if (ended && this.selected === null) {
+      this.selected = trivia.options.indexOf(trivia.answer);
+    }
+    if (this.options.mode === "multiple") {
+      for (let i = 0; i < 4; i++) {
+        row.addComponents(
+          new ButtonBuilder9().setStyle(ButtonStyle9.Secondary).setCustomId(`$gamecord-trivia-${i}`).setLabel(trivia.options[i]).setDisabled(ended)
+        );
+      }
+      if (this.selected !== null) {
+        if (trivia.answer !== trivia.options[this.selected]) {
+          row.components[this.selected].setStyle(ButtonStyle9.Danger);
+        } else {
+          row.components[this.selected].setStyle(ButtonStyle9.Success);
+        }
+      }
+    } else {
+      row.setComponents(
+        new ButtonBuilder9().setStyle(
+          this.selected === 0 ? trivia.answer === "True" ? ButtonStyle9.Success : ButtonStyle9.Danger : ButtonStyle9.Secondary
+        ).setCustomId("$gamecord-trivia-0").setLabel(this.options.trueText).setDisabled(ended),
+        new ButtonBuilder9().setStyle(
+          this.selected === 1 ? trivia.answer === "False" ? ButtonStyle9.Success : ButtonStyle9.Danger : ButtonStyle9.Secondary
+        ).setCustomId("$gamecord-trivia-1").setLabel(this.options.falseText).setDisabled(ended)
+      );
+    }
+    return [row];
+  }
+  async getTriviaQuestion() {
+    if (this.options.trivia) {
+      return await this.options.trivia(this);
+    }
+    const mode = this.options.mode.replace("single", "boolean");
+    let data;
+    try {
+      const res = await fetch(
+        `https://opentdb.com/api.php?amount=1&type=${mode}&difficulty=${this.difficulty}&encode=url3986`
+      );
+      const json = await res.json();
+      if (json.response_code === 5) {
+        throw new Error("Ratelimited by opentdb");
+      }
+      data = triviaAPISchema.parse(json);
+      data = data.results[0];
+    } catch (err) {
+      this.emit("error", err);
+      return null;
+    }
+    if (!data) {
+      return null;
+    }
+    const trivia = {
+      question: decodeURIComponent(data.question),
+      difficulty: decodeURIComponent(data.difficulty),
+      category: decodeURIComponent(data.category),
+      answer: decodeURIComponent(data.correct_answer),
+      options: []
+    };
+    if (mode === "multiple") {
+      data.incorrect_answers.push(data.correct_answer);
+      trivia.options = shuffleArray(data.incorrect_answers).map((a) => decodeURIComponent(a));
+    } else {
+      trivia.options = ["True", "False"];
+    }
+    return trivia;
+  }
+};
+
+// src/games/Wordle.ts
+import z12 from "zod/v4";
+import { createCanvas as createCanvas2 } from "@napi-rs/canvas";
+import { AttachmentBuilder as AttachmentBuilder2 } from "discord.js";
+
+// src/data/wordle.json
+var wordle_default = [
+  "APPLE",
+  "BEACH",
+  "CHAIR",
+  "DREAM",
+  "EAGLE",
+  "FIGHT",
+  "GRADE",
+  "HEART",
+  "IDEAS",
+  "JELLY",
+  "KNIFE",
+  "LIGHT",
+  "MOUSE",
+  "NOVEL",
+  "OCEAN",
+  "PLANT",
+  "QUICK",
+  "READY",
+  "SHEEP",
+  "TIGER",
+  "UNION",
+  "VALUE",
+  "WHALE",
+  "YOUNG",
+  "ZEBRA",
+  "ABOVE",
+  "BLANK",
+  "CRISP",
+  "DIRTY",
+  "ERROR",
+  "FLUID",
+  "GIANT",
+  "HAPPY",
+  "INDEX",
+  "JOKER",
+  "KNEEL",
+  "LEMON",
+  "MAGIC",
+  "NIGHT",
+  "ORDER",
+  "POWER",
+  "RIVER",
+  "SCOPE",
+  "SNAKE",
+  "TABLE",
+  "ULTRA",
+  "VOICE",
+  "WATCH",
+  "YIELD",
+  "ZONAL"
+];
+
+// src/games/Wordle.ts
+var defaultOptions11 = {
+  embed: {
+    title: "Wordle",
+    color: colors.blurple
+  },
+  winMessage: /* @__PURE__ */ __name((res) => `You won! The word was **${res.word}**.`, "winMessage"),
+  loseMessage: /* @__PURE__ */ __name((res) => `You lost! The word was **${res.word}**.`, "loseMessage"),
+  notOwnedMessage: /* @__PURE__ */ __name((game) => `Only ${game.player} can use this menu.`, "notOwnedMessage"),
+  timeout: 12e4
+};
+var wordleOptions = z12.object({
+  embed: embedBuilder().optional().default(defaultOptions11.embed),
+  endEmbed: embedBuilder().optional(),
+  winMessage: resultMessage().optional().default(() => defaultOptions11.winMessage),
+  loseMessage: resultMessage().optional().default(() => defaultOptions11.loseMessage),
+  timeout: z12.number().int().optional().default(defaultOptions11.timeout),
+  word: z12.string().length(5).optional()
+});
+var Wordle = class extends Game {
+  static {
+    __name(this, "Wordle");
+  }
+  options;
+  /**
+   * The word to guess, in lowercase. Either the one specified or a random one.
+   */
+  word;
+  guesses = [];
+  message = null;
+  collector = null;
+  constructor(context, options) {
+    super(context);
+    this.options = wordleOptions.parse(options || {});
+    this.word = (this.options.word || getRandomElement(wordle_default)).toLowerCase();
+  }
+  async start() {
+    const embed = await this.buildEmbed(this.options.embed, {
+      image: { url: "attachment://board.png" }
+    });
+    this.message = await this.sendMessage({ embeds: [embed], files: [await this.getBoardAttachment()] });
+    const message = this.message;
+    if (!message.channel.isSendable()) return;
+    const collector = message.channel.createMessageCollector({
+      idle: this.options.timeout,
+      filter: /* @__PURE__ */ __name((msg) => msg.author.id === this.player.id && msg.content.length === 5, "filter")
+    });
+    this.collector = collector;
+    collector.on("collect", async (msg) => {
+      const guess = msg.content.toLowerCase();
+      if (msg.deletable) {
+        try {
+          await msg.delete();
+        } catch (err) {
+          this.emit("error", err);
+        }
+      }
+      this.guesses.push(guess);
+      if (this.word === guess || this.guesses.length > 5) return collector.stop("$end");
+      try {
+        await this.editContextOrMessage(message, { embeds: [embed], files: [await this.getBoardAttachment()] });
+      } catch (err) {
+        this.emit("error", err);
+      }
+    });
+    collector.on("end", async (_, reason) => {
+      this.emit("end");
+      if (reason === "$end" || reason === "idle") {
+        await this.gameOver(message, reason === "idle");
+      }
+    });
+  }
+  async gameOver(message, isTimeout) {
+    const result = this.result({
+      outcome: isTimeout ? "timeout" : this.guesses.includes(this.word) ? "win" : "lose",
+      word: this.word,
+      guesses: this.guesses
+    });
+    this.emit("gameOver", result);
+    const embed = await this.buildEndEmbed(this.options.embed, this.options.endEmbed, result, {
+      image: {
+        url: "attachment://board.png"
+      },
+      fields: [
+        {
+          name: "Game Over",
+          value: result.outcome === "win" ? this.options.winMessage(result, this) : this.options.loseMessage(result, this)
+        }
+      ]
+    });
+    try {
+      await this.editContextOrMessage(message, {
+        embeds: [embed],
+        files: [await this.getBoardAttachment()]
+      });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  async getBoardAttachment() {
+    return new AttachmentBuilder2(await this.getBoardImage(), { name: "board.png" });
+  }
+  async getBoardImage() {
+    const rows = 6;
+    const cols = 5;
+    const tile = 88;
+    const gap = 12;
+    const padding = 20;
+    const width = padding * 2 + cols * tile + (cols - 1) * gap;
+    const height = padding * 2 + rows * tile + (rows - 1) * gap;
+    const canvas = createCanvas2(width, height);
+    const ctx = canvas.getContext("2d");
+    const PALETTE = {
+      green: "#6aaa64",
+      yellow: "#c9b458",
+      gray: "#3a3a3c",
+      empty: "#121213",
+      border: "#3a3a3c",
+      bg: "#121213",
+      textLight: "#ffffff"
+    };
+    ctx.fillStyle = PALETTE.bg;
+    ctx.fillRect(0, 0, width, height);
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.font = `700 ${Math.floor(tile * 0.54)}px sans-serif`;
+    function scoreGuess(guess, answer) {
+      const res = Array(cols).fill(PALETTE.gray);
+      const a = answer.split("");
+      const g = guess.split("");
+      const counts = {};
+      for (let i = 0; i < a.length; i++) counts[a[i]] = (counts[a[i]] || 0) + 1;
+      for (let i = 0; i < cols; i++) {
+        if (g[i] === a[i]) {
+          res[i] = PALETTE.green;
+          counts[g[i]] = Math.max(0, counts[g[i]] - 1);
+        }
+      }
+      for (let i = 0; i < cols; i++) {
+        if (res[i] === PALETTE.green) continue;
+        const ch = g[i];
+        if (counts[ch] && counts[ch] > 0) {
+          res[i] = PALETTE.yellow;
+          counts[ch]--;
+        } else {
+          res[i] = PALETTE.gray;
+        }
+      }
+      return res;
+    }
+    __name(scoreGuess, "scoreGuess");
+    for (let r = 0; r < rows; r++) {
+      const guess = this.guesses[r];
+      const colors2 = guess ? scoreGuess(guess.toLowerCase(), this.word.toLowerCase()) : Array(cols).fill(PALETTE.empty);
+      for (let c = 0; c < cols; c++) {
+        const x = padding + c * (tile + gap);
+        const y = padding + r * (tile + gap);
+        ctx.fillStyle = colors2[c] === PALETTE.empty ? PALETTE.empty : colors2[c];
+        const radius = 8;
+        ctx.beginPath();
+        ctx.moveTo(x + radius, y);
+        ctx.lineTo(x + tile - radius, y);
+        ctx.quadraticCurveTo(x + tile, y, x + tile, y + radius);
+        ctx.lineTo(x + tile, y + tile - radius);
+        ctx.quadraticCurveTo(x + tile, y + tile, x + tile - radius, y + tile);
+        ctx.lineTo(x + radius, y + tile);
+        ctx.quadraticCurveTo(x, y + tile, x, y + tile - radius);
+        ctx.lineTo(x, y + radius);
+        ctx.quadraticCurveTo(x, y, x + radius, y);
+        ctx.closePath();
+        ctx.fill();
+        ctx.lineWidth = 4;
+        ctx.strokeStyle = colors2[c] === PALETTE.empty ? PALETTE.border : colors2[c];
+        ctx.stroke();
+        const ch = guess ? (guess[c] || "").toUpperCase() : "";
+        if (ch) {
+          ctx.fillStyle = PALETTE.textLight;
+          ctx.fillText(ch, x + tile / 2, y + tile / 2 + 2);
+        }
+      }
+    }
+    return canvas.toBuffer("image/png");
+  }
+};
+export {
+  Connect4,
+  FastType,
+  Flood,
+  Game2048,
+  Memory,
+  Minesweeper,
+  RockPaperScissors,
+  TicTacToe,
+  Trivia,
+  Wordle,
+  connect4Options,
+  fastTypeOptions,
+  floodOptions,
+  game2048Options,
+  jokerEmoji,
+  memoryOptions,
+  minesweeperOptions,
+  rockPaperScissorsOptions,
+  ticTacToeOptions,
+  triviaOptions,
+  wordleOptions
+};
+//# sourceMappingURL=index.mjs.map