dist/server/chat-plugins/auction.js

"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 auction_exports = {};
__export(auction_exports, {
  Auction: () => Auction,
  commands: () => commands,
  roomSettings: () => roomSettings
});
module.exports = __toCommonJS(auction_exports);
var import_lib = require("../../lib");
class Team {
  constructor(name, auction) {
    this.id = toID(name);
    this.name = name;
    this.players = [];
    this.credits = auction.startingCredits;
    this.suspended = false;
    this.auction = auction;
  }
  getManagers() {
    return [...this.auction.managers.values()].filter((m) => m.team === this).map((m) => Users.getExact(m.id)?.name || m.id);
  }
  addPlayer(player, price = 0) {
    player.team?.removePlayer(player);
    this.players.push(player);
    this.credits -= price;
    player.team = this;
    player.price = price;
  }
  removePlayer(player) {
    const pIndex = this.players.indexOf(player);
    if (pIndex === -1)
      return;
    this.players.splice(pIndex, 1);
    delete player.team;
    player.price = 0;
  }
  isSuspended() {
    return this.suspended || (this.auction.type === "snake" ? this.players.length >= this.auction.minPlayers : this.credits < this.auction.minBid || this.auction.maxPlayers && this.players.length >= this.auction.maxPlayers);
  }
  maxBid(credits = this.credits) {
    return credits + this.auction.minBid * Math.min(0, this.players.length - this.auction.minPlayers + 1);
  }
}
function parseCredits(amount) {
  let credits = Number(amount.replace(",", "."));
  if (Math.abs(credits) < 500)
    credits *= 1e3;
  if (!credits || credits % 500 !== 0) {
    throw new Chat.ErrorMessage(`The amount of credits must be a multiple of 500.`);
  }
  return credits;
}
class Auction extends Rooms.SimpleRoomGame {
  constructor(room, startingCredits = 1e5) {
    super(room);
    this.gameid = "auction";
    this.owners = /* @__PURE__ */ new Set();
    this.teams = /* @__PURE__ */ new Map();
    this.managers = /* @__PURE__ */ new Map();
    this.auctionPlayers = /* @__PURE__ */ new Map();
    this.minBid = 3e3;
    this.minPlayers = 10;
    this.maxPlayers = 0;
    this.type = "auction";
    this.lastQueue = null;
    this.queue = [];
    this.nomTimer = null;
    this.nomTimeLimit = 0;
    this.nomTimeRemaining = 0;
    this.bidTimer = null;
    this.bidTimeLimit = 10;
    this.bidTimeRemaining = 10;
    this.nominatingTeam = null;
    this.nominatedPlayer = null;
    this.highestBidder = null;
    this.highestBid = 0;
    /** Used for blind mode */
    this.bidsPlaced = /* @__PURE__ */ new Map();
    this.state = "setup";
    this.title = "Auction";
    this.startingCredits = startingCredits;
  }
  sendMessage(message) {
    this.room.add(`|c|~|${message}`).update();
  }
  sendHTMLBox(htmlContent) {
    this.room.add(`|html|<div class="infobox">${htmlContent}</div>`).update();
  }
  checkOwner(user) {
    if (!this.owners.has(user.id) && !Users.Auth.hasPermission(user, "declare", null, this.room)) {
      throw new Chat.ErrorMessage(`You must be an auction owner to use this command.`);
    }
  }
  addOwners(users) {
    for (const name of users) {
      const user = Users.getExact(name);
      if (!user)
        throw new Chat.ErrorMessage(`User "${name}" not found.`);
      if (this.owners.has(user.id))
        throw new Chat.ErrorMessage(`${user.name} is already an auction owner.`);
      this.owners.add(user.id);
    }
  }
  removeOwners(users) {
    for (const name of users) {
      const id = toID(name);
      if (!this.owners.has(id))
        throw new Chat.ErrorMessage(`User "${name}" is not an auction owner.`);
      this.owners.delete(id);
    }
  }
  generateUsernameList(players, max = players.length, clickable = false) {
    let buf = `<span style="font-size: 85%">`;
    buf += players.slice(0, max).map((p) => {
      if (typeof p === "object") {
        return `<username ${clickable ? ' class="username"' : ""}>${import_lib.Utils.escapeHTML(p.name)}</username>`;
      }
      return `<username${clickable ? ' class="username"' : ""}>${import_lib.Utils.escapeHTML(p)}</username>`;
    }).join(", ");
    if (players.length > max) {
      buf += ` <span title="${players.slice(max).map((p) => import_lib.Utils.escapeHTML(typeof p === "object" ? p.name : p)).join(", ")}">(+${players.length - max})</span>`;
    }
    buf += `</span>`;
    return buf;
  }
  generatePriceList() {
    const players = import_lib.Utils.sortBy(this.getDraftedPlayers(), (p) => -p.price);
    let buf = "";
    let smogonExport = "";
    for (const team of this.teams.values()) {
      let table2 = `<table>`;
      for (const player of players.filter((p) => p.team === team)) {
        table2 += import_lib.Utils.html`<tr><td>${player.name}</td><td>${player.price}</td></tr>`;
      }
      table2 += `</table>`;
      buf += `<details><summary>${import_lib.Utils.escapeHTML(team.name)}</summary>${table2}</details><br/>`;
      if (this.ended)
        smogonExport += `[SPOILER="${team.name}"]${table2.replace(/<(.*?)>/g, "[$1]")}[/SPOILER]`;
    }
    let table = `<table>`;
    for (const player of players) {
      table += import_lib.Utils.html`<tr><td>${player.name}</td><td>${player.price}</td><td>${player.team.name}</td></tr>`;
    }
    table += `</table>`;
    buf += `<details><summary>All</summary>${table}</details><br/>`;
    if (this.ended) {
      smogonExport += `[SPOILER="All"]${table.replace(/<(.*?)>/g, "[$1]")}[/SPOILER]`;
      buf += import_lib.Utils.html`<copytext value="${smogonExport}">Copy Smogon Export</copytext>`;
    }
    return buf;
  }
  generateAuctionTable() {
    const queue = this.queue.filter((team) => !team.isSuspended());
    let buf = `<div class="ladder pad"><table style="width: 100%"><tr>${!this.ended ? `<th colspan=2>Order</th>` : ""}<th>Team</th>${this.type !== "snake" ? `<th>Credits</th>` : ""}<th style="width: 100%">Players</th></tr>`;
    for (const team of this.teams.values()) {
      buf += `<tr>`;
      if (!this.ended) {
        let i1 = queue.indexOf(team) + 1;
        let i2 = queue.lastIndexOf(team) + 1;
        if (i1 > queue.length / 2) {
          [i1, i2] = [i2, i1];
        }
        buf += `<td align="center" style="width: 15px">${i1 || "-"}</td><td align="center" style="width: 15px">${i2 || "-"}</td>`;
      }
      buf += `<td style="white-space: nowrap"><strong>${import_lib.Utils.escapeHTML(team.name)}</strong><br/>${this.generateUsernameList(team.getManagers(), 2, true)}</td>`;
      if (this.type !== "snake") {
        buf += `<td style="white-space: nowrap">${team.credits.toLocaleString()}${team.maxBid() >= this.minBid ? `<br/><span style="font-size: 90%">Max bid: ${team.maxBid().toLocaleString()}</span>` : ""}</td>`;
      }
      buf += `<td title="${team.players.map((p) => import_lib.Utils.escapeHTML(p.name)).join(", ")}"><div style="min-height: 32px${!this.ended ? `; height: 32px; overflow: hidden; resize: vertical` : ""}"><span style="float: right">${team.players.length}</span>${this.generateUsernameList(team.players)}</div></td>`;
      buf += `</tr>`;
    }
    buf += `</table></div>`;
    const players = import_lib.Utils.sortBy(this.getUndraftedPlayers(), (p) => p.name);
    const tierArrays = /* @__PURE__ */ new Map();
    for (const player of players) {
      for (const tier of player.tiersPlayed) {
        if (!tierArrays.has(tier))
          tierArrays.set(tier, []);
        tierArrays.get(tier).push(player);
      }
    }
    const sortedTiers = [...tierArrays.keys()].sort();
    if (sortedTiers.length) {
      buf += `<details><summary>Remaining Players (${players.length})</summary>`;
      buf += `<details><summary>All</summary>${this.generateUsernameList(players)}</details>`;
      buf += `<details><summary>Tiers</summary><ul style="list-style-type: none">`;
      for (const tier of sortedTiers) {
        const tierPlayers = tierArrays.get(tier);
        buf += `<li><details><summary>${import_lib.Utils.escapeHTML(tier)} (${tierPlayers.length})</summary>${this.generateUsernameList(tierPlayers)}</details></li>`;
      }
      buf += `</ul></details></details>`;
    } else {
      buf += `<details><summary>Remaining Players (${players.length})</summary>${this.generateUsernameList(players)}</details>`;
    }
    buf += `<details><summary>Auction Settings</summary>`;
    buf += `- Minimum bid: <b>${this.minBid.toLocaleString()}</b><br/>`;
    buf += `- Minimum players per team: <b>${this.minPlayers}</b><br/>`;
    if (this.type !== "snake")
      buf += `- Maximum players per team: <b>${this.maxPlayers || "N/A"}</b><br/>`;
    buf += `- Nom timer: <b>${this.nomTimeLimit ? `${this.nomTimeLimit}s` : "Off"}</b><br/>`;
    if (this.type !== "snake")
      buf += `- Bid timer: <b>${this.bidTimeLimit}s</b><br/>`;
    buf += `- Auction type: <b>${this.type}</b><br/>`;
    buf += `</details>`;
    return buf;
  }
  sendBidInfo() {
    if (this.type === "blind")
      return;
    let buf = `<div class="infobox">`;
    buf += import_lib.Utils.html`Player: <username>${this.nominatedPlayer.name}</username> `;
    buf += `Top bid: <b>${this.highestBid}</b> `;
    buf += import_lib.Utils.html`Top bidder: <b>${this.highestBidder.name}</b><br/>`;
    buf += import_lib.Utils.html`Tiers Played: <b>${this.nominatedPlayer.tiersPlayed.length ? `${this.nominatedPlayer.tiersPlayed.join(", ")}` : "N/A"}</b><br/>`;
    buf += import_lib.Utils.html`Tiers Not Played: <b>${this.nominatedPlayer.tiersNotPlayed.length ? `${this.nominatedPlayer.tiersNotPlayed.join(", ")}` : "N/A"}</b>`;
    buf += `</div>`;
    this.room.add(`|uhtml|bid-${this.nominatedPlayer.id}|${buf}`).update();
  }
  sendTimer(change = false, nom = false) {
    let buf = `<div class="infobox message-error">`;
    buf += `<i class="fa fa-hourglass-start"></i> ${Chat.toDurationString((nom ? this.nomTimeRemaining : this.bidTimeRemaining) * 1e3, { hhmmss: true }).slice(1)}`;
    buf += `</div>`;
    this.room.add(`|uhtml${change ? "change" : ""}|timer|${buf}`).update();
  }
  setMinBid(amount) {
    if (this.state !== "setup") {
      throw new Chat.ErrorMessage(`The minimum bid cannot be changed after the auction has started.`);
    }
    if (amount > 5e5)
      throw new Chat.ErrorMessage(`The minimum bid must not exceed 500,000.`);
    this.minBid = amount;
  }
  setMinPlayers(amount) {
    if (this.state !== "setup") {
      throw new Chat.ErrorMessage(`The minimum number of players cannot be changed after the auction has started.`);
    }
    if (!amount || amount > 30) {
      throw new Chat.ErrorMessage(`The minimum number of players must be between 1 and 30.`);
    }
    this.minPlayers = amount;
  }
  setMaxPlayers(amount) {
    if (this.type === "snake")
      throw new Chat.ErrorMessage(`You only need to set minplayers for snake drafts.`);
    if (this.state !== "setup") {
      throw new Chat.ErrorMessage(`The maximum number of players cannot be changed after the auction has started.`);
    }
    this.maxPlayers = amount;
  }
  setNomTimeLimit(seconds) {
    if (this.state !== "setup") {
      throw new Chat.ErrorMessage(`The nomination time limit cannot be changed after the auction has started.`);
    }
    if (isNaN(seconds) || seconds && (seconds < 7 || seconds > 300)) {
      throw new Chat.ErrorMessage(`The nomination time limit must be between 7 and 300 seconds.`);
    }
    this.nomTimeLimit = this.nomTimeRemaining = seconds;
  }
  setBidTimeLimit(seconds) {
    if (this.state !== "setup") {
      throw new Chat.ErrorMessage(`The bid time limit cannot be changed after the auction has started.`);
    }
    if (!seconds || seconds < 7 || seconds > 120) {
      throw new Chat.ErrorMessage(`The bid time limit must be between 7 and 120 seconds.`);
    }
    this.bidTimeLimit = this.bidTimeRemaining = seconds;
  }
  setType(auctionType) {
    if (this.state !== "setup") {
      throw new Chat.ErrorMessage(`The auction type cannot be changed after the auction has started.`);
    }
    if (!["auction", "blind", "snake"].includes(toID(auctionType))) {
      throw new Chat.ErrorMessage(`Invalid auction type "${auctionType}". Valid types are "auction", "blind", and "snake".`);
    }
    this.type = toID(auctionType);
    this.nomTimeLimit = this.nomTimeRemaining = this.type === "snake" ? 60 : 0;
    this.bidTimeLimit = this.bidTimeRemaining = this.type === "blind" ? 30 : 10;
  }
  getUndraftedPlayers() {
    return [...this.auctionPlayers.values()].filter((p) => !p.team);
  }
  getDraftedPlayers() {
    return [...this.auctionPlayers.values()].filter((p) => p.team);
  }
  importPlayers(data) {
    if (this.state !== "setup") {
      throw new Chat.ErrorMessage(`Player lists cannot be imported after the auction has started.`);
    }
    const rows = data.replace("\r", "").split("\n");
    const tierNames = rows.shift().split("	").slice(1);
    if (tierNames.some((tier) => tier.length > 30)) {
      throw new Chat.ErrorMessage(`Tier names must be 30 characters or less.`);
    }
    const playerList = /* @__PURE__ */ new Map();
    for (const row of rows) {
      const tiersPlayed = [];
      const tiersNotPlayed = [];
      const [name, ...tierData] = row.split("	");
      for (let i = 0; i < tierData.length; i++) {
        switch (tierData[i].trim().toLowerCase()) {
          case "y":
            if (!tierNames[i])
              throw new Chat.ErrorMessage(`Invalid tier data found in the pastebin.`);
            tiersPlayed.push(tierNames[i]);
            break;
          case "n":
            if (!tierNames[i])
              throw new Chat.ErrorMessage(`Invalid tier data found in the pastebin.`);
            tiersNotPlayed.push(tierNames[i]);
            break;
        }
      }
      if (name.length > 25)
        throw new Chat.ErrorMessage(`Player names must be 25 characters or less.`);
      const player = {
        id: toID(name),
        name: name.trim(),
        price: 0,
        tiersPlayed,
        tiersNotPlayed
      };
      playerList.set(player.id, player);
    }
    this.auctionPlayers = playerList;
  }
  addAuctionPlayer(name, tiersPlayed, tiersNotPlayed) {
    if (this.state === "bid")
      throw new Chat.ErrorMessage(`Players cannot be added during a nomination.`);
    if (name.length > 25)
      throw new Chat.ErrorMessage(`Player names must be 25 characters or less.`);
    if (tiersPlayed.some((tier) => tier.length > 30) || tiersNotPlayed.some((tier) => tier.length > 30)) {
      throw new Chat.ErrorMessage(`Tier names must be 30 characters or less.`);
    }
    const player = {
      id: toID(name),
      name,
      price: 0,
      tiersPlayed,
      tiersNotPlayed
    };
    this.auctionPlayers.set(player.id, player);
    return player;
  }
  removeAuctionPlayer(name) {
    if (this.state === "bid")
      throw new Chat.ErrorMessage(`Players cannot be removed during a nomination.`);
    const player = this.auctionPlayers.get(toID(name));
    if (!player)
      throw new Chat.ErrorMessage(`Player "${name}" not found.`);
    player.team?.removePlayer(player);
    this.auctionPlayers.delete(player.id);
    if (this.state !== "setup" && !this.getUndraftedPlayers().length) {
      this.end("The auction has ended because there are no players remaining in the draft pool.");
    }
    return player;
  }
  assignPlayer(name, teamName) {
    if (this.state === "bid")
      throw new Chat.ErrorMessage(`Players cannot be assigned during a nomination.`);
    const player = this.auctionPlayers.get(toID(name));
    if (!player)
      throw new Chat.ErrorMessage(`Player "${name}" not found.`);
    if (teamName) {
      const team = this.teams.get(toID(teamName));
      if (!team)
        throw new Chat.ErrorMessage(`Team "${teamName}" not found.`);
      team.addPlayer(player);
      if (!this.getUndraftedPlayers().length) {
        return this.end("The auction has ended because there are no players remaining in the draft pool.");
      }
    } else {
      player.team?.removePlayer(player);
    }
  }
  addTeam(name) {
    if (this.state !== "setup")
      throw new Chat.ErrorMessage(`Teams cannot be added after the auction has started.`);
    if (name.length > 40)
      throw new Chat.ErrorMessage(`Team names must be 40 characters or less.`);
    const team = new Team(name, this);
    this.teams.set(team.id, team);
    const teams = [...this.teams.values()];
    this.queue = teams.concat(teams.slice().reverse());
    return team;
  }
  removeTeam(name) {
    if (this.state !== "setup")
      throw new Chat.ErrorMessage(`Teams cannot be removed after the auction has started.`);
    const team = this.teams.get(toID(name));
    if (!team)
      throw new Chat.ErrorMessage(`Team "${name}" not found.`);
    this.queue = this.queue.filter((t) => t !== team);
    this.teams.delete(team.id);
    return team;
  }
  suspendTeam(name) {
    if (this.state === "bid")
      throw new Chat.ErrorMessage(`Teams cannot be suspended during a nomination.`);
    const team = this.teams.get(toID(name));
    if (!team)
      throw new Chat.ErrorMessage(`Team "${name}" not found.`);
    if (team.suspended)
      throw new Chat.ErrorMessage(`Team ${name} is already suspended.`);
    if (this.nominatingTeam === team)
      throw new Chat.ErrorMessage(`The nominating team cannot be suspended.`);
    team.suspended = true;
    return team;
  }
  unsuspendTeam(name) {
    if (this.state === "bid")
      throw new Chat.ErrorMessage(`Teams cannot be unsuspended during a nomination.`);
    const team = this.teams.get(toID(name));
    if (!team)
      throw new Chat.ErrorMessage(`Team "${name}" not found.`);
    if (!team.suspended)
      throw new Chat.ErrorMessage(`Team ${name} is not suspended.`);
    team.suspended = false;
    return team;
  }
  addManagers(teamName, users) {
    const team = this.teams.get(toID(teamName));
    if (!team)
      throw new Chat.ErrorMessage(`Team "${teamName}" not found.`);
    const problemUsers = users.filter((user) => !toID(user) || toID(user).length > 18);
    if (problemUsers.length) {
      throw new Chat.ErrorMessage(`Invalid usernames: ${problemUsers.join(", ")}`);
    }
    for (const id of users.map(toID)) {
      const manager = this.managers.get(id);
      if (!manager) {
        this.managers.set(id, { id, team });
      } else {
        manager.team = team;
      }
    }
    return team;
  }
  removeManagers(users) {
    const problemUsers = users.filter((user) => !this.managers.has(toID(user)));
    if (problemUsers.length) {
      throw new Chat.ErrorMessage(`Invalid managers: ${problemUsers.join(", ")}`);
    }
    for (const id of users.map(toID)) {
      this.managers.delete(id);
    }
  }
  addCreditsToTeam(teamName, amount) {
    if (this.type === "snake")
      throw new Chat.ErrorMessage(`Snake draft does not support credits.`);
    if (this.state === "bid")
      throw new Chat.ErrorMessage(`Credits cannot be changed during a nomination.`);
    const team = this.teams.get(toID(teamName));
    if (!team)
      throw new Chat.ErrorMessage(`Team "${teamName}" not found.`);
    const newCredits = team.credits + amount;
    if (newCredits <= 0 || newCredits > 1e7) {
      throw new Chat.ErrorMessage(`A team must have between 0 and 10,000,000 credits.`);
    }
    if (team.maxBid(newCredits) < this.minBid) {
      throw new Chat.ErrorMessage(`A team must have enough credits to draft the minimum amount of players.`);
    }
    team.credits = newCredits;
    return team;
  }
  start() {
    if (this.state !== "setup")
      throw new Chat.ErrorMessage(`The auction has already started.`);
    if (this.teams.size < 2)
      throw new Chat.ErrorMessage(`The auction needs at least 2 teams to start.`);
    const problemTeams = [...this.teams.values()].filter((t) => t.maxBid() < this.minBid).map((t) => t.name);
    if (problemTeams.length) {
      throw new Chat.ErrorMessage(`The following teams do not have enough credits to draft the minimum amount of players: ${problemTeams.join(", ")}`);
    }
    this.next();
  }
  reset() {
    const teams = [...this.teams.values()];
    for (const team of teams) {
      team.credits = this.startingCredits;
      team.suspended = false;
      for (const player of team.players) {
        delete player.team;
        player.price = 0;
      }
      team.players = [];
    }
    this.lastQueue = null;
    this.queue = teams.concat(teams.slice().reverse());
    this.clearNomTimer();
    this.clearBidTimer();
    this.state = "setup";
    this.sendHTMLBox(this.generateAuctionTable());
  }
  next() {
    this.state = "nom";
    if (!this.queue.filter((team) => !team.isSuspended()).length) {
      return this.end("The auction has ended because there are no teams remaining that can draft players.");
    }
    if (!this.getUndraftedPlayers().length) {
      return this.end("The auction has ended because there are no players remaining in the draft pool.");
    }
    do {
      this.nominatingTeam = this.queue.shift();
      this.queue.push(this.nominatingTeam);
    } while (this.nominatingTeam.isSuspended());
    this.sendHTMLBox(this.generateAuctionTable());
    this.sendMessage(`/html It is now <b>${import_lib.Utils.escapeHTML(this.nominatingTeam.name)}</b>'s turn to nominate a player. Managers: ${this.nominatingTeam.getManagers().map((m) => `<username class="username">${import_lib.Utils.escapeHTML(m)}</username>`).join(" ")}`);
    this.startNomTimer();
  }
  nominate(user, target) {
    if (this.state !== "nom")
      throw new Chat.ErrorMessage(`You cannot nominate players right now.`);
    const manager = this.managers.get(user.id);
    if (!manager || manager.team !== this.nominatingTeam)
      this.checkOwner(user);
    this.lastQueue = this.queue.slice();
    this.lastQueue.unshift(this.lastQueue.pop());
    const player = this.auctionPlayers.get(toID(target));
    if (!player)
      throw new Chat.ErrorMessage(`${target} is not a valid player.`);
    if (player.team)
      throw new Chat.ErrorMessage(`${player.name} has already been drafted.`);
    this.clearNomTimer();
    this.nominatedPlayer = player;
    if (this.type === "snake") {
      this.sendMessage(import_lib.Utils.html`/html <b>${this.nominatingTeam.name}</b> drafted <username>${this.nominatedPlayer.name}</username>!`);
      this.nominatingTeam.addPlayer(this.nominatedPlayer);
      this.next();
    } else {
      this.state = "bid";
      this.highestBid = this.minBid;
      this.highestBidder = this.nominatingTeam;
      this.sendMessage(import_lib.Utils.html`/html <username class="username">${user.name}</username> from team <b>${this.nominatingTeam.name}</b> has nominated <username>${player.name}</username> for auction!`);
      const notifyMsg = import_lib.Utils.html`|notify|${this.room.title} Auction|${player.name} has been nominated!`;
      for (const currManager of this.managers.values()) {
        if (currManager.team === this.nominatingTeam)
          continue;
        const curUser = Users.getExact(currManager.id);
        curUser?.sendTo(this.room, notifyMsg);
        curUser?.sendTo(
          this.room,
          `|raw|Send a message with the amount you want to bid (e.g. <code>.5</code> or <code>5</code> will place a bid of <b>5000</b>)!`
        );
      }
      this.sendBidInfo();
      this.startBidTimer();
    }
  }
  bid(user, bid) {
    if (this.state !== "bid")
      throw new Chat.ErrorMessage(`There are no players up for auction right now.`);
    const team = this.managers.get(user.id)?.team;
    if (!team)
      throw new Chat.ErrorMessage(`Only managers can bid on players.`);
    if (team.isSuspended())
      throw new Chat.ErrorMessage(`Your team is suspended and cannot place bids.`);
    if (bid > team.maxBid())
      throw new Chat.ErrorMessage(`Your team cannot afford to bid that much.`);
    if (this.type === "blind") {
      if (this.bidsPlaced.has(team))
        throw new Chat.ErrorMessage(`Your team has already placed a bid.`);
      if (bid <= this.minBid)
        throw new Chat.ErrorMessage(`Your bid must be higher than the minimum bid.`);
      const msg = `|c:|${Math.floor(Date.now() / 1e3)}|&|/html Your team placed a bid of <b>${bid}</b> on <username>${import_lib.Utils.escapeHTML(this.nominatedPlayer.name)}</username>.`;
      for (const manager of this.managers.values()) {
        if (manager.team !== team)
          continue;
        Users.getExact(manager.id)?.sendTo(this.room, msg);
      }
      if (bid > this.highestBid) {
        this.highestBid = bid;
        this.highestBidder = team;
      }
      this.bidsPlaced.set(team, bid);
      if (this.bidsPlaced.size === this.teams.size) {
        this.finishCurrentNom();
      }
    } else {
      if (bid <= this.highestBid)
        throw new Chat.ErrorMessage(`Your bid must be higher than the current bid.`);
      this.highestBid = bid;
      this.highestBidder = team;
      this.sendBidInfo();
      this.startBidTimer();
    }
  }
  onChatMessage(message, user) {
    if (this.state !== "bid" || this.type !== "blind")
      return;
    if (message.startsWith("."))
      message = message.slice(1);
    if (Number(message.replace(",", "."))) {
      this.bid(user, parseCredits(message));
      return "";
    }
  }
  onLogMessage(message, user) {
    if (this.state !== "bid" || this.type === "blind")
      return;
    if (message.startsWith("."))
      message = message.slice(1);
    if (Number(message.replace(",", "."))) {
      this.room.update();
      try {
        this.bid(user, parseCredits(message));
      } catch (e) {
        if (e instanceof Chat.ErrorMessage) {
          user.sendTo(this.room, import_lib.Utils.html`|raw|<span class="message-error">${e.message}</span>`);
        } else {
          user.sendTo(this.room, `|raw|<span class="message-error">An unexpected error occurred while placing your bid.</span>`);
        }
      }
    }
  }
  skipNom() {
    if (this.state !== "nom")
      throw new Chat.ErrorMessage(`Nominations cannot be skipped right now.`);
    this.nominatedPlayer = null;
    this.sendMessage(`**${this.nominatingTeam.name}**'s nomination turn has been skipped!`);
    this.clearNomTimer();
    this.next();
  }
  finishCurrentNom() {
    if (this.type === "blind") {
      let buf = `<div class="ladder pad"><table><tr><th>Team</th><th>Bid</th></tr>`;
      if (!this.bidsPlaced.has(this.nominatingTeam)) {
        buf += import_lib.Utils.html`<tr><td>${this.nominatingTeam.name}</td><td>${this.minBid}</td></tr>`;
      }
      for (const [team, bid] of this.bidsPlaced) {
        buf += import_lib.Utils.html`<tr><td>${team.name}</td><td>${bid}</td></tr>`;
      }
      buf += `</table></div>`;
      this.sendHTMLBox(buf);
      this.bidsPlaced.clear();
    }
    this.sendMessage(import_lib.Utils.html`/html <b>${this.highestBidder.name}</b> bought <username>${this.nominatedPlayer.name}</username> for <b>${this.highestBid}</b> credits!`);
    this.highestBidder.addPlayer(this.nominatedPlayer, this.highestBid);
    this.clearBidTimer();
    this.next();
  }
  undoLastNom() {
    if (this.state !== "nom")
      throw new Chat.ErrorMessage(`Nominations cannot be undone right now.`);
    if (!this.lastQueue)
      throw new Chat.ErrorMessage(`Only one nomination can be undone at a time.`);
    this.queue = this.lastQueue;
    this.lastQueue = null;
    if (this.nominatedPlayer) {
      this.highestBidder.removePlayer(this.nominatedPlayer);
      this.highestBidder.credits += this.highestBid;
    }
    this.next();
  }
  clearNomTimer() {
    clearInterval(this.nomTimer);
    this.nomTimeRemaining = this.nomTimeLimit;
    this.room.add("|uhtmlchange|timer|");
  }
  startNomTimer() {
    if (!this.nomTimeLimit)
      return;
    this.clearNomTimer();
    this.sendTimer(false, true);
    this.nomTimer = setInterval(() => this.pokeNomTimer(), 1e3);
  }
  clearBidTimer() {
    clearInterval(this.bidTimer);
    this.bidTimeRemaining = this.bidTimeLimit;
    this.room.add("|uhtmlchange|timer|");
  }
  startBidTimer() {
    if (!this.bidTimeLimit)
      return;
    this.clearBidTimer();
    this.sendTimer();
    this.bidTimer = setInterval(() => this.pokeBidTimer(), 1e3);
  }
  pokeNomTimer() {
    this.nomTimeRemaining--;
    if (!this.nomTimeRemaining) {
      this.skipNom();
    } else {
      this.sendTimer(true, true);
      if (this.nomTimeRemaining % 30 === 0 || [20, 10, 5].includes(this.nomTimeRemaining)) {
        this.sendMessage(`/html <span class="message-error">${this.nomTimeRemaining} seconds left!</span>`);
      }
    }
  }
  pokeBidTimer() {
    this.bidTimeRemaining--;
    if (!this.bidTimeRemaining) {
      this.finishCurrentNom();
    } else {
      this.sendTimer(true);
      if (this.bidTimeRemaining % 30 === 0 || [20, 10, 5].includes(this.bidTimeRemaining)) {
        this.sendMessage(`/html <span class="message-error">${this.bidTimeRemaining} seconds left!</span>`);
      }
    }
  }
  end(message) {
    this.setEnded();
    this.sendHTMLBox(this.generateAuctionTable());
    this.sendHTMLBox(this.generatePriceList());
    if (message)
      this.sendMessage(message);
    this.destroy();
  }
  destroy() {
    this.clearNomTimer();
    this.clearBidTimer();
    super.destroy();
  }
}
const commands = {
  auction: {
    create(target, room, user) {
      room = this.requireRoom();
      this.checkCan("minigame", null, room);
      if (room.game)
        return this.errorReply(`There is already a game of ${room.game.title} in progress in this room.`);
      if (room.settings.auctionDisabled)
        return this.errorReply("Auctions are currently disabled in this room.");
      let startingCredits;
      if (target) {
        startingCredits = parseCredits(target);
        if (startingCredits < 1e4 || startingCredits > 1e7) {
          return this.errorReply(`Starting credits must be between 10,000 and 10,000,000.`);
        }
      }
      const auction = new Auction(room, startingCredits);
      auction.addOwners([user.id]);
      room.game = auction;
      this.addModAction(`An auction was created by ${user.name}.`);
      this.modlog(`AUCTION CREATE`);
    },
    createhelp: [
      `/auction create [startingcredits] - Creates an auction. Requires: % @ # ~`
    ],
    start(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      auction.start();
      this.addModAction(`The auction was started by ${user.name}.`);
      this.modlog(`AUCTION START`);
    },
    reset(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      auction.reset();
      this.addModAction(`The auction was reset by ${user.name}.`);
      this.modlog(`AUCTION RESET`);
    },
    delete: "end",
    stop: "end",
    end(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      auction.end();
      this.addModAction(`The auction was ended by ${user.name}.`);
      this.modlog("AUCTION END");
    },
    info: "display",
    display(target, room, user) {
      this.runBroadcast();
      const auction = this.requireGame(Auction);
      this.sendReplyBox(auction.generateAuctionTable());
    },
    pricelist(target, room, user) {
      this.runBroadcast();
      const auction = this.requireGame(Auction);
      this.sendReplyBox(auction.generatePriceList());
    },
    minbid(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction minbid");
      const amount = parseCredits(target);
      auction.setMinBid(amount);
      this.addModAction(`${user.name} set the minimum bid to ${amount}.`);
      this.modlog("AUCTION MINBID", null, `${amount}`);
    },
    minbidhelp: [
      `/auction minbid [amount] - Sets the minimum bid. Requires: # ~ auction owner`
    ],
    minplayers(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction minplayers");
      const amount = parseInt(target);
      auction.setMinPlayers(amount);
      this.addModAction(`${user.name} set the minimum number of players to ${amount}.`);
    },
    minplayershelp: [
      `/auction minplayers [amount] - Sets the minimum number of players. Requires: # ~ auction owner`
    ],
    maxplayers(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction maxplayers");
      const amount = parseInt(target);
      auction.setMaxPlayers(amount);
      this.addModAction(`${user.name} set the maximum number of players to ${amount}.`);
    },
    maxplayershelp: [
      `/auction maxplayers [amount] - Sets the maximum number of players. Requires: # ~ auction owner`
    ],
    nomtimer(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction nomtimer");
      const seconds = this.meansNo(target) ? 0 : parseInt(target);
      auction.setNomTimeLimit(seconds);
      this.addModAction(`${user.name} set the nomination timer to ${seconds} seconds.`);
    },
    nomtimerhelp: [
      `/auction nomtimer [seconds/off] - Sets the nomination timer to [seconds] seconds or disables it. Requires: # ~ auction owner`
    ],
    bidtimer(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction settimer");
      const seconds = parseInt(target);
      auction.setBidTimeLimit(seconds);
      this.addModAction(`${user.name} set the bid timer to ${seconds} seconds.`);
    },
    bidtimerhelp: [
      `/auction timer [seconds] - Sets the bid timer to [seconds] seconds. Requires: # ~ auction owner`
    ],
    settype(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction settype");
      auction.setType(target);
      this.addModAction(`${user.name} set the auction type to ${toID(target)}.`);
    },
    settypehelp: [
      `/auction settype [auction|blind|snake] - Sets the auction type. Requires: # ~ auction owner`,
      `- auction: Standard auction with credits and bidding.`,
      `- blind: Same as auction, but bids are hidden until the end of the nomination.`,
      `- snake: Standard snake draft with no credits or bidding.`
    ],
    addowner: "addowners",
    addowners(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      const owners = target.split(",").map((x) => x.trim());
      if (!owners.length)
        return this.parse("/help auction addowners");
      auction.addOwners(owners);
      this.addModAction(`${user.name} added ${Chat.toListString(owners.map((o) => Users.getExact(o).name))} as auction owner${Chat.plural(owners.length)}.`);
    },
    addownershelp: [
      `/auction addowners [user1], [user2], ... - Adds users as auction owners. Requires: # ~ auction owner`
    ],
    removeowner: "removeowners",
    removeowners(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      const owners = target.split(",").map((x) => x.trim());
      if (!owners.length)
        return this.parse("/help auction removeowners");
      auction.removeOwners(owners);
      this.addModAction(`${user.name} removed ${Chat.toListString(owners.map((o) => Users.getExact(o)?.name || o))} as auction owner${Chat.plural(owners.length)}.`);
    },
    removeownershelp: [
      `/auction removeowners [user1], [user2], ... - Removes users as auction owners. Requires: # ~ auction owner`
    ],
    async importplayers(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction importplayers");
      if (!/^https?:\/\/pastebin\.com\/[a-zA-Z0-9]+$/.test(target)) {
        return this.errorReply("Invalid pastebin URL.");
      }
      let data = "";
      try {
        data = await (0, import_lib.Net)(`https://pastebin.com/raw/${target.split("/").pop()}`).get();
      } catch {
      }
      if (!data)
        return this.errorReply("Error fetching data from pastebin.");
      auction.importPlayers(data);
      this.addModAction(`${user.name} imported the player list from ${target}.`);
    },
    importplayershelp: [
      `/auction importplayers [pastebin url] - Imports a list of players from a pastebin. Requires: # ~ auction owner`,
      `The pastebin should be a list of tab-separated values with the first row containing tier names and subsequent rows containing the player names and either a 'y' or an 'n' in the column corresponding to the tier they prefer or do not play respectively.`,
      `See https://pastebin.com/jPTbJBva for an example.`
    ],
    addplayer(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      const [playedPart, notPlayedPart] = target.split(";");
      const tiersPlayed = playedPart.split(",").map((item) => item.trim());
      const tiersNotPlayed = notPlayedPart ? notPlayedPart.split(",").map((item) => item.trim()) : [];
      const name = tiersPlayed.shift();
      if (!name)
        return this.parse("/help auction addplayer");
      const player = auction.addAuctionPlayer(name, tiersPlayed, tiersNotPlayed);
      this.addModAction(`${user.name} added player ${player.name} to the auction.`);
    },
    addplayerhelp: [
      `/auction addplayer [name], [tierPlayed1], [tierPlayed2], ... ; [tierNotPlayed1], [tierNotPlayed2], ... - Adds a player to the auction. Requires: # ~ auction owner`
    ],
    removeplayer(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction removeplayer");
      const player = auction.removeAuctionPlayer(target);
      this.addModAction(`${user.name} removed player ${player.name} from the auction.`);
    },
    removeplayerhelp: [
      `/auction removeplayer [name] - Removes a player from the auction. Requires: # ~ auction owner`
    ],
    assignplayer(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      const [player, team] = target.split(",").map((x) => x.trim());
      if (!player)
        return this.parse("/help auction assignplayer");
      if (team) {
        auction.assignPlayer(player, team);
        this.addModAction(`${user.name} assigned player ${player} to team ${team}.`);
      } else {
        auction.assignPlayer(player);
        this.sendReply(`${user.name} returned player ${player} to the draft pool.`);
      }
    },
    assignplayerhelp: [
      `/auction assignplayer [player], [team] - Assigns a player to a team. If team is blank, returns player to draft pool. Requires: # ~ auction owner`
    ],
    addteam(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      const [name, ...managerNames] = target.split(",").map((x) => x.trim());
      if (!name)
        return this.parse("/help auction addteam");
      const team = auction.addTeam(name);
      this.addModAction(`${user.name} added team ${team.name} to the auction.`);
      auction.addManagers(team.name, managerNames);
    },
    addteamhelp: [
      `/auction addteam [name], [manager1], [manager2], ... - Adds a team to the auction. Requires: # ~ auction owner`
    ],
    removeteam(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction removeteam");
      const team = auction.removeTeam(target);
      this.addModAction(`${user.name} removed team ${team.name} from the auction.`);
    },
    removeteamhelp: [
      `/auction removeteam [team] - Removes a team from the auction. Requires: # ~ auction owner`
    ],
    suspendteam(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction suspendteam");
      const team = auction.suspendTeam(target);
      this.addModAction(`${user.name} suspended team ${team.name}.`);
    },
    suspendteamhelp: [
      `/auction suspendteam [team] - Suspends a team from the auction. Requires: # ~ auction owner`,
      `Suspended teams have their nomination turns skipped and are not allowed to place bids.`
    ],
    unsuspendteam(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction unsuspendteam");
      const team = auction.unsuspendTeam(target);
      this.addModAction(`${user.name} unsuspended team ${team.name}.`);
    },
    unsuspendteamhelp: [
      `/auction unsuspendteam [team] - Unsuspends a team from the auction. Requires: # ~ auction owner`
    ],
    addmanager: "addmanagers",
    addmanagers(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      const [teamName, ...managerNames] = target.split(",").map((x) => x.trim());
      if (!teamName || !managerNames.length)
        return this.parse("/help auction addmanagers");
      const team = auction.addManagers(teamName, managerNames);
      const managers = managerNames.map((m) => Users.getExact(m)?.name || toID(m));
      this.addModAction(`${user.name} added ${Chat.toListString(managers)} as manager${Chat.plural(managers.length)} for team ${team.name}.`);
    },
    addmanagershelp: [
      `/auction addmanagers [team], [user1], [user2], ... - Adds users as managers to a team. Requires: # ~ auction owner`
    ],
    removemanager: "removemanagers",
    removemanagers(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      if (!target)
        return this.parse("/help auction removemanagers");
      const managerNames = target.split(",").map((x) => x.trim());
      auction.removeManagers(managerNames);
      const managers = managerNames.map((m) => Users.getExact(m)?.name || toID(m));
      this.addModAction(`${user.name} removed ${Chat.toListString(managers)} as manager${Chat.plural(managers.length)}.`);
    },
    removemanagershelp: [
      `/auction removemanagers [user1], [user2], ... - Removes users as managers. Requires: # ~ auction owner`
    ],
    addcredits(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      const [teamName, amount] = target.split(",").map((x) => x.trim());
      if (!teamName || !amount)
        return this.parse("/help auction addcredits");
      const credits = parseCredits(amount);
      const team = auction.addCreditsToTeam(teamName, credits);
      this.addModAction(`${user.name} ${credits < 0 ? "removed" : "added"} ${Math.abs(credits)} credits ${credits < 0 ? "from" : "to"} team ${team.name}.`);
    },
    addcreditshelp: [
      `/auction addcredits [team], [amount] - Adds credits to a team. Requires: # ~ auction owner`
    ],
    nom: "nominate",
    nominate(target, room, user) {
      const auction = this.requireGame(Auction);
      if (!target)
        return this.parse("/help auction nominate");
      auction.nominate(user, target);
    },
    nominatehelp: [
      `/auction nominate OR /nom [player] - Nominates a player for auction.`
    ],
    skip: "skipnom",
    skipnom(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      auction.skipNom();
      this.addModAction(`${user.name} skipped the previous nomination.`);
    },
    undo(target, room, user) {
      const auction = this.requireGame(Auction);
      auction.checkOwner(user);
      auction.undoLastNom();
      this.addModAction(`${user.name} undid the last nomination.`);
    },
    disable(target, room) {
      room = this.requireRoom();
      this.checkCan("gamemanagement", null, room);
      if (room.settings.auctionDisabled) {
        return this.errorReply("Auctions are already disabled.");
      }
      room.settings.auctionDisabled = true;
      room.saveSettings();
      this.sendReply("Auctions have been disabled for this room.");
    },
    enable(target, room) {
      room = this.requireRoom();
      this.checkCan("gamemanagement", null, room);
      if (!room.settings.auctionDisabled) {
        return this.errorReply("Auctions are already enabled.");
      }
      delete room.settings.auctionDisabled;
      room.saveSettings();
      this.sendReply("Auctions have been enabled for this room.");
    },
    ongoing: "running",
    running() {
      if (!this.runBroadcast())
        return;
      const runningAuctions = [...Rooms.rooms.values()].filter((r) => r.getGame(Auction)).map((r) => r.title);
      this.sendReply(`Running auctions: ${runningAuctions.join(", ") || "None"}`);
    },
    "": "help",
    help() {
      this.parse("/help auction");
    }
  },
  auctionhelp() {
    if (!this.runBroadcast())
      return;
    this.sendReplyBox(
      `Auction commands<br/>- create [startingcredits]: Creates an auction.<br/>- start: Starts the auction.<br/>- reset: Resets the auction.<br/>- end: Ends the auction.<br/>- running: Shows a list of rooms with running auctions.<br/>- display: Displays the current state of the auction.<br/>- pricelist: Displays the current prices of players by team.<br/>- nom [player]: Nominates a player for auction.<br/>You may use /nom directly without the /auction prefix.<br/>During the bidding phase, all numbers that are sent in the chat will be treated as bids.<br/><br/><details class="readmore"><summary>Configuration Commands</summary>- minbid [amount]: Sets the minimum bid.<br/>- minplayers [amount]: Sets the minimum number of players.<br/>- nomtimer [seconds]: Sets the nomination timer to [seconds] seconds.<br/>- bidtimer [seconds]: Sets the bid timer to [seconds] seconds.<br/>- settype [auction|blind|snake]: Sets the auction type.<br/>- addowners [user1], [user2], ...: Adds users as auction owners.<br/>- removeowners [user1], [user2], ...: Removes users as auction owners.<br/>- importplayers [pastebin url]: Imports a list of players from a pastebin.<br/>- addplayer [name], [tier1], [tier2], ...: Adds a player to the auction.<br/>- removeplayer [name]: Removes a player from the auction.<br/>- assignplayer [player], [team]: Assigns a player to a team. If team is blank, returns player to draft pool.<br/>- addteam [name], [manager1], [manager2], ...: Adds a team to the auction.<br/>- removeteam [name]: Removes the given team from the auction.<br/>- suspendteam [name]: Suspends the given team from the auction.<br/>- unsuspendteam [name]: Unsuspends the given team from the auction.<br/>- addmanagers [team], [user1], [user2], ...: Adds users as managers to a team.<br/>- removemanagers [user1], [user2], ...: Removes users as managers..<br/>- addcredits [team], [amount]: Adds credits to a team.<br/>- skipnom: Skips the current nomination.<br/>- undo: Undoes the last nomination.<br/>- [enable/disable]: Enables or disables auctions from being started in a room.<br/></details>`
    );
  },
  nom(target) {
    this.parse(`/auction nominate ${target}`);
  },
  bid() {
    this.errorReply(`/bid is no longer supported. Send the amount by itself in the chat to place your bid.`);
  },
  overpay() {
    this.requireGame(Auction);
    this.checkChat();
    return "/announce OVERPAY!";
  }
};
const roomSettings = (room) => ({
  label: "Auction",
  permission: "editroom",
  options: [
    [`disabled`, room.settings.auctionDisabled || "auction disable"],
    [`enabled`, !room.settings.auctionDisabled || "auction enable"]
  ]
});
//# sourceMappingURL=auction.js.map