"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var jeopardy_exports = {};
__export(jeopardy_exports, {
  Jeopardy: () => Jeopardy,
  commands: () => commands,
  roomSettings: () => roomSettings
});
module.exports = __toCommonJS(jeopardy_exports);
var import_lib = require("../../lib");
const BACKGROUND_COLOR = "#0000FF";
const HEIGHT = 40;
const MAX_CATEGORY_COUNT = 5;
const MAX_QUESTION_COUNT = 5;
const BUZZ_COOLDOWN = 500;
class Jeopardy extends Rooms.RoomGame {
  constructor(room, user, categoryCount, questionCount, playerCap) {
    super(room);
    this.gameNumber = room.nextGameNumber();
    this.host = user;
    this.allowRenames = true;
    this.state = "signups";
    this.gameid = "jeopardy";
    this.title = "Jeopardy";
    this.categories = [];
    this.question = /* @__PURE__ */ Object.create(null);
    this.questions = [];
    this.finalQuestion = /* @__PURE__ */ Object.create(null);
    this.started = false;
    this.categoryCount = categoryCount;
    this.questionCount = questionCount;
    this.round = 1;
    this.points = /* @__PURE__ */ new Map();
    this.playerCap = playerCap;
    this.canBuzz = false;
    this.numUpdates = 0;
    this.finalCategory = "";
    this.answeringTime = 10;
    this.finalAnsweringTime = 30;
    this.timeout = null;
    this.roundStarted = false;
    this.curPlayer = new JeopardyGamePlayer(user, this);
    this.prevPlayer = new JeopardyGamePlayer(user, this);
    this.order = [];
    this.finals = false;
    this.setupGrid();
  }
  destroy() {
    if (this.timeout)
      clearTimeout(this.timeout);
    super.destroy();
  }
  makePlayer(user) {
    return new JeopardyGamePlayer(user, this);
  }
  setupGrid() {
    this.categories = [];
    for (let j = 0; j < this.categoryCount; j++) {
      this.categories.push("");
    }
    this.questions = [];
    for (let i = 0; i < this.questionCount; i++) {
      this.questions.push([]);
      for (let j = 0; j < this.categoryCount; j++) {
        this.questions[i].push({ question: "", answer: "", points: 200 * this.round * (i + 1), answered: false, dd: false });
      }
    }
    this.finalQuestion = /* @__PURE__ */ Object.create(null);
    this.roundStarted = false;
    this.question = /* @__PURE__ */ Object.create(null);
    if (this.round === 1) {
      this.display();
    } else {
      this.update();
    }
  }
  start() {
    if (this.roundStarted)
      throw new Chat.ErrorMessage("The game has already been started.");
    if (this.playerCount < 2)
      throw new Chat.ErrorMessage("The game needs at least two players to start.");
    const noquestions = [];
    for (let i = 0; i < this.categoryCount; i++) {
      for (let j = 0; j < this.questionCount; j++) {
        if (!this.questions[j][i].question) {
          noquestions.push(`(${i + 1}, ${j + 1})`);
        }
      }
    }
    let badstr = noquestions.join(", ");
    if (!this.finalQuestion.question && this.round === 2) {
      badstr += `${badstr ? ", " : ""} final`;
    }
    if (badstr) {
      throw new Chat.ErrorMessage(`The following questions still need questions and answers: ${badstr}.`);
    }
    this.roundStarted = true;
    if (this.round === 1) {
      for (const userID in this.playerTable) {
        const player = this.playerTable[userID];
        this.points.set(player, 0);
      }
    }
    this.state = "selecting";
    let lowest = [];
    let minpoints;
    for (const userID in this.playerTable) {
      const points = this.playerTable[userID].points;
      if (!minpoints) {
        lowest.push(userID);
        minpoints = points;
      } else if (points < minpoints) {
        lowest = [userID];
        minpoints = points;
      } else if (points === minpoints) {
        lowest.push(userID);
      }
    }
    this.curPlayer = this.playerTable[lowest[Math.floor(lowest.length * Math.random())]];
    this.prevPlayer = this.curPlayer;
    this.update();
    this.nextPlayer();
  }
  nextPlayer() {
    this.room.addRaw(`${this.curPlayer.name}, you're up!`);
  }
  getGrid() {
    let buffer = `<div class="infobox"><html><body><table align="center" border="2" style="table-layout: fixed; width: 100%"><tr>`;
    for (let i = 0; i < this.categoryCount; i++) {
      buffer += `<td style="word-wrap: break-word" bgcolor="${BACKGROUND_COLOR}"; height="${HEIGHT}px"; width="30px" align="center"><font color="white">${import_lib.Utils.escapeHTML(this.categories[i])}</font></td>`;
    }
    buffer += `</tr>`;
    for (let i = 0; i < this.questionCount; i++) {
      buffer += `<tr>`;
      for (let j = 0; j < this.categoryCount; j++) {
        buffer += `<td bgcolor="${BACKGROUND_COLOR}"; height="${HEIGHT}px"; align="center"><font color="black" size="6">${this.questions[i][j].answered ? "" : this.questions[i][j].points}</font></td>`;
      }
      buffer += `</tr>`;
    }
    buffer += `</table><br />`;
    for (const userID in this.playerTable) {
      const player = this.playerTable[userID];
      const bold = this.curPlayer?.name === player.name;
      buffer += `${bold ? "<b>" : ""}<font size=2>${import_lib.Utils.escapeHTML(player.name)} (${player.points || 0})${bold ? "</b>" : ""}<br />`;
    }
    buffer += `</body></html></div>`;
    return buffer;
  }
  display() {
    this.room.add(`|uhtml|jeopardy${this.gameNumber}-${this.numUpdates}|${this.getGrid()}`);
  }
  update(dontMove = false) {
    if (dontMove) {
      this.room.add(`|uhtmlchange|jeopardy${this.gameNumber}-${this.numUpdates}|${this.getGrid()}`);
    } else {
      this.room.add(`|uhtmlchange|jeopardy${this.gameNumber}-${this.numUpdates}|`);
      this.numUpdates++;
      this.room.add(`|uhtml|jeopardy${this.gameNumber}-${this.numUpdates}|${this.getGrid()}`);
    }
  }
  dailyDouble() {
    if (this.timeout)
      clearTimeout(this.timeout);
    this.state = "answering";
    if (!this.curPlayer.wager)
      this.curPlayer.wager = 0;
    this.askQuestion();
  }
  select(target) {
    if (this.state !== "selecting")
      throw new Chat.ErrorMessage("The game of Jeopardy is not in the selection phase.");
    const params = target.split(",");
    if (params.length < 2)
      throw new Chat.ErrorMessage("You must specify a row and a column number.");
    const categoryNumber = parseInt(params[0]);
    if (!categoryNumber || categoryNumber < 1 || categoryNumber > this.categoryCount) {
      throw new Chat.ErrorMessage(`The category must be a number between 1 and ${this.categoryCount}.`);
    }
    const questionNumber = parseInt(params[1]);
    if (!questionNumber || questionNumber < 1 || questionNumber > this.questionCount) {
      throw new Chat.ErrorMessage(`The question must be a number between 1 and ${this.questionCount}.`);
    }
    const question = this.questions[questionNumber - 1][categoryNumber - 1];
    if (question.answered)
      throw new Chat.ErrorMessage("That question has already been answered.");
    this.question = question;
    if (question.dd) {
      this.room.add(`That was a daily double! ${this.curPlayer.name}, how much would you like to wager?`);
      this.clearWagers();
      this.state = "wagering";
      this.timeout = setTimeout(() => this.dailyDouble(), 30 * 1e3);
    } else {
      this.state = "buzzing";
      this.askQuestion();
    }
  }
  clearWagers() {
    for (const userID in this.playerTable) {
      this.playerTable[userID].wager = 0;
    }
  }
  clearBuzzes() {
    for (const userID in this.playerTable) {
      this.playerTable[userID].buzzed = false;
    }
  }
  askQuestion() {
    if (!this.question.dd) {
      this.curPlayer = null;
    }
    this.clearBuzzes();
    this.room.addRaw(import_lib.Utils.html`<div class="broadcast-blue">Your question is: ${this.question.question}</div>`);
    if (!this.finals) {
      this.canBuzz = false;
      this.update(true);
      this.timeout = setTimeout(() => this.allowBuzzes(), this.question.question.length / 15 * 1e3);
    }
  }
  allowBuzzes() {
    this.canBuzz = true;
    this.room.add(`You may now buzz in for the Jeopardy game!`);
    this.update(true);
    this.timeout = setTimeout(() => this.allowAllBuzzes(), BUZZ_COOLDOWN);
  }
  allowAllBuzzes() {
    for (const userID in this.playerTable) {
      this.playerTable[userID].buzzedEarly = false;
    }
  }
  revealAnswer() {
    this.room.addRaw(`<div class="broadcast-blue">The answer was: ${import_lib.Utils.escapeHTML(this.question.answer)}</div>`);
    this.question.answered = true;
  }
  buzz(user) {
    if (this.state !== "buzzing")
      throw new Chat.ErrorMessage("You cannot buzz in at this time.");
    const player = this.playerTable[user.id];
    if (!player)
      throw new Chat.ErrorMessage("You are not in the game of Jeopardy.");
    if (player.buzzed)
      throw new Chat.ErrorMessage("You have already buzzed in to the current question.");
    if (!this.canBuzz) {
      player.buzzedEarly = true;
      player.send("You buzzed early! You now have a delay before you will be able to buzz.");
      return;
    } else if (player.buzzedEarly) {
      throw new Chat.ErrorMessage("Your buzzing cooldown has not yet ended.");
    }
    this.curPlayer = player;
    this.curPlayer.buzzed = true;
    this.room.add(`${user.name} has buzzed in!`);
    this.state = "answering";
    this.timeout = setTimeout(() => this.check({ correct: false, isBuzzTimeout: true }), this.answeringTime * 1e3);
  }
  hasRemainingQuestion() {
    for (let i = 0; i < this.questionCount; i++) {
      for (let j = 0; j < this.categoryCount; j++) {
        if (!this.questions[i][j].answered)
          return true;
      }
    }
    return false;
  }
  startFinals() {
    this.update();
    this.room.add("Time to begin finals! The category is: " + this.finalCategory + "! Please wager your amounts now.");
    this.finals = true;
    this.state = "wagering";
    this.clearWagers();
    this.timeout = setTimeout(() => this.finalWagers(), this.finalAnsweringTime * 1e3);
  }
  wager(amount, user) {
    if (this.state !== "wagering" && (!this.finals || this.curPlayer?.id !== user.id)) {
      throw new Chat.ErrorMessage("You cannot wager at this time.");
    }
    const player = this.playerTable[user.id];
    if (!player)
      throw new Chat.ErrorMessage("You are not in the game of Jeopardy.");
    amount = toID(amount);
    const wager = amount === "all" ? player.points : parseInt(amount);
    if (!wager || isNaN(wager))
      throw new Chat.ErrorMessage("Your wager must be a number, or 'all'.");
    if (wager < 0)
      throw new Chat.ErrorMessage("You cannot wager a negative amount.");
    if (wager > player.points && (wager > this.round * 1e3 || this.finals)) {
      throw new Chat.ErrorMessage("You cannot wager more than your current number of points.");
    }
    if (player.wager)
      throw new Chat.ErrorMessage("You have already wagered.");
    player.wager = wager;
    player.send(`You have wagered ${wager} points!`);
    if (!this.finals) {
      this.dailyDouble();
    } else {
      for (const userID in this.playerTable) {
        if (!this.playerTable[userID].wager)
          return;
      }
      if (this.timeout)
        clearTimeout(this.timeout);
      this.finalWagers();
    }
  }
  finalWagers() {
    for (const userID in this.playerTable) {
      const player = this.playerTable[userID];
      if (!player.wager)
        player.wager = 0;
    }
    this.question = this.finalQuestion;
    this.state = "answering";
    this.askQuestion();
    this.timeout = setTimeout(() => this.doFinals(), this.finalAnsweringTime * 1e3);
  }
  doFinals() {
    if (!this.playerTable)
      return this.room?.add(`Could not play finals because the player table does not exist.`);
    this.order = Object.keys(this.playerTable);
    this.doFinalPlayer();
  }
  doFinalPlayer() {
    if (this.order.length === 0) {
      this.revealAnswer();
      let highest = [];
      let maxpoints;
      for (const userID in this.playerTable) {
        const player = this.playerTable[userID];
        const points = player.points;
        if (!maxpoints) {
          highest.push(player.name);
          maxpoints = points;
        } else if (points > maxpoints) {
          highest = [player.name];
          maxpoints = points;
        } else if (points === maxpoints) {
          highest.push(player.name);
        }
      }
      this.room.add(`|raw|<div class=broadcast-green>Congratulations to ${highest.map((n) => import_lib.Utils.escapeHTML(n)).join(", ")} for winning the game of Jeopardy with ${maxpoints} points!`);
      this.destroy();
      return;
    } else {
      const index = this.order.shift() || 0;
      this.curPlayer = this.playerTable[index];
      const answer = this.curPlayer.finalAnswer;
      if (answer) {
        this.room.add(`${this.curPlayer.name} has answered ${import_lib.Utils.escapeHTML(answer)}!`);
        this.state = "checking";
      } else {
        const wager = this.curPlayer.wager;
        this.room.add(`${this.curPlayer.name} did not answer the final Jeopardy and loses ${wager} points`);
        let points = this.curPlayer.points;
        points -= wager;
        this.curPlayer.points = points;
        this.timeout = setTimeout(() => this.doFinalPlayer(), 5 * 1e3);
      }
    }
  }
  answer(target, user) {
    if (this.state !== "answering")
      throw new Chat.ErrorMessage("You cannot answer the question at this time.");
    const player = this.playerTable[user.id];
    if (!player)
      throw new Chat.ErrorMessage("You are not in the game of Jeopardy.");
    if (this.finals) {
      if (player.finalAnswer)
        throw new Chat.ErrorMessage("You have already answered the Final Jeopardy");
      player.answer = import_lib.Utils.escapeHTML(target);
      player.send(`You have selected your answer as ${import_lib.Utils.escapeHTML(target)}.`);
    } else {
      if (this.timeout)
        clearTimeout(this.timeout);
      if (!this.curPlayer || this.curPlayer.id !== user.id)
        throw new Chat.ErrorMessage("It is not your turn to answer.");
      this.state = "checking";
      this.room.add(`${user.name} has answered ${import_lib.Utils.escapeHTML(target)}!`);
    }
  }
  mark(correct) {
    if (this.state !== "checking")
      throw new Chat.ErrorMessage("There is no answer to currently check.");
    this.check({ correct });
  }
  check(info) {
    if (info.correct) {
      const gainpoints = this.question.dd || this.finals ? this.curPlayer.wager : this.question.points;
      let points = this.curPlayer.points;
      points += gainpoints;
      this.curPlayer.points = points;
      this.room.add(`${this.curPlayer.name} has answered the question correctly and gained ${gainpoints} points!`);
      if (!this.finals) {
        this.revealAnswer();
      }
      if (this.finals) {
        this.doFinalPlayer();
      } else if (!this.hasRemainingQuestion()) {
        if (this.round === 1) {
          this.round++;
          this.setupGrid();
          this.state = "round2";
        } else {
          this.startFinals();
        }
      } else {
        this.prevPlayer = this.curPlayer;
        this.state = "selecting";
        this.question = /* @__PURE__ */ Object.create(null);
        this.update();
      }
    } else {
      const losspoints = this.question.dd || this.finals ? this.curPlayer.wager : this.question.points;
      const action = info.isBuzzTimeout ? "failed to answer in time" : "answered incorrectly";
      this.room.add(`${this.curPlayer.name} ${action} and loses ${losspoints} points!`);
      let points = this.curPlayer.points;
      points -= losspoints;
      this.curPlayer.points = points;
      if (this.finals) {
        this.doFinalPlayer();
      } else if (this.everyBuzzed() || this.question.dd) {
        this.nextQuestion();
      } else {
        this.state = "buzzing";
      }
    }
  }
  everyBuzzed() {
    for (const userID in this.playerTable) {
      if (!this.playerTable[userID].buzzed)
        return false;
    }
    return true;
  }
  setCategory(categoryNumber, category) {
    if (typeof categoryNumber === "string") {
      this.finalCategory = category.trim();
    } else {
      this.categories[categoryNumber] = category.trim();
      this.update();
    }
  }
  nextQuestion() {
    this.revealAnswer();
    if (!this.hasRemainingQuestion()) {
      if (this.round === 1) {
        this.round++;
        this.setupGrid();
        this.state = "round2";
      } else {
        this.startFinals();
      }
    } else {
      this.curPlayer = this.prevPlayer;
      this.state = "selecting";
      this.question = /* @__PURE__ */ Object.create(null);
      this.update();
    }
  }
  setCategories(categories) {
    if (this.state !== "signups" && this.state !== "round2")
      return false;
    for (const [i, category] of categories.entries()) {
      this.categories[i] = category;
    }
    this.update();
  }
  getQuestion(categoryNumber, questionNumber) {
    const question = this.questions[questionNumber][categoryNumber];
    if (question.question) {
      return `<strong>Question: </strong>${import_lib.Utils.escapeHTML(question.question)}<br><strong>Answer: </strong>${import_lib.Utils.escapeHTML(question.answer)}`;
    } else {
      return "That question has not yet been imported.";
    }
  }
  setDailyDouble(categoryNumber, questionNumber) {
    const question = this.questions[questionNumber][categoryNumber];
    if (question.dd)
      throw new Chat.ErrorMessage("That question is already a daily double.");
    question.dd = true;
  }
  importQuestions(questions, questionStart, categoryStart) {
    if (typeof categoryStart === "string") {
      const split = questions[0].split("|");
      if (split.length !== 2)
        throw new Chat.ErrorMessage("Final question was unable to be imported.");
      this.finalQuestion.question = split[0].trim();
      this.finalQuestion.answer = split[1].trim();
    } else {
      for (let i = categoryStart; i < this.categoryCount; i++) {
        for (let j = i === categoryStart ? questionStart : 0; j < this.questionCount; j++) {
          if (questions.length === 0) {
            return;
          }
          const split = questions[0].split("|");
          if (split.length !== 2) {
            throw new Chat.ErrorMessage(`Questions before ${questions[0]} imported successfully, but ${questions[0]} did not have a question and one answer.`);
          }
          this.questions[j][i].question = split[0].trim();
          this.questions[j][i].answer = split[1].trim();
          questions.shift();
        }
      }
      if (questions.length > 0) {
        const split = questions[0].split("|");
        if (split.length !== 2) {
          throw new Chat.ErrorMessage(`Questions before ${questions[0]} imported successfully, but ${questions[0]} did not have a question and one answer.`);
        }
        this.finalQuestion.question = split[0].trim();
        this.finalQuestion.answer = split[1].trim();
      }
    }
  }
  givePoints(user, n) {
    const id = toID(user);
    if (!(id in this.playerTable))
      throw new Chat.ErrorMessage(`'${id}' is not a player in the game of Jeopardy.`);
    this.playerTable[id].points += n;
  }
  substitute(original, substitute) {
    const originalPlayer = this.playerTable[original.id];
    if (!originalPlayer)
      throw new Chat.ErrorMessage(`${original.name} is not a player in the game of Jeopardy.`);
    delete this.playerTable[original.id];
    this.addPlayer(substitute);
    this.playerTable[substitute.id].answer = originalPlayer.answer;
    this.playerTable[substitute.id].points = originalPlayer.points;
    this.playerTable[substitute.id].wager = originalPlayer.wager;
    this.playerTable[substitute.id].buzzedEarly = originalPlayer.buzzedEarly;
    this.playerTable[substitute.id].finalAnswer = originalPlayer.finalAnswer;
    this.playerTable[substitute.id].buzzed = originalPlayer.buzzed;
    this.room.add(`${substitute.name} subbed in for ${original.name}!`);
  }
}
class JeopardyGamePlayer extends Rooms.RoomGamePlayer {
  constructor(user, game) {
    super(user, game);
    this.answer = "";
    this.points = 0;
    this.wager = 0;
    this.buzzedEarly = false;
    this.finalAnswer = "";
    this.buzzed = false;
  }
}
const commands = {
  jp: "jeopardy",
  jeopardy: {
    "": "help",
    help() {
      return this.parse("/help jeopardy");
    },
    off: "disable",
    disable(target, room, user) {
      room = this.requireRoom();
      this.checkCan("gamemanagement", null, room);
      if (room.settings.jeopardyDisabled) {
        return this.errorReply("Jeopardy is already disabled in this room.");
      }
      room.settings.jeopardyDisabled = true;
      room.saveSettings();
      return this.sendReply("Jeopardy has been disabled for this room.");
    },
    on: "enable",
    enable(target, room, user) {
      room = this.requireRoom();
      this.checkCan("gamemanagement", null, room);
      if (!room.settings.jeopardyDisabled) {
        return this.errorReply("Jeopardy is already enabled in this room.");
      }
      delete room.settings.jeopardyDisabled;
      room.saveSettings();
      return this.sendReply("Jeopardy has been enabled for this room.");
    },
    create: "new",
    new(target, room, user) {
      room = this.requireRoom();
      if (room.game) {
        return this.errorReply(`There is already a game of ${room.game.title} in progress in this room.`);
      }
      this.checkCan("minigame", null, room);
      const params = target.split(",");
      const playerCap = parseInt(params[0]);
      const categoryCount = parseInt(params[1]);
      const questionCount = parseInt(params[2]);
      if (isNaN(playerCap) || playerCap <= 1) {
        return this.errorReply(`The player cap must be a number above 1.`);
      }
      if (isNaN(categoryCount) || categoryCount <= 0) {
        return this.errorReply(`The category count must be a number above 0.`);
      }
      if (categoryCount > MAX_CATEGORY_COUNT) {
        return this.sendReply(`A match with more than ${MAX_CATEGORY_COUNT} categories cannot be created.`);
      }
      if (isNaN(questionCount) || questionCount <= 0) {
        return this.errorReply(`The question count must be a number above 0.`);
      }
      if (questionCount > MAX_QUESTION_COUNT) {
        return this.sendReply(
          `A match with more than ${MAX_QUESTION_COUNT} questions per category cannot be created.`
        );
      }
      room.game = new Jeopardy(room, user, categoryCount, questionCount, playerCap);
      this.privateModAction(`${user.name} started a new game of Jeopardy.`);
      this.modlog("JEOPARDY", null, `maximum of ${playerCap} players, ${categoryCount} categories, and ${questionCount} questions`);
    },
    categories(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const params = target.split(",");
      if (params.length !== game.categoryCount) {
        return this.errorReply(`You must set exactly ${game.categoryCount} categories.`);
      }
      const reply = game.setCategories(params);
      if (reply)
        this.errorReply(reply);
    },
    category(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const params = target.split(",");
      if (params.length !== 2)
        return this.errorReply("You must specify the category number and the category.");
      let categoryNumber;
      if (params[0] === "final") {
        categoryNumber = "final";
      } else {
        categoryNumber = parseInt(params[0]);
        if (!categoryNumber || categoryNumber < 1 || categoryNumber > game.categoryCount) {
          return this.errorReply(`The category number must be between 1 and ${game.categoryCount}.`);
        }
      }
      game.setCategory(typeof categoryNumber === "string" ? categoryNumber : categoryNumber - 1, params[1]);
    },
    select(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      game.select(target);
    },
    buzz(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      game.buzz(user);
    },
    wager(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.lastCommand !== `/jeopardy wager ${target}`) {
        user.lastCommand = `/jeopardy wager ${target}`;
        return this.sendReply(`To confirm your wager of ${target}, type '${user.lastCommand}' again.`);
      }
      game.wager(target, user);
    },
    answer(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      game.answer(target, user);
    },
    import(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (!target)
        return this.errorReply("You must specify at least one question");
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const params = target.split(",");
      let dataStart = 0;
      let catStart;
      let questionStart = 1;
      if (toID(params[0]) === "final") {
        catStart = "finals";
        params.splice(0, 1);
      } else {
        if (isNaN(import_lib.Utils.parseExactInt(params[0])) || isNaN(import_lib.Utils.parseExactInt(params[1]))) {
          return this.errorReply(`You must specify numeric values for Category Number Start and Question Number Start.`);
        }
        catStart = parseInt(params[0]);
        if (catStart) {
          if (catStart < 1 || catStart > game.categoryCount) {
            return this.errorReply(`The category must be a number between 1 and ${game.categoryCount}.`);
          }
          dataStart = 1;
          questionStart = parseInt(params[1]);
          if (questionStart) {
            if (questionStart < 1 || questionStart > game.questionCount) {
              return this.errorReply(`The question must be a number between 1 and ${game.questionCount}.`);
            }
            dataStart = 2;
          } else {
            questionStart = 1;
          }
        } else {
          catStart = 1;
          questionStart = 1;
        }
        params.splice(0, dataStart);
      }
      const numberOfQuestions = params.length;
      game.importQuestions(
        params,
        questionStart - 1,
        typeof catStart === "string" ? catStart : catStart - 1
      );
      this.sendReply(`Imported ${numberOfQuestions} questions.`);
    },
    dd: "dailydouble",
    dailydouble(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const params = target.split(",");
      if (params.length !== 2)
        return this.errorReply("You must specify the category number and question number");
      const categoryNumber = parseInt(params[0]);
      if (!categoryNumber || categoryNumber < 1 || categoryNumber > game.categoryCount) {
        return this.errorReply(`The category must be a number between 1 and ${game.categoryCount}.`);
      }
      const questionNumber = parseInt(params[0]);
      if (!questionNumber || questionNumber < 1 || questionNumber > game.questionCount) {
        return this.errorReply(`The question must be a number between 1 and ${game.questionCount}.`);
      }
      game.setDailyDouble(categoryNumber - 1, questionNumber - 1);
      this.sendReply("Daily double has been added.");
    },
    dailydoublehelp: [
      `/jeopardy dailydouble [category number], [question number] - Set a question to be a daily double.`
    ],
    view(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const params = target.split(",");
      if (params.length !== 2)
        return this.errorReply("You must specify the category number and question number");
      const categoryNumber = parseInt(params[0]);
      if (!categoryNumber || categoryNumber < 1 || categoryNumber > game.categoryCount) {
        return this.errorReply(`The category must be a number between 1 and ${game.categoryCount}.`);
      }
      const questionNumber = parseInt(params[1]);
      if (!questionNumber || questionNumber < 1 || questionNumber > game.questionCount) {
        return this.errorReply(`The question must be a number between 1 and ${game.questionCount}.`);
      }
      this.sendReplyBox(game.getQuestion(categoryNumber - 1, questionNumber - 1));
    },
    join(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (game.host.id === user.id)
        return this.errorReply("You are the host and therefore cannot join the game.");
      if (game.state !== "signups")
        return this.errorReply("This Jeopardy game is not in its signups phase.");
      if (game.addPlayer(user)) {
        game.update();
      } else {
        this.errorReply("Unable to join the game.");
      }
    },
    incorrect: "correct",
    correct(target, room, user, connection, cmd) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      game.mark(cmd === "correct");
    },
    start(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      game.start();
    },
    kick: "leave",
    leave(target, room, user, connection, cmd) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      const kicking = cmd.includes("kick");
      if (kicking && user.id !== game.host.id)
        return this.errorReply("Only the host can kick players.");
      const targetUser = kicking ? Users.get(target) : user;
      if (!targetUser)
        return this.errorReply(`User '${target}' not found.`);
      if (game.removePlayer(targetUser)) {
        game.update();
      } else {
        return this.errorReply(`Unable to remove '${targetUser.name}' from the game.`);
      }
    },
    subhost(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const targetUser = Users.get(target);
      if (!targetUser)
        return this.errorReply(`User '${target}' not found.`);
      game.host = targetUser;
      this.sendReply(`${targetUser.name} has subbed in as the host.`);
    },
    subplayer(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const split = target.split(",");
      if (split.length !== 2)
        return this.parse(`/help jeopardy`);
      const [toSubOut, toSubIn] = split.map((u) => Users.get(u));
      if (!toSubOut)
        return this.errorReply(`User '${target[0]}' not found.`);
      if (!toSubIn)
        return this.errorReply(`User '${target[1]}' not found.`);
      game.substitute(toSubOut, toSubIn);
    },
    state(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      this.sendReply(`The game is currently in the ${game.state} state.`);
    },
    end(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      this.checkCan("minigame", null, room);
      game.destroy();
      this.privateModAction(`${user.name} ended the game of Jeopardy.`);
      this.modlog("JEOPARDY END");
    },
    pass(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      game.nextQuestion();
    },
    timer(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const amount = parseInt(target);
      if (!amount || amount < 2 || amount > 120)
        return this.errorReply("The amount must be a number between 2 and 120.");
      game.answeringTime = amount;
      this.addModAction(`${user.name} has set the answering window for questions to ${amount} seconds`);
      this.modlog("JEOPARDY TIMER", null, `${amount} seconds`);
    },
    finaltimer(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const amount = parseInt(target);
      if (!amount || amount < 2 || amount > 300)
        return this.errorReply("The amount must be a number between 2 and 300.");
      game.finalAnsweringTime = amount;
      this.addModAction(`${user.name} has set the answering window for the final question to ${amount} seconds`);
      this.modlog("JEOPARDY FINALTIMER", null, `${amount} seconds`);
    },
    removepoints: "addpoints",
    addpoints(target, room, user, connection, cmd) {
      room = this.requireRoom();
      if (!target)
        return this.parse(`/help jeopardy`);
      const game = this.requireGame(Jeopardy);
      if (user.id !== game.host.id)
        return this.errorReply("This command can only be used by the host.");
      const [recipient, pointsString] = target.split(",");
      let points = parseInt(pointsString);
      if (points <= 0 || isNaN(points)) {
        return this.errorReply(`You must provide a positive number of points to add/remove.`);
      }
      if (cmd.includes("remove"))
        points *= -1;
      game.givePoints(toID(recipient), points);
    }
  },
  jeopardyhelp() {
    this.runBroadcast();
    return this.sendReply(
      `|html|<details class="readmore"><summary><code>/jp new [player cap], [number of categories], [number of questions]</code>: Host a new game of Jeopardy. Requires: % @ # &<br /><code>/jp join</code>: Join the game of Jeopardy.<br /><code>/jp leave</code>: Leave the game of Jeopardy.<br /><code>/jp buzz</code>: Buzz into the current question.<br /><code>/jp answer [answer]</code>: Attempt to answer the current question.</summary><code>/jp start</code>: Start the game of Jeopardy. Must be the host.<br /><code>/jp correct/incorrect</code>: Mark an answer as correct or incorrect. Must be the host.<br /><code>/jp categories [First Category], [Second Category], etc.</code>: Set the categories of the jeopardy game. Must be the host.<br /><code>/jp category [Category Number], [Category Name]</code>: Set a specific category of the jeopardy game. Must be the host.<br /><code>/jp select [Category Number], [Question Number]</code>: Select a question of the Jeopardy game.<br /><code>/jp end</code>: End the current game of Jeopardy. Requires: % @ # &<br /><code>/jp dailydouble [Category Number], [Question Number]</code>: Set a question to be a daily double. Must be the host.<br /><code>/jp wager [amount]</code>: Wager some money for a daily double or finals. Must be a number or 'all'<br /><code>/jp kick [User]</code>: Remove a user from the game of Jeopardy. Must be the host.<br /><code>/jp view [Category Number], [Question Number]</code>: View a specific question and answer. Must be the host.<br /><code>/jp subhost [User]</code>: Sub a new host into the game. Must be the host.<br /><code>/jp subplayer [original], [substitute]</code>: Sub a new player into the game. Must be the host.<br /><code>/jp import [Category Number Start], [Question Number Start], [Question 1 | Answer 1], [Question 2 | Answer 2], etc.</code>: Import questions into the current game of Jeopardy. Must be the host.<br /><code>/jp pass</code>: Skip the current question of Jeopardy. Must be the host.<br /><code>/jp state</code>: Check the state of the current Jeopardy game. Must be the host.<br /><code>/jp timer [seconds]</code>: Set the answering window after buzzing for questions<br /><code>/jp finaltimer [seconds]</code>: Set the answering window for answering the final question<br /><code>/jp addpoints [user], [number of points]</code>: Give a player an arbitrary number of points. Must be the host.<br /><code>/jp remove [user], [number of points]</code>: Subtract an arbitrary number of points from a player. Must be the host.</details>`
    );
  }
};
const roomSettings = (room) => ({
  label: "Jeopardy",
  permission: "editroom",
  options: [
    [`disabled`, room.settings.jeopardyDisabled || "jeopardy disable"],
    [`enabled`, !room.settings.jeopardyDisabled || "jeopardy enable"]
  ]
});
//# sourceMappingURL=jeopardy.js.map