dist/server/chat-plugins/hangman.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 hangman_exports = {};
__export(hangman_exports, {
  Hangman: () => Hangman,
  commands: () => commands,
  hangmanData: () => hangmanData,
  pages: () => pages,
  roomSettings: () => roomSettings
});
module.exports = __toCommonJS(hangman_exports);
var import_lib = require("../../lib");
const HANGMAN_FILE = "config/chat-plugins/hangman.json";
const DIACRITICS_AFTER_UNDERSCORE = /_[\u0300-\u036f\u0483-\u0489\u0610-\u0615\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06ED\u0E31\u0E34-\u0E3A\u0E47-\u0E4E]+/g;
const MAX_HANGMAN_LENGTH = 30;
const MAX_INDIVIDUAL_WORD_LENGTH = 20;
const MAX_HINT_LENGTH = 150;
let hangmanData = {};
try {
  hangmanData = JSON.parse((0, import_lib.FS)(HANGMAN_FILE).readSync());
  let save = false;
  for (const roomid in hangmanData) {
    const roomData = hangmanData[roomid] || {};
    const roomKeys = Object.keys(roomData);
    if (roomKeys.length && !roomData[roomKeys[0]].hints) {
      save = true;
      for (const key of roomKeys) {
        roomData[key] = { hints: roomData[key] };
      }
    }
  }
  if (save) {
    (0, import_lib.FS)(HANGMAN_FILE).writeUpdate(() => JSON.stringify(hangmanData));
  }
} catch {
}
const maxMistakes = 6;
class Hangman extends Rooms.SimpleRoomGame {
  constructor(room, user, word, hint = "", gameOptions = {}) {
    super(room);
    this.gameid = "hangman";
    this.checkChat = true;
    this.gameNumber = room.nextGameNumber();
    this.title = "Hangman";
    this.creator = user.id;
    this.word = word;
    this.hint = hint;
    this.incorrectGuesses = 0;
    this.options = gameOptions;
    this.guesses = [];
    this.letterGuesses = [];
    this.lastGuesser = "";
    this.wordSoFar = [];
    for (const letter of word) {
      if (/[a-zA-Z]/.test(letter)) {
        this.wordSoFar.push("_");
      } else {
        this.wordSoFar.push(letter);
      }
    }
  }
  choose(user, word) {
    if (user.id === this.creator && !this.options.allowCreator) {
      throw new Chat.ErrorMessage("You can't guess in your own hangman game.");
    }
    const sanitized = word.replace(/[^A-Za-z ]/g, "");
    const normalized = toID(sanitized);
    if (normalized.length < 1) {
      throw new Chat.ErrorMessage(`Use "/guess [letter]" to guess a letter, or "/guess [phrase]" to guess the entire Hangman phrase.`);
    }
    if (sanitized.length > MAX_HANGMAN_LENGTH) {
      throw new Chat.ErrorMessage(`Guesses must be ${MAX_HANGMAN_LENGTH} or fewer letters \u2013 "${word}" is too long.`);
    }
    for (const guessid of this.guesses) {
      if (normalized === toID(guessid))
        throw new Chat.ErrorMessage(`Your guess "${word}" has already been guessed.`);
    }
    if (sanitized.length > 1) {
      if (!this.guessWord(sanitized, user.name)) {
        throw new Chat.ErrorMessage(`Your guess "${sanitized}" is invalid.`);
      } else {
        this.room.addByUser(user, `${user.name} guessed "${sanitized}"!`);
      }
    } else {
      if (!this.guessLetter(sanitized, user.name)) {
        throw new Chat.ErrorMessage(`Your guess "${sanitized}" is not a valid letter.`);
      }
    }
  }
  guessLetter(letter, guesser) {
    letter = letter.toUpperCase();
    if (this.guesses.includes(letter))
      return false;
    if (this.word.toUpperCase().includes(letter)) {
      for (let i = 0; i < this.word.length; i++) {
        if (this.word[i].toUpperCase() === letter) {
          this.wordSoFar[i] = this.word[i];
        }
      }
      if (!this.wordSoFar.includes("_")) {
        this.incorrectGuesses = -1;
        this.guesses.push(letter);
        this.letterGuesses.push(`${letter}1`);
        this.lastGuesser = guesser;
        this.finish();
        return true;
      }
      this.letterGuesses.push(`${letter}1`);
    } else {
      this.incorrectGuesses++;
      this.letterGuesses.push(`${letter}0`);
    }
    this.guesses.push(letter);
    this.lastGuesser = guesser;
    this.update();
    return true;
  }
  guessWord(word, guesser) {
    const ourWord = toID(this.word.replace(/[0-9]+/g, ""));
    const guessedWord = toID(word.replace(/[0-9]+/g, ""));
    const wordSoFar = this.wordSoFar.filter((letter) => /[a-zA-Z_]/.test(letter)).join("").toLowerCase();
    if (ourWord.length !== guessedWord.length)
      return false;
    for (let i = 0; i < ourWord.length; i++) {
      if (wordSoFar.charAt(i) === "_") {
        if (this.letterGuesses.some((guess) => guess.toLowerCase().startsWith(guessedWord.charAt(i))))
          return false;
      } else if (wordSoFar.charAt(i) !== guessedWord.charAt(i)) {
        return false;
      }
    }
    if (ourWord === guessedWord) {
      for (const [i, letter] of this.wordSoFar.entries()) {
        if (letter === "_") {
          this.wordSoFar[i] = this.word[i];
        }
      }
      this.incorrectGuesses = -1;
      this.guesses.push(word);
      this.lastGuesser = guesser;
      this.finish();
    } else {
      this.incorrectGuesses++;
      this.guesses.push(word);
      this.lastGuesser = guesser;
      this.update();
    }
    return true;
  }
  hangingMan() {
    return `<img width="120" height="120" src="//${Config.routes.client}/fx/hangman${this.incorrectGuesses === -1 ? 7 : this.incorrectGuesses}.png" />`;
  }
  generateWindow() {
    let result = 0;
    if (this.incorrectGuesses === maxMistakes) {
      result = 1;
    } else if (!this.wordSoFar.includes("_")) {
      result = 2;
    }
    const color = result === 1 ? "red" : result === 2 ? "green" : "blue";
    const message = `${result === 1 ? "Too bad! The mon has been hanged." : result === 2 ? "The word has been guessed. Congratulations!" : "Hangman"}`;
    let output = `<div class="broadcast-${color}">`;
    output += `<p style="text-align:left;font-weight:bold;font-size:10pt;margin:5px 0 0 15px">${message}</p>`;
    output += `<table><tr><td style="text-align:center;">${this.hangingMan()}</td><td style="text-align:center;width:100%;word-wrap:break-word">`;
    let escapedWord = this.wordSoFar.map(import_lib.Utils.escapeHTML);
    if (result === 1) {
      const word = this.word;
      escapedWord = escapedWord.map((letter, index) => letter === "_" ? `<font color="#7af87a">${word.charAt(index)}</font>` : letter);
    }
    const wordString = escapedWord.join("").replace(DIACRITICS_AFTER_UNDERSCORE, "_");
    if (this.hint)
      output += import_lib.Utils.html`<div>(Hint: ${this.hint})</div>`;
    output += `<p style="font-weight:bold;font-size:12pt;letter-spacing:3pt">${wordString}</p>`;
    if (this.guesses.length) {
      if (this.letterGuesses.length) {
        output += "Letters: " + this.letterGuesses.map(
          (g) => `<strong${g[1] === "1" ? "" : ' style="color: #DBA"'}>${g[0]}</strong>`
        ).join(", ");
      }
      if (result === 2) {
        output += import_lib.Utils.html`<br />Winner: ${this.lastGuesser}`;
      } else if (this.guesses[this.guesses.length - 1].length === 1) {
        output += import_lib.Utils.html` <small>&ndash; ${this.lastGuesser}</small>`;
      } else {
        output += import_lib.Utils.html`<br />Guessed: ${this.guesses[this.guesses.length - 1]} ` + `<small>&ndash; ${this.lastGuesser}</small>`;
      }
    }
    output += "</td></tr></table></div>";
    return output;
  }
  display(user, broadcast = false) {
    if (broadcast) {
      this.room.add(`|uhtml|hangman${this.gameNumber}|${this.generateWindow()}`);
    } else {
      user.sendTo(this.room, `|uhtml|hangman${this.gameNumber}|${this.generateWindow()}`);
    }
  }
  update() {
    this.room.uhtmlchange(`hangman${this.gameNumber}`, this.generateWindow());
    if (this.incorrectGuesses === maxMistakes) {
      this.finish();
    }
  }
  end() {
    this.room.uhtmlchange(`hangman${this.gameNumber}`, '<div class="infobox">(The game of hangman was ended.)</div>');
    this.room.add("The game of hangman was ended.");
    this.room.game = null;
  }
  finish() {
    this.room.uhtmlchange(`hangman${this.gameNumber}`, '<div class="infobox">(The game of hangman has ended &ndash; scroll down to see the results)</div>');
    this.room.add(`|html|${this.generateWindow()}`);
    this.room.game = null;
  }
  static save() {
    (0, import_lib.FS)(HANGMAN_FILE).writeUpdate(() => JSON.stringify(hangmanData));
  }
  static getRandom(room, tag) {
    if (!hangmanData[room]) {
      hangmanData[room] = {};
      this.save();
    }
    let phrases = Object.keys(hangmanData[room]);
    if (!phrases.length)
      throw new Chat.ErrorMessage(`The room ${room} has no saved hangman words.`);
    if (tag) {
      tag = toID(tag);
      phrases = phrases.filter((key) => hangmanData[room][key].tags?.map(toID).includes(tag));
      if (!phrases.length) {
        throw new Chat.ErrorMessage(`No terms found with tag ${tag}`);
      }
    }
    const shuffled = import_lib.Utils.randomElement(phrases);
    const entry = hangmanData[room][shuffled];
    return {
      question: shuffled,
      hint: import_lib.Utils.randomElement(entry.hints)
    };
  }
  static validateParams(params) {
    const phrase = params[0].normalize("NFD").trim().replace(/_/g, "\uFF3F");
    if (!phrase.length)
      throw new Chat.ErrorMessage("Enter a valid word");
    if (phrase.length > MAX_HANGMAN_LENGTH) {
      throw new Chat.ErrorMessage(`Phrase must be less than ${MAX_HANGMAN_LENGTH} characters long.`);
    }
    if (phrase.split(" ").some((w) => w.length > MAX_INDIVIDUAL_WORD_LENGTH)) {
      throw new Chat.ErrorMessage(`Each word in the phrase must be less than ${MAX_INDIVIDUAL_WORD_LENGTH} characters long.`);
    }
    if (!/[a-zA-Z]/.test(phrase))
      throw new Chat.ErrorMessage("Word must contain at least one letter.");
    let hint;
    if (params.length > 1) {
      hint = params.slice(1).join(",").trim();
      if (hint.length > MAX_HINT_LENGTH) {
        throw new Chat.ErrorMessage(`Hint must be less than ${MAX_HINT_LENGTH} characters long.`);
      }
    }
    return { phrase, hint };
  }
}
const commands = {
  hangman: {
    create: "new",
    new(target, room, user, connection) {
      room = this.requireRoom();
      target = target.trim();
      const text = this.filter(target);
      if (target !== text)
        return this.errorReply("You are not allowed to use filtered words in hangmans.");
      const params = text.split(",");
      this.checkCan("minigame", null, room);
      if (room.settings.hangmanDisabled)
        return this.errorReply("Hangman is disabled for this room.");
      this.checkChat();
      if (room.game)
        return this.errorReply(`There is already a game of ${room.game.title} in progress in this room.`);
      if (!params)
        return this.errorReply("No word entered.");
      const { phrase, hint } = Hangman.validateParams(params);
      const game = new Hangman(room, user, phrase, hint);
      room.game = game;
      game.display(user, true);
      this.modlog("HANGMAN");
      return this.addModAction(`A game of hangman was started by ${user.name} \u2013 use /guess to play!`);
    },
    createhelp: ["/hangman create [word], [hint] - Makes a new hangman game. Requires: % @ # ~"],
    guess(target, room, user) {
      const word = this.filter(target);
      if (word !== target)
        return this.errorReply(`You may not use filtered words in guesses.`);
      this.parse(`/choose ${target}`);
    },
    guesshelp: [
      `/guess [letter] - Makes a guess for the letter entered.`,
      `/guess [word] - Same as a letter, but guesses an entire word.`
    ],
    stop: "end",
    end(target, room, user) {
      room = this.requireRoom();
      this.checkCan("minigame", null, room);
      this.checkChat();
      const game = this.requireGame(Hangman);
      game.end();
      this.modlog("ENDHANGMAN");
      return this.privateModAction(`The game of hangman was ended by ${user.name}.`);
    },
    endhelp: ["/hangman end - Ends the game of hangman before the man is hanged or word is guessed. Requires: % @ # ~"],
    disable(target, room, user) {
      room = this.requireRoom();
      this.checkCan("gamemanagement", null, room);
      if (room.settings.hangmanDisabled) {
        return this.errorReply("Hangman is already disabled.");
      }
      room.settings.hangmanDisabled = true;
      room.saveSettings();
      return this.sendReply("Hangman has been disabled for this room.");
    },
    enable(target, room, user) {
      room = this.requireRoom();
      this.checkCan("gamemanagement", null, room);
      if (!room.settings.hangmanDisabled) {
        return this.errorReply("Hangman is already enabled.");
      }
      delete room.settings.hangmanDisabled;
      room.saveSettings();
      return this.sendReply("Hangman has been enabled for this room.");
    },
    display(target, room, user) {
      room = this.requireRoom();
      const game = this.requireGame(Hangman);
      if (!this.runBroadcast())
        return;
      room.update();
      game.display(user, this.broadcasting);
    },
    ""(target, room, user) {
      return this.parse("/help hangman");
    },
    random(target, room, user) {
      room = this.requireRoom();
      this.checkCan("mute", null, room);
      if (room.game) {
        throw new Chat.ErrorMessage(`There is already a game of ${room.game.title} running.`);
      }
      target = toID(target);
      const { question, hint } = Hangman.getRandom(room.roomid, target);
      const game = new Hangman(room, user, question, hint, { allowCreator: true });
      room.game = game;
      this.addModAction(`${user.name} started a random game of hangman - use /guess to play!`);
      game.display(user, true);
      this.modlog(`HANGMAN RANDOM`, null, target ? `tag: ${target}` : "");
    },
    addrandom(target, room, user) {
      room = this.requireRoom();
      this.checkCan("mute", null, room);
      if (!hangmanData[room.roomid])
        hangmanData[room.roomid] = {};
      if (!target)
        return this.parse("/help hangman");
      const args = target.split(target.includes("|") ? "|" : ",");
      const { phrase } = Hangman.validateParams(args);
      if (!hangmanData[room.roomid][phrase])
        hangmanData[room.roomid][phrase] = { hints: [] };
      args.shift();
      hangmanData[room.roomid][phrase].hints.push(...args);
      Hangman.save();
      this.privateModAction(`${user.name} added a random hangman with ${Chat.count(args.length, "hints")}.`);
      this.modlog(`HANGMAN ADDRANDOM`, null, `${phrase}: ${args.join(", ")}`);
    },
    rr: "removerandom",
    removerandom(target, room, user) {
      room = this.requireRoom();
      this.checkCan("mute", null, room);
      let [word, ...hints] = target.split(",");
      if (!toID(target) || !word)
        return this.parse("/help hangman");
      for (const [i, hint] of hints.entries()) {
        if (hint.startsWith("room:")) {
          const newID = hint.slice(5);
          const targetRoom = Rooms.search(newID);
          if (!targetRoom) {
            return this.errorReply(`Invalid room: ${newID}`);
          }
          this.room = targetRoom;
          room = targetRoom;
          hints.splice(i, 1);
        }
      }
      if (!hangmanData[room.roomid]) {
        return this.errorReply("There are no hangman words for this room.");
      }
      const roomKeys = Object.keys(hangmanData[room.roomid]);
      const roomKeyIDs = roomKeys.map(toID);
      const index = roomKeyIDs.indexOf(toID(word));
      if (index < 0) {
        return this.errorReply(`That word is not a saved hangman.`);
      }
      word = roomKeys[index];
      hints = hints.map(toID);
      if (!hints.length) {
        delete hangmanData[room.roomid][word];
        this.privateModAction(`${user.name} deleted the hangman entry for '${word}'`);
        this.modlog(`HANGMAN REMOVERANDOM`, null, word);
      } else {
        hangmanData[room.roomid][word].hints = hangmanData[room.roomid][word].hints.filter((item) => !hints.includes(toID(item)));
        if (!hangmanData[room.roomid][word].hints.length) {
          delete hangmanData[room.roomid][word];
        }
        this.privateModAction(`${user.name} deleted ${Chat.count(hints, "hints")} for the hangman term '${word}'`);
        this.modlog(`HANGMAN REMOVERANDOM`, null, `${word}: ${hints.join(", ")}`);
      }
      this.refreshPage(`hangman-${room.roomid}`);
      Hangman.save();
    },
    addtag(target, room, user) {
      room = this.requireRoom();
      this.checkCan("mute", null, room);
      let [term, ...tags] = target.split(",");
      term = term.trim();
      tags = tags.map((i) => toID(i)).filter(Boolean);
      if (!term || !tags?.length) {
        return this.parse("/help hangman");
      }
      if (!hangmanData[room.roomid]) {
        hangmanData[room.roomid] = {};
      }
      if (!hangmanData[room.roomid][term]) {
        return this.errorReply(`Term ${term} not found.`);
      }
      if (!hangmanData[room.roomid][term].tags)
        hangmanData[room.roomid][term].tags = [];
      for (const [i, tag] of tags.entries()) {
        if (hangmanData[room.roomid][term].tags.includes(tag)) {
          this.errorReply(`The tag ${tag} is already on the term ${term} and has been skipped.`);
          tags.splice(i, 1);
        }
      }
      if (!tags.length) {
        this.errorReply(`Specify at least one valid tag.`);
        return this.parse(`/help hangman`);
      }
      hangmanData[room.roomid][term].tags.push(...tags);
      Hangman.save();
      this.privateModAction(`${user.name} added ${Chat.count(tags, "tags")} to the hangman term ${term}`);
      this.modlog(`HANGMAN ADDTAG`, null, `${term}: ${tags.map(import_lib.Utils.escapeHTML).join(", ")}`);
      this.refreshPage(`hangman-${room.roomid}`);
    },
    untag(target, room, user) {
      room = this.requireRoom();
      this.checkCan("mute", null, room);
      if (!toID(target)) {
        return this.parse(`/help hangman`);
      }
      let [term, ...tags] = target.split(",");
      tags = tags.map((i) => toID(i)).filter(Boolean);
      if (!term || !tags) {
        return this.parse("/help hangman");
      }
      if (!hangmanData[room.roomid]) {
        return this.errorReply(`This room has no hangman terms.`);
      }
      if (!hangmanData[room.roomid][term]) {
        return this.errorReply(`That term was not found.`);
      }
      if (!hangmanData[room.roomid][term].tags) {
        return this.errorReply(`That term has no tags.`);
      }
      if (tags.length) {
        this.privateModAction(`${user.name} removed ${Chat.count(tags, "tags")} from the hangman term ${term}`);
        this.modlog(`HANGMAN UNTAG`, null, `${term}: ${tags.map(import_lib.Utils.escapeHTML).join(", ")}`);
        hangmanData[room.roomid][term].tags = hangmanData[room.roomid][term].tags?.filter((t) => !tags.includes(t));
      } else {
        this.privateModAction(`${user.name} removed all tags from the hangman term ${term}`);
        this.modlog(`HANGMAN UNTAG`, null, `${term}`);
        hangmanData[room.roomid][term].tags = [];
      }
      if (!hangmanData[room.roomid][term].tags.length) {
        delete hangmanData[room.roomid][term].tags;
      }
      Hangman.save();
      this.refreshPage(`hangman-${room.roomid}`);
    },
    view: "terms",
    terms(target, room, user) {
      room = this.requireRoom();
      return this.parse(`/j view-hangman-${target || room.roomid}`);
    }
  },
  hangmanhelp: [
    `/hangman allows users to play the popular game hangman in PS rooms.`,
    `Accepts the following commands:`,
    `/hangman create [word], [hint] - Makes a new hangman game. Requires: % @ # ~`,
    `/hangman guess [letter] - Makes a guess for the letter entered.`,
    `/hangman guess [word] - Same as a letter, but guesses an entire word.`,
    `/hangman display - Displays the game.`,
    `/hangman end - Ends the game of hangman before the man is hanged or word is guessed. Requires: % @ # ~`,
    `/hangman [enable/disable] - Enables or disables hangman from being started in a room. Requires: # ~`,
    `/hangman random [tag]- Runs a random hangman, if the room has any added. `,
    `If a tag is given, randomizes from only terms with those tags. Requires: % @ # ~`,
    `/hangman addrandom [word], [...hints] - Adds an entry for [word] with the [hints] provided to the room's hangman pool. Requires: % @ # ~`,
    `/hangman removerandom [word][, hints] - Removes data from the hangman entry for [word]. If hints are given, removes only those hints. Otherwise it removes the entire entry. Requires: % @ ~ #`,
    `/hangman addtag [word], [...tags] - Adds tags to the hangman term matching [word]. Requires: % @ ~ #`,
    `/hangman untag [term][, ...tags] - Removes tags from the hangman [term]. If tags are given, removes only those tags. Requires: % @ # * `,
    `/hangman terms - Displays all random hangman in a room. Requires: % @ # ~`
  ]
};
const pages = {
  hangman(args, user) {
    const room = this.requireRoom();
    this.title = `[Hangman]`;
    this.checkCan("mute", null, room);
    let buf = `<div class="pad"><button style="float:right;" class="button" name="send" value="/join view-hangman-${room.roomid}"><i class="fa fa-refresh"></i> Refresh</button>`;
    buf += `<div class="pad"><h2>Hangman entries on ${room.title}</h2>`;
    const roomTerms = hangmanData[room.roomid];
    if (!roomTerms) {
      return this.errorReply(`No hangman terms found for ${room.title}.`);
    }
    for (const t in roomTerms) {
      buf += `<div class="infobox">`;
      buf += `<h3>${t}</h3><hr />`;
      if (user.can("mute", null, room, "hangman addrandom")) {
        buf += `<strong>Hints:</strong> `;
        buf += roomTerms[t].hints.map(
          (hint) => `${hint} <button class="button" name="send" value="/msgroom ${room.roomid}, /hangman rr ${t},${hint}" aria-label="Delete"><i class="fa fa-trash"></i></button>`
        ).join(", ");
        buf += `<button style="float:right;" class="button" name="send" value="/msgroom ${room.roomid}, /hangman rr ${t}"><i class="fa fa-trash"></i> Delete all terms</button>`;
        if (roomTerms[t].tags) {
          buf += `<br /><strong>Tags: </strong> `;
          buf += roomTerms[t].tags?.map(
            (tag) => `${tag} <button class="button" name="send" value="/msgroom ${room.roomid}, /hangman untag ${t},${tag}" aria-label="Delete"><i class="fa fa-trash"></i></button>`
          ).join(", ");
          buf += `<button style="float:right;" class="button" name="send" value="/msgroom ${room.roomid}, /hangman untag ${t}"><i class="fa fa-trash"></i> Delete all tags</button>`;
        }
      }
      buf += `</div><br />`;
    }
    buf += `</div>`;
    return buf;
  }
};
const roomSettings = (room) => ({
  label: "Hangman",
  permission: "editroom",
  options: [
    [`disabled`, room.settings.hangmanDisabled || "hangman disable"],
    [`enabled`, !room.settings.hangmanDisabled || "hangman enable"]
  ]
});
//# sourceMappingURL=hangman.js.map