";
if (hasThousandArrows) {
buffer += " Thousand Arrows has neutral type effectiveness on Flying-type Pok\xE9mon if not already smacked down.";
}
this.sendReplyBox(`Coverage for ${sources.join(" + ")}: ${buffer}`);
}
},
coveragehelp: [
`/coverage [move 1], [move 2] ... - Provides the best effectiveness match-up against all defending types for given moves or attacking types`,
`!coverage [move 1], [move 2] ... - Shows this information to everyone.`,
`Adding the parameter 'all' or 'table' will display the information with a table of all type combinations.`
],
statcalc(target, room, user) {
if (!target)
return this.parse("/help statcalc");
if (!this.runBroadcast())
return;
const targets = target.split(" ");
let lvlSet = false;
let natureSet = false;
let ivSet = false;
let evSet = false;
let baseSet = false;
let modSet = false;
let realSet = false;
let pokemon;
let useStat = "";
let level = 100;
let calcHP = false;
let nature = 1;
let iv = 31;
let ev = 252;
let baseStat = -1;
let modifier = 0;
let positiveMod = true;
let realStat = 0;
for (const arg of targets) {
const lowercase = arg.toLowerCase();
if (!lvlSet) {
if (lowercase === "lc") {
level = 5;
lvlSet = true;
continue;
} else if (lowercase === "vgc") {
level = 50;
lvlSet = true;
continue;
} else if (lowercase.startsWith("lv") || lowercase.startsWith("level")) {
level = parseInt(arg.replace(/\D/g, ""));
lvlSet = true;
if (isNaN(level)) {
return this.sendReplyBox("Invalid value for level: " + import_lib.Utils.escapeHTML(arg));
}
if (level < 1 || level > 9999) {
return this.sendReplyBox("Level should be between 1 and 9999.");
}
continue;
}
}
if (!useStat) {
switch (lowercase) {
case "hp":
case "hitpoints":
calcHP = true;
useStat = "hp";
continue;
case "atk":
case "attack":
useStat = "atk";
continue;
case "def":
case "defense":
useStat = "def";
continue;
case "spa":
useStat = "spa";
continue;
case "spd":
case "sdef":
useStat = "spd";
continue;
case "spe":
case "speed":
useStat = "spe";
continue;
}
}
if (!natureSet) {
if (lowercase === "boosting" || lowercase === "positive") {
nature = 1.1;
natureSet = true;
continue;
} else if (lowercase === "negative" || lowercase === "inhibiting") {
nature = 0.9;
natureSet = true;
continue;
} else if (lowercase === "neutral") {
continue;
}
}
if (!pokemon) {
const testPoke = Dex.species.get(arg);
if (testPoke.exists) {
pokemon = testPoke.baseStats;
baseSet = true;
continue;
}
}
if (!ivSet) {
if (lowercase.endsWith("iv") || lowercase.endsWith("ivs")) {
iv = parseInt(arg);
ivSet = true;
if (isNaN(iv)) {
return this.sendReplyBox("Invalid value for IVs: " + import_lib.Utils.escapeHTML(arg));
}
continue;
}
}
if (!evSet) {
if (lowercase === "invested" || lowercase === "max") {
evSet = true;
if (lowercase === "max" && !natureSet) {
nature = 1.1;
natureSet = true;
}
} else if (lowercase === "uninvested") {
ev = 0;
evSet = true;
} else if (lowercase.endsWith("ev") || lowercase.endsWith("evs") || lowercase.endsWith("+") || lowercase.endsWith("-")) {
ev = parseInt(arg);
evSet = true;
if (isNaN(ev)) {
return this.sendReplyBox("Invalid value for EVs: " + import_lib.Utils.escapeHTML(arg));
}
if (ev > 255 || ev < 0) {
return this.sendReplyBox("The amount of EVs should be between 0 and 255.");
}
if (!natureSet) {
if (arg.includes("+")) {
nature = 1.1;
natureSet = true;
} else if (arg.includes("-")) {
nature = 0.9;
natureSet = true;
}
}
continue;
}
}
if (!modSet) {
if (["band", "scarf", "specs"].includes(arg)) {
modifier = 1;
modSet = true;
} else if (arg.startsWith("+")) {
modifier = parseInt(arg.charAt(1));
modSet = true;
} else if (arg.startsWith("-")) {
positiveMod = false;
modifier = parseInt(arg.charAt(1));
modSet = true;
}
if (isNaN(modifier)) {
return this.sendReplyBox("Invalid value for modifier: " + import_lib.Utils.escapeHTML(String(modifier)));
}
if (modifier > 6) {
return this.sendReplyBox("Modifier should be a number between -6 and +6");
}
if (modSet)
continue;
}
const tempStat = parseInt(arg);
if (!realSet) {
if (lowercase.endsWith("real")) {
realStat = tempStat;
realSet = true;
if (isNaN(realStat)) {
return this.sendReplyBox("Invalid value for target real stat: " + import_lib.Utils.escapeHTML(arg));
}
if (realStat < 0) {
return this.sendReplyBox("The target real stat must be greater than 0.");
}
continue;
}
}
if (!isNaN(tempStat) && !baseSet && tempStat > 0 && tempStat < 256) {
baseStat = tempStat;
baseSet = true;
}
}
if (pokemon) {
if (useStat) {
baseStat = pokemon[useStat];
} else {
return this.sendReplyBox("No stat found.");
}
}
if (realSet) {
if (!baseSet) {
if (calcHP) {
baseStat = Math.ceil((100 * realStat - 10 - level * (Math.floor(ev / 4) + iv + 100)) / (2 * level));
} else {
if (!positiveMod) {
realStat *= (2 + modifier) / 2;
} else {
realStat *= 2 / (2 + modifier);
}
baseStat = Math.ceil(
(100 * Math.ceil(realStat) - nature * (level * (Math.floor(ev / 4) + iv) + 500)) / (2 * level * nature)
);
}
if (baseStat < 0) {
return this.sendReplyBox("No valid value for base stat possible with given parameters.");
}
} else if (!evSet) {
if (calcHP) {
ev = Math.ceil(100 * (realStat - 10) / level - 2 * (baseStat + 50));
} else {
if (!positiveMod) {
realStat *= (2 + modifier) / 2;
} else {
realStat *= 2 / (2 + modifier);
}
ev = Math.ceil(-1 * (2 * (nature * (baseStat * level + 250) - 50 * Math.ceil(realStat))) / (level * nature));
}
ev -= 31;
if (ev < 0)
iv += ev;
ev *= 4;
if (iv < 0 || ev > 255) {
return this.sendReplyBox(`No valid EV/IV combination possible with given parameters. Maybe try a different nature?${ev}`);
}
} else {
return this.sendReplyBox("Too many parameters given; nothing to calculate.");
}
} else if (baseStat < 0) {
return this.sendReplyBox("No valid value for base stat found.");
}
let output;
if (calcHP) {
output = (iv + 2 * baseStat + Math.floor(ev / 4) + 100) * level / 100 + 10;
} else {
output = Math.floor(nature * Math.floor((iv + 2 * baseStat + Math.floor(ev / 4)) * level / 100 + 5));
if (positiveMod) {
output *= (2 + modifier) / 2;
} else {
output *= 2 / (2 + modifier);
}
}
return this.sendReplyBox(`Base ${baseStat} ${calcHP ? " HP " : " "}at level ${level} with ${iv} IVs, ${ev}${nature === 1.1 ? "+" : nature === 0.9 ? "-" : ""} EVs${modifier > 0 && !calcHP ? ` at ${positiveMod ? "+" : "-"}${modifier}` : ""}: ${Math.floor(output)}.`);
},
statcalchelp: [
`/statcalc [level] [base stat] [IVs] [nature] [EVs] [modifier] (only base stat is required) - Calculates what the actual stat of a Pok\xE9mon is with the given parameters. For example, '/statcalc lv50 100 30iv positive 252ev scarf' calculates the speed of a base 100 scarfer with HP Ice in Battle Spot, and '/statcalc uninvested 90 neutral' calculates the attack of an uninvested Crobat.`,
`!statcalc [level] [base stat] [IVs] [nature] [EVs] [modifier] (only base stat is required) - Shows this information to everyone.`,
`Inputting 'hp' as an argument makes it use the formula for HP. Instead of giving nature, '+' and '-' can be appended to the EV amount (e.g. 252+ev) to signify a boosting or inhibiting nature.`,
`An actual stat can be given in place of a base stat or EVs. In this case, the minumum base stat or EVs necessary to have that real stat with the given parameters will be determined. For example, '/statcalc 502real 252+ +1' calculates the minimum base speed necessary for a positive natured fully invested scarfer to outspeed`
],
/*********************************************************
* Informational commands
*********************************************************/
uptime(target, room, user) {
if (!this.runBroadcast())
return;
const uptime = process.uptime();
let uptimeText;
if (uptime > 24 * 60 * 60) {
const uptimeDays = Math.floor(uptime / (24 * 60 * 60));
uptimeText = `${uptimeDays} ${uptimeDays === 1 ? "day" : "days"}`;
const uptimeHours = Math.floor(uptime / (60 * 60)) - uptimeDays * 24;
if (uptimeHours)
uptimeText += `, ${uptimeHours} ${uptimeHours === 1 ? "hour" : "hours"}`;
} else {
uptimeText = Chat.toDurationString(uptime * 1e3);
}
this.sendReplyBox(`Uptime: ${uptimeText}`);
},
uptimehelp: [`/uptime - Shows how long the server has been online for.`],
st: "servertime",
servertime(target, room, user) {
if (!this.runBroadcast())
return;
const servertime = new Date();
this.sendReplyBox(`Server time: ${servertime.toLocaleString()}`);
},
servertimehelp: [`/servertime - Shows the current time where the server is.`],
groups(target, room, user) {
if (!this.runBroadcast())
return;
target = toID(target);
const showRoom = target !== "global";
const showGlobal = target !== "room" && target !== "rooms";
const roomRanks = [
`Room ranks`,
`^ Prize Winner - They don't have any powers beyond a symbol.`,
`+ Voice - They can use ! commands like !groups`,
`% Driver - The above, and they can mute and warn`,
`@ Moderator - The above, and they can room ban users`,
`* Bot - An automated account that can mute, warn, and use HTML`,
`# Room Owner - They are leaders of the room and can almost totally control it`
];
const globalRanks = [
`Global ranks`,
`+ Global Voice - They can use ! commands like !groups`,
`% Global Driver - Like Voice, and they can lock users and check for alts`,
`@ Global Moderator - The above, and they can globally ban users`,
`* Global Bot - An automated account that can use HTML anywhere`,
`~ Global Administrator - They can do anything, like change what this message says and promote users globally`
];
this.sendReplyBox(
(showRoom ? roomRanks.map((str) => this.tr(str)).join(" ") : ``) + (showRoom && showGlobal ? `
` : ``) + (showGlobal ? globalRanks.map((str) => this.tr(str)).join(" ") : ``)
);
},
groupshelp: [
`/groups - Explains what the symbols (like % and @) before people's names mean.`,
`/groups [global|room] - Explains only global or room symbols.`,
`!groups - Shows everyone that information. Requires: + % @ # ~`
],
punishments(target, room, user) {
if (!this.runBroadcast())
return;
target = toID(target);
const showRoom = target !== "global";
const showGlobal = target !== "room" && target !== "rooms";
const roomPunishments = [
`Room punishments:`,
`warn - Displays a popup with the rules.`,
`mute - Mutes a user (makes them unable to talk) for 7 minutes.`,
`hourmute - Mutes a user for 60 minutes.`,
`ban - Bans a user (makes them unable to join the room) for 2 days.`,
`weekban - Bans a user from the room for a week.`,
`blacklist - Bans a user for a year.`
];
const globalPunishments = [
`Global punishments:`,
`lock - Locks a user (makes them unable to talk in any rooms or PM non-staff) for 2 days.`,
`weeklock - Locks a user for a week.`,
`namelock - Locks a user and prevents them from having a username for 2 days.`,
`globalban - Globally bans (makes them unable to connect and play games) for a week.`
];
const indefinitePunishments = [
this.tr`Indefinite global punishments:`,
this.tr`permalock - Issued for repeated instances of bad behavior and is rarely the result of a single action. ` + this.tr`These can be appealed in the Discipline Appeal` + this.tr` forum after at least 3 months without incident.`,
this.tr`permaban - Unappealable global ban typically issued for the most severe cases of offensive/inappropriate behavior.`
];
this.sendReplyBox(
(showRoom ? roomPunishments.map((str) => this.tr(str)).join(" ") : ``) + (showRoom && showGlobal ? `
${indefinitePunishments.join(" ")}` : ``)
);
},
punishmentshelp: [
`/punishments - Explains punishments.`,
`!punishments - Show everyone that information. Requires: + % @ # ~`
],
repo: "opensource",
repository: "opensource",
git: "opensource",
opensource(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(
`Pokémon Showdown is open source: - Language: mostly TypeScript, a little PHP - What's new? - Server source code - Client source code - Dex source code - Login server source code`
);
},
opensourcehelp: [
`/opensource - Links to PS's source code repository.`,
`!opensource - Show everyone that information. Requires: + % @ # ~`
],
staff(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(`Pokémon Showdown Staff List`);
},
staffhelp: [`/staff - View the staff list.`],
forums(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(`Pokémon Showdown Forums`);
},
forumshelp: [`/forums - Links to the PS forums.`],
privacypolicy(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox([
this.tr`- We log PMs so you can report them - staff can't look at them without permission unless there's a law enforcement reason.`,
this.tr`- We log IPs to enforce bans and mutes.`,
this.tr`- We use cookies to save your login info and teams, and for Google Analytics and AdSense.`,
this.tr`- For more information, you can read our full privacy policy.`
].join(` `));
},
privacypolicyhelp: [`/privacypolicy - Displays PS's privacy policy.`],
suggest: "suggestions",
suggestion: "suggestions",
suggestions(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(`Make a suggestion for Pokémon Showdown`);
},
suggestionshelp: [`/suggestions - Links to the place to make suggestions for Pokemon Showdown.`],
bugreport: "bugs",
bugreports: "bugs",
bugs(target, room, user) {
if (!this.runBroadcast())
return;
if (room?.battle) {
this.sendReplyBox(`
`);
} else {
this.sendReplyBox(
`Have a replay showcasing a bug on Pokémon Showdown? - Questions - Bug Reports (ask in Help before posting if you're unsure)`
);
}
},
bugshelp: [`/bugs - Links to the various bug reporting services.`],
optionbutton: "optionsbutton",
optionsbutton(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(` (The Sound and Options buttons are at the top right, next to your username)`);
},
optionsbuttonhelp: [`/optionsbutton - Provides a button to the Options menu.`],
soundsbutton: "soundbutton",
volumebutton: "soundbutton",
soundbutton(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(` (The Sound and Options buttons are at the top right, next to your username)`);
},
soundbuttonhelp: [`/soundbutton - Provides a button to the Sounds menu.`],
introduction: "intro",
intro(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(
`New to competitive Pokémon? - Beginner's Guide to Pokémon Showdown - An introduction to competitive Pokémon - What do 'OU', 'UU', etc mean? - What are the rules for each format? - What is 'Sleep Clause' and other clauses? - Next Steps for Competitive Battling`
);
},
introhelp: [
`/intro - Provides an introduction to competitive Pok\xE9mon.`,
`!intro - Show everyone that information. Requires: + % @ # ~`
],
mentoring: "smogintro",
smogonintro: "smogintro",
smogintro(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(
`Welcome to Smogon's official simulator! The Information & Resources forum can help you get integrated into the community. - Useful Smogon Info - Tiering FAQ `
);
},
smogintrohelp: [`/smogintro - Provides an introduction to Smogon.`],
bsscalc: "calc",
calculator: "calc",
cantsaycalc: "calc",
damagecalculator: "calc",
damagecalc: "calc",
honkalculator: "calc",
honkocalc: "calc",
randomscalc: "calc",
randbatscalc: "calc",
rcalc: "calc",
calc(target, room, user, connection, cmd) {
if (cmd === "calc" && target)
return this.run("calculate");
if (!this.runBroadcast())
return;
const DEFAULT_CALC_COMMANDS = ["honkalculator", "honkocalc"];
const RANDOMS_CALC_COMMANDS = ["randomscalc", "randbatscalc", "rcalc"];
const BATTLESPOT_CALC_COMMANDS = ["bsscalc", "cantsaycalc"];
const SUPPORTED_BATTLESPOT_FORMATS = [
"gen5gbusingles",
"gen5gbudoubles",
"gen6battlespotsingles",
"gen6battlespotdoubles",
"gen6battlespottriples",
"gen7battlespotsingles",
"gen7battlespotdoubles",
"gen7bssfactory"
];
const isRandomBattle = room?.battle && (room.battle.format.endsWith("randombattle") || room.battle.format.endsWith("randomdoublesbattle"));
const isBattleSpotBattle = room?.battle && (SUPPORTED_BATTLESPOT_FORMATS.includes(room.battle.format) || room.battle.format.includes("battlespotspecial"));
const { dex } = this.extractFormat(room?.battle?.format);
if (RANDOMS_CALC_COMMANDS.includes(cmd) || isRandomBattle && !DEFAULT_CALC_COMMANDS.includes(cmd) && !BATTLESPOT_CALC_COMMANDS.includes(cmd)) {
return this.sendReplyBox(
`Random Battles damage calculator. (Courtesy of dhelmise & jetou) - Random Battles Damage Calculator`
);
}
if (BATTLESPOT_CALC_COMMANDS.includes(cmd) || isBattleSpotBattle && !DEFAULT_CALC_COMMANDS.includes(cmd)) {
return this.sendReplyBox(
`Battle Spot damage calculator. (Courtesy of cant say & LegoFigure11) - Battle Spot Damage Calculator`
);
}
this.sendReplyBox(
`Pokémon Showdown! damage calculator. (Courtesy of Honko, Austin, dhelmise, & jetou) - Damage Calculator`
);
},
calchelp: [
`/calc - Provides a link to a damage calculator`,
`/rcalc - Provides a link to the random battles damage calculator`,
`/bsscalc - Provides a link to the Battle Spot damage calculator`,
`!calc - Shows everyone a link to a damage calculator. Requires: + % @ # ~`
],
capintro: "cap",
cap(target, room, user) {
if (!this.runBroadcast())
return;
this.sendReplyBox(
`An introduction to the Create-A-Pokémon project: - CAP project website and description - CAP project discussion forum - What Pokémon have been made? - Talk about the metagame here - Sample SV CAP teams`
);
},
caphelp: [
`/cap - Provides an introduction to the Create-A-Pok\xE9mon project.`,
`!cap - Show everyone that information. Requires: + % @ # ~`
],
battlerules(target, room, user) {
return this.parse(`/join view-battlerules`);
},
battleruleshelp: [
`/battlerules - Provides information on the rules that can be added to tournament and challenge battles.`
],
banlists: "formathelp",
tier: "formathelp",
tiers: "formathelp",
formats: "formathelp",
tiershelp: "formathelp",
formatshelp: "formathelp",
viewbanlist: "formathelp",
async formathelp(target, room, user, connection, cmd) {
if (!target && this.runBroadcast()) {
return this.sendReplyBox(
`- Smogon Tiers - Tiering FAQ - The banlists for each tier
Type /formatshelp [format|section] to get details about an available format or group of formats.`
);
}
const isOMSearch = cmd === "om" || cmd === "othermetas";
let targetId = toID(target);
if (targetId === "ladder")
targetId = "search";
if (targetId === "all")
targetId = "";
const { totalMatches, sections } = findFormats(targetId, isOMSearch);
if (!totalMatches)
return this.errorReply("No matched formats found.");
const format = totalMatches === 1 ? Dex.formats.get(Object.values(sections)[0].formats[0]) : null;
if (!this.runBroadcast(`!formathelp ${format ? format.id : target}`))
return;
if (format) {
const rules = [];
let rulesetHtml = "";
if (["Format", "Rule", "ValidatorRule"].includes(format.effectType)) {
if (format.ruleset?.length) {
rules.push(`Ruleset - ${import_lib.Utils.escapeHTML(format.ruleset.join(", "))}`);
}
if (format.banlist?.length) {
rules.push(`Bans - ${import_lib.Utils.escapeHTML(format.banlist.join(", "))}`);
}
if (format.unbanlist?.length) {
rules.push(`Unbans - ${import_lib.Utils.escapeHTML(format.unbanlist.join(", "))}`);
}
if (format.restricted?.length) {
rules.push(`Restricted - ${import_lib.Utils.escapeHTML(format.restricted.join(", "))}`);
}
if (rules.length > 0) {
rulesetHtml = `Banlist/Ruleset${rules.join(" ")}`;
} else {
rulesetHtml = `No ruleset found for ${format.name}`;
}
}
const formatDesc = format.desc || "";
const descHtml = [];
const data = await getFormatResources(format.id);
if (data) {
for (const { resource_name, url } of data.resources) {
let rn = resource_name;
rn = rn.replace(/ thread$/gi, "");
rn = rn.replace(/Pokemon Showdown/gi, "PS");
rn = rn.split(" ").map((x) => x[0].toUpperCase() + x.substr(1)).join(" ");
descHtml.push(`• ${rn}`);
}
} else if (format.threads?.length) {
descHtml.push(...format.threads);
} else {
const genID = ["rb", "gs", "rs", "dp", "bw", "xy", "sm", "ss", "sv"];
descHtml.push(`This format has no resources linked on its Smogon Dex page. Please contact a C&C Leader to resolve this. Alternatively, if this format can't have a page on the Smogon Dex, message dhelmise. `);
}
return this.sendReplyBox(`
`];
for (const sectionId in sections) {
buf.push(import_lib.Utils.html`
${sections[sectionId].name}
`);
for (const section of sections[sectionId].formats) {
const subformat = Dex.formats.get(section);
const nameHTML = import_lib.Utils.escapeHTML(subformat.name);
const desc = subformat.desc ? [subformat.desc] : [];
const data = await getFormatResources(subformat.id);
if (data) {
for (const { resource_name, url } of data.resources) {
desc.push(`• ${resource_name}`);
}
}
const descHTML = desc.length ? desc.join(" ") : "—";
buf.push(`
${nameHTML}
${descHTML}
`);
}
}
buf.push(`
`);
return this.sendReply(`|raw|${buf.join("")}`);
},
formathelphelp: [
`/formathelp [format] - Provides information on the given [format].`,
`If no format is given, provides information on how tiers work.`
],
roomhelp(target, room, user) {
room = this.requireRoom();
this.checkBroadcast(false, "!htmlbox");
if (this.broadcastMessage)
this.checkCan("declare", null, room);
if (!this.runBroadcast(false, "!htmlbox"))
return;
const strings = [
[
`Room drivers (%) can use:`,
`- /warn OR /k username: warn a user and show the Pokémon Showdown rules`,
`- /mute OR /m username: 7 minute mute`,
`- /hourmute OR /hm username: 60 minute mute`,
`- /unmute username: unmute`,
`- /hidetext username: hide a user's messages from the room`,
`- /announce OR /wall message: make an announcement`,
`- /modlog username: search the moderator log of the room`,
`- /modnote note: add a moderator note that can be read through modlog`,
`- !show [image or youtube link]: display given media in chat.`
],
[
`Room moderators (@) can also use:`,
`- /roomban OR /rb username: ban user from the room`,
`- /roomunban username: unban user from the room`,
`- /roomvoice username: appoint a room voice`,
`- /roomdevoice username: remove a room voice`,
`- /staffintro intro: set the staff introduction that will be displayed for all staff joining the room`,
`- /roomsettings: change a variety of room settings, namely modchat`
],
[
`Room owners (#) can also use:`,
`- /roomintro intro: set the room introduction that will be displayed for all users joining the room`,
`- /rules rules link: set the room rules link seen when using /rules`,
`- /roommod, /roomdriver username: appoint a room moderator/driver`,
`- /roomdemod, /roomdedriver username: remove a room moderator/driver`,
`- /roomdeauth username: remove all room auth from a user`,
`- /declare message: make a large blue declaration to the room`,
`- !htmlbox HTML code: broadcast a box of HTML code to the room`,
`- /roomsettings: change a variety of room settings, including modchat, capsfilter, etc`
],
[
`More detailed help can be found in the roomauth guide`
],
[
`Tournament Help:`,
`- /tour create format, elimination: create a new single elimination tournament in the current room.`,
`- /tour create format, roundrobin: create a new round robin tournament in the current room.`,
`- /tour end: forcibly end the tournament in the current room`,
`- /tour start: start the tournament in the current room`,
`- /tour banlist [pokemon], [talent], [...]: ban moves, abilities, Pok\xE9mon or items from being used in a tournament (it must be created first)`
],
[
`More detailed help can be found in the tournaments guide`
]
];
this.sendReplyBox(
strings.map((par) => par.map((string) => this.tr(string)).join(" ")).join("
")
);
},
restarthelp(target, room, user) {
if (!Rooms.global.lockdown)
this.checkCan("lockdown");
if (!this.runBroadcast())
return;
this.sendReplyBox(
`The server is restarting. Things to know: - We wait a few minutes before restarting so people can finish up their battles - The restart itself will take around 0.6 seconds - Your ladder ranking and teams will not change - We are restarting to update Pokémon Showdown to a newer version`
);
},
rule: "rules",
roomrules: "rules",
rules(target, room, user, connection, cmd) {
if (!target) {
if (!this.runBroadcast())
return;
this.sendReplyBox(
`${room ? this.tr`Please follow the rules:` + " " : ``}${room?.settings.rulesLink ? import_lib.Utils.html`- ${this.tr`${room.title} room rules`} ` : ``}- ${this.tr`Global Rules`}`
);
return;
}
if (!room) {
return this.errorReply(`This is not a room you can set the rules of.`);
}
const possibleRoom = Rooms.search(toID(target));
const { totalMatches: formatMatches } = findFormats(toID(target));
if (formatMatches && possibleRoom && cmd !== "roomrules") {
this.errorReply(`'${target}' is both a room and a tier. `);
this.errorReply(`If you were looking for rules of that room, use /roomrules [room].`);
this.errorReply(`Otherwise, use /tier [tiername].`);
return;
}
if (possibleRoom) {
const rulesLink = possibleRoom.settings.rulesLink;
return this.sendReplyBox(
`${possibleRoom.title}'s rules: ${rulesLink ? import_lib.Utils.html`- ${this.tr`${possibleRoom.title} room rules`} ` : `None set.`}`
);
}
if (formatMatches > 0 && cmd !== "roomrules") {
return this.parse(`/tier ${target}`);
}
this.checkCan("editroom", null, room);
if (target.length > 150) {
return this.errorReply(`Error: Room rules link is too long (must be under 150 characters). You can use a URL shortener to shorten the link.`);
}
target = target.trim();
if (target === "delete" || target === "remove") {
if (!room.settings.rulesLink)
return this.errorReply(`This room does not have rules set to remove.`);
delete room.settings.rulesLink;
this.privateModAction(`${user.name} has removed the room rules link.`);
this.modlog("RULES", null, `removed room rules link`);
} else {
room.settings.rulesLink = target;
this.privateModAction(`${user.name} changed the room rules link to: ${target}`);
this.modlog("RULES", null, `changed link to: ${target}`);
}
room.saveSettings();
},
ruleshelp: [
`/rules - Show links to room rules and global rules.`,
`!rules - Show everyone links to room rules and global rules. Requires: + % @ # ~`,
`/rules [url] - Change the room rules URL. Requires: # ~`,
`/rules remove - Removes a room rules URL. Requires: # ~`
],
faq(target, room, user) {
if (!this.runBroadcast())
return;
target = toID(target);
const showAll = target === "all";
if (showAll && this.broadcasting) {
return this.sendReplyBox(this.tr`You cannot broadcast all FAQs at once.`);
}
const buffer = [];
if (showAll || target === "staff") {
buffer.push(`${this.tr`Staff FAQ`}`);
}
if (showAll || target === "autoconfirmed" || target === "ac") {
buffer.push(this.tr`A user is autoconfirmed when they have won at least one rated battle and have been registered for one week or longer. In order to prevent spamming and trolling, most chatrooms only allow autoconfirmed users to chat. If you are not autoconfirmed, you can politely PM a staff member (staff have %, @, or # in front of their username) in the room you would like to chat and ask them to disable modchat. However, staff are not obligated to disable modchat.`);
if (!this.broadcasting)
void this.parse(`/regtime`);
}
if (showAll || target === "ladder" || target === "ladderhelp" || target === "decay") {
buffer.push(`${this.tr`How the ladder works`}`);
}
if (showAll || target === "tiering" || target === "tiers" || target === "tier") {
buffer.push(`${this.tr`Tiering FAQ`}`);
}
if (showAll || ["badge", "badges", "badgeholders"].includes(target)) {
buffer.push(`${this.tr`Badge FAQ`}`);
}
if (showAll || target === "rng") {
buffer.push(`${this.tr`Common misconceptions about our RNG`}`);
}
if (showAll || ["tournaments", "tournament", "tours", "tour"].includes(target)) {
buffer.push(this.tr`To join a room tournament, click the Join! button or type the command /tour join in the room's chat. You can check if your team is legal for the tournament by clicking the Validate button once you've joined and selected a team. To battle your opponent in the tournament, click the Ready! button when it appears. There are two different types of room tournaments: elimination (if a user loses more than a certain number of times, they are eliminated) and round robin (all users play against each other, and the user with the most wins is the winner).`);
}
if (showAll || ["vpn", "proxy"].includes(target)) {
buffer.push(`${this.tr`Proxy lock help`}`);
}
if (showAll || ["ca", "customavatar", "customavatars"].includes(target)) {
buffer.push(this.tr`Custom avatars are given to Global Staff members, contributors (coders and spriters) to Pokemon Showdown, and Smogon badgeholders at the discretion of the PS! Administrators. They are also sometimes given out as rewards for major events such as PSPL (Pokemon Showdown Premier League). If you're curious, you can view the entire list of custom avatars.`);
}
if (showAll || ["privacy", "private"].includes(target)) {
buffer.push(`${this.tr`Pokémon Showdown privacy policy`}`);
}
if (showAll || ["lostpassword", "password", "lostpass"].includes(target)) {
buffer.push(`If you need your Pok\xE9mon Showdown password reset, you can fill out a ${this.tr`Password Reset Form`}. You will need to make a Smogon account to be able to fill out a form; that's what the email address you sign in to Smogon with is for (PS accounts for regular users don't have emails associated with them).`);
}
if (!buffer.length && target) {
this.errorReply(`'${target}' is an invalid FAQ.`);
return this.parse(`/help faq`);
}
if (!target || showAll) {
buffer.unshift(`${this.tr`Frequently Asked Questions`}`);
}
this.sendReplyBox(buffer.join(` `));
},
faqhelp: [
`/faq [theme] - Provides a link to the FAQ. Add autoconfirmed, badges, proxy, ladder, staff, or tiers for a link to these questions. Add all for all of them.`,
`!faq [theme] - Shows everyone a link to the FAQ. Add autoconfirmed, badges, proxy, ladder, staff, or tiers for a link to these questions. Add all for all of them. Requires: + % @ # ~`
],
analysis: "smogdex",
strategy: "smogdex",
smogdex(target, room, user) {
if (!target)
return this.parse("/help smogdex");
if (!this.runBroadcast())
return;
const targets = target.split(",");
let pokemon = Dex.species.get(targets[0]);
const item = Dex.items.get(targets[0]);
const move = Dex.moves.get(targets[0]);
const ability = Dex.abilities.get(targets[0]);
const format = Dex.formats.get(targets[0]);
let atLeastOne = false;
let generation = (targets[1] || "sv").trim().toLowerCase();
let genNumber = 9;
const extraFormat = Dex.formats.get(targets[2]);
if (["9", "gen9", "nine", "sv"].includes(generation)) {
generation = "sv";
} else if (["8", "gen8", "eight", "ss", "swsh"].includes(generation)) {
generation = "ss";
genNumber = 8;
} else if (["7", "gen7", "seven", "sm", "sumo", "usm", "usum"].includes(generation)) {
generation = "sm";
genNumber = 7;
} else if (["6", "gen6", "oras", "six", "xy"].includes(generation)) {
generation = "xy";
genNumber = 6;
} else if (["5", "b2w2", "bw", "bw2", "five", "gen5"].includes(generation)) {
generation = "bw";
genNumber = 5;
} else if (["4", "dp", "dpp", "four", "gen4", "hgss"].includes(generation)) {
generation = "dp";
genNumber = 4;
} else if (["3", "adv", "frlg", "gen3", "rs", "rse", "three"].includes(generation)) {
generation = "rs";
genNumber = 3;
} else if (["2", "gen2", "gs", "gsc", "two"].includes(generation)) {
generation = "gs";
genNumber = 2;
} else if (["1", "gen1", "one", "rb", "rby", "rgy"].includes(generation)) {
generation = "rb";
genNumber = 1;
} else {
generation = "sv";
}
if (pokemon.exists) {
atLeastOne = true;
if (genNumber < pokemon.gen) {
return this.sendReplyBox(`${pokemon.name} did not exist in ${generation.toUpperCase()}!`);
}
if (pokemon.battleOnly && pokemon.baseSpecies !== "Greninja" || ["Keldeo", "Genesect"].includes(pokemon.baseSpecies)) {
pokemon = Dex.species.get(pokemon.changesFrom || pokemon.baseSpecies);
}
let formatName = extraFormat.name;
let formatId = extraFormat.id;
if (formatName.startsWith("[Gen ") && formatName.slice(6, 8) === "] ") {
formatName = formatName.slice(8);
formatId = toID(formatName);
}
if (formatId === "anythinggoes") {
formatId = "ag";
} else if (formatId === "battlespotdoubles") {
formatId = "battle_spot_doubles";
} else if (formatId === "battlespottriples") {
formatId = "battle_spot_triples";
if (genNumber > 6) {
return this.sendReplyBox(`Triples formats are not an available format in Pokémon generation ${generation.toUpperCase()}.`);
}
} else if (formatId === "doublesou") {
formatId = "doubles";
} else if (formatId === "balancedhackmons") {
formatId = "bh";
} else if (formatId === "battlespotsingles") {
formatId = "battle_spot_singles";
} else if (formatId === "ubers") {
formatId = "uber";
} else if (formatId.includes("vgc")) {
formatId = "vgc" + formatId.slice(-2);
formatName = "VGC 20" + formatId.slice(-2);
} else if (extraFormat.effectType !== "Format") {
formatName = formatId = "";
}
const supportedLanguages = {
spanish: "es",
french: "fr",
italian: "it",
german: "de",
portuguese: "pt"
};
let id = pokemon.name.toLowerCase();
if (id === "meowstic")
id = "meowstic-m";
if (id === "zygarde-10%")
id = "zygarde-10";
if (["ou", "uu"].includes(formatId) && generation === "sm" && room?.settings.language && room.settings.language in supportedLanguages) {
this.sendReplyBox(
import_lib.Utils.html`${generation.toUpperCase()} ${formatName} ${pokemon.name} analysis, brought to you by Smogon University`
);
} else if (["ou", "uu"].includes(formatId) && generation === "sm") {
this.sendReplyBox(
import_lib.Utils.html`${generation.toUpperCase()} ${formatName} ${pokemon.name} analysis, brought to you by Smogon University ` + `Other languages: Espa\xF1ol, Fran\xE7ais, Italiano, Deutsch, Portugu\xEAs`
);
} else {
this.sendReplyBox(import_lib.Utils.html`${generation.toUpperCase()} ${formatName} ${pokemon.name} analysis, brought to you by Smogon University`);
}
}
if (item.exists && genNumber > 1 && item.gen <= genNumber) {
atLeastOne = true;
this.sendReplyBox(`${generation.toUpperCase()} ${item.name} item analysis, brought to you by Smogon University`);
}
if (ability.exists && genNumber > 2 && ability.gen <= genNumber) {
atLeastOne = true;
this.sendReplyBox(`${generation.toUpperCase()} ${ability.name} ability analysis, brought to you by Smogon University`);
}
if (move.exists && move.gen <= genNumber) {
atLeastOne = true;
this.sendReplyBox(`${generation.toUpperCase()} ${move.name} move analysis, brought to you by Smogon University`);
}
if (format.id) {
let formatName = format.name;
let formatId = format.id;
if (formatName.startsWith("[Gen ") && formatName.slice(6, 8) === "] ") {
formatName = formatName.slice(8);
formatId = toID(formatName);
}
if (formatId === "anythinggoes") {
formatId = "ag";
} else if (formatId === "battlespotdoubles") {
formatId = "battle_spot_doubles";
} else if (formatId === "battlespottriples") {
formatId = "battle_spot_triples";
if (genNumber > 6) {
return this.sendReplyBox(`Triples formats are not an available format in Pokémon generation ${generation.toUpperCase()}.`);
}
} else if (formatId === "doublesou") {
formatId = "doubles";
} else if (formatId === "balancedhackmons") {
formatId = "bh";
} else if (formatId === "battlespotsingles") {
formatId = "battle_spot_singles";
} else if (formatId === "ubers") {
formatId = "uber";
} else if (formatId.includes("vgc")) {
formatId = `vgc${formatId.slice(-2)}`;
formatName = `VGC 20${formatId.slice(-2)}`;
} else if (format.effectType !== "Format") {
formatName = formatId = "";
}
if (formatName) {
atLeastOne = true;
this.sendReplyBox(import_lib.Utils.html`${generation.toUpperCase()} ${formatName} format analysis, brought to you by Smogon University`);
}
}
if (!atLeastOne) {
return this.sendReplyBox(`Pokémon, item, move, ability, or format not found for generation ${generation.toUpperCase()}.`);
}
},
smogdexhelp: [
`/analysis [pokemon], [generation], [format] - Links to the Smogon University analysis for this Pok\xE9mon in the given generation.`,
`!analysis [pokemon], [generation], [format] - Shows everyone this link. Requires: + % @ # ~`
],
bulbapedia(target, broadcast, user) {
if (!target)
return this.parse("/help bulbapedia");
if (!this.runBroadcast())
return;
const baseLink = "https://bulbapedia.bulbagarden.net/wiki/";
const pokemon = Dex.species.get(target);
const item = Dex.items.get(target);
const move = Dex.moves.get(target);
const ability = Dex.abilities.get(target);
const nature = Dex.natures.get(target);
let atLeastOne = false;
if (pokemon.exists) {
atLeastOne = true;
if (pokemon.isNonstandard && pokemon.isNonstandard !== "Past") {
return this.errorReply(`${pokemon.name} is not a real Pok\xE9mon.`);
}
let baseSpecies = pokemon.baseSpecies;
if (pokemon.id.startsWith("flabebe"))
baseSpecies = "Flab\xE9b\xE9";
const link = `${baseLink}${encodeURIComponent(baseSpecies)}_(Pok\xE9mon)`;
this.sendReplyBox(import_lib.Utils.html`${pokemon.name} in-game information, provided by Bulbapedia`);
}
if (item.exists) {
atLeastOne = true;
if (item.isNonstandard && item.isNonstandard !== "Past") {
return this.errorReply(`${item.name} is not a real item.`);
}
let link = `${baseLink}${encodeURIComponent(item.name)}`;
if (Dex.moves.get(item.name).exists)
link += "_(item)";
this.sendReplyBox(import_lib.Utils.html`${item.name} item description, provided by Bulbapedia`);
}
if (ability.exists) {
atLeastOne = true;
if (ability.isNonstandard && ability.isNonstandard !== "Past") {
return this.errorReply(`${ability.name} is not a real ability.`);
}
const link = `${baseLink}${encodeURIComponent(ability.name)}_(Ability)`;
this.sendReplyBox(`${ability.name} ability description, provided by Bulbapedia`);
}
if (move.exists) {
atLeastOne = true;
if (move.isNonstandard && move.isNonstandard !== "Past") {
return this.errorReply(`${move.name} is not a real move.`);
}
const link = `${baseLink}${encodeURIComponent(move.name)}_(move)`;
this.sendReplyBox(`${move.name} move description, provided by Bulbapedia`);
}
if (nature.exists) {
atLeastOne = true;
const link = `${baseLink}Nature`;
this.sendReplyBox(`Nature descriptions, provided by Bulbapedia`);
}
if (!atLeastOne) {
return this.sendReplyBox(`Pokémon, item, move, ability, or nature not found.`);
}
},
bulbapediahelp: [
`/bulbapedia [pokemon/item/move/ability/nature] - Links to Bulbapedia wiki page for this pokemon/item/move/ability/nature.`,
`!bulbapedia [pokemon/item/move/ability/nature] - Shows everyone this link. Requires: + % @ # ~`
],
register() {
if (!this.runBroadcast())
return;
this.sendReplyBox(`You will be prompted to register upon winning a rated battle. Alternatively, there is a register button in the menu in the upper right.`);
},
registerhelp: [`/register - Provides information on how to register.`],
/*********************************************************
* Miscellaneous commands
*********************************************************/
roll: "dice",
dice(target, room, user) {
if (!target || /[^\d\sdHL+-]/i.test(target))
return this.parse("/help dice");
if (!this.runBroadcast(true))
return;
const maxDice = 40;
let diceQuantity = 1;
const diceDataStart = target.indexOf("d");
if (diceDataStart >= 0) {
if (diceDataStart)
diceQuantity = Number(target.slice(0, diceDataStart));
target = target.slice(diceDataStart + 1);
if (!Number.isInteger(diceQuantity) || diceQuantity <= 0 || diceQuantity > maxDice) {
return this.sendReply(`The amount of dice rolled should be a natural number up to ${maxDice}.`);
}
}
let offset = 0;
let removeOutlier = 0;
const modifierData = /[+-]/.exec(target);
if (modifierData) {
switch (target.slice(modifierData.index).trim().toLowerCase()) {
case "-l":
removeOutlier = -1;
break;
case "-h":
removeOutlier = 1;
break;
default:
offset = Number(target.slice(modifierData.index));
if (isNaN(offset))
return this.parse("/help dice");
if (!Number.isSafeInteger(offset)) {
return this.errorReply(`The specified offset must be an integer up to ${Number.MAX_SAFE_INTEGER}.`);
}
}
if (removeOutlier && diceQuantity <= 1) {
return this.errorReply(`More than one dice should be rolled before removing outliers.`);
}
target = target.slice(0, modifierData.index);
}
let diceFaces = 6;
if (target.length) {
diceFaces = Number(target);
if (!Number.isSafeInteger(diceFaces) || diceFaces <= 0) {
return this.errorReply(`Rolled dice must have a natural amount of faces up to ${Number.MAX_SAFE_INTEGER}.`);
}
}
if (diceQuantity > 1) {
if (!Number.isSafeInteger(offset < 0 ? diceQuantity * diceFaces : diceQuantity * diceFaces + offset)) {
return this.errorReply(`The maximum sum of rolled dice must be lower or equal than ${Number.MAX_SAFE_INTEGER}.`);
}
}
let maxRoll = 0;
let minRoll = Number.MAX_SAFE_INTEGER;
const trackRolls = diceQuantity * (`${diceFaces}`.length + 1) <= 60;
const rolls = [];
let rollSum = 0;
for (let i = 0; i < diceQuantity; ++i) {
const curRoll = Math.floor(Math.random() * diceFaces) + 1;
rollSum += curRoll;
if (curRoll > maxRoll)
maxRoll = curRoll;
if (curRoll < minRoll)
minRoll = curRoll;
if (trackRolls)
rolls.push(curRoll);
}
if (removeOutlier > 0) {
rollSum -= maxRoll;
} else if (removeOutlier < 0) {
rollSum -= minRoll;
}
if (offset)
rollSum += offset;
let offsetFragment = "";
if (offset)
offsetFragment += `${offset > 0 ? ` + ${offset}` : offset}`;
if (diceQuantity === 1)
return this.sendReplyBox(`Rolling (1 to ${diceFaces})${offsetFragment}: ${rollSum}`);
const outlierFragment = removeOutlier ? ` except ${removeOutlier > 0 ? "highest" : "lowest"}` : ``;
const rollsFragment = trackRolls ? ": " + rolls.join(", ") : "";
return this.sendReplyBox(
`${diceQuantity} rolls (1 to ${diceFaces})${rollsFragment} Sum${offsetFragment}${outlierFragment}: ${rollSum}`
);
},
dicehelp: [
`/dice [max number] - Randomly picks a number between 1 and the number you choose.`,
`/dice [number of dice]d[number of sides] - Simulates rolling a number of dice, e.g., /dice 2d4 simulates rolling two 4-sided dice.`,
`/dice [number of dice]d[number of sides][+/-][offset] - Simulates rolling a number of dice and adding an offset to the sum, e.g., /dice 2d6+10: two standard dice are rolled; the result lies between 12 and 22.`,
`/dice [number of dice]d[number of sides]-[H/L] - Simulates rolling a number of dice with removal of extreme values, e.g., /dice 3d8-L: rolls three 8-sided dice; the result ignores the lowest value.`
],
pr: "pickrandom",
pick: "pickrandom",
pickrandom(target, room, user) {
if (!target?.includes(","))
return this.parse("/help pick");
if (!this.runBroadcast(true))
return false;
if (this.broadcasting) {
[, target] = import_lib.Utils.splitFirst(this.message, " ");
}
const options = target.split(",");
const pickedOption = options[Math.floor(Math.random() * options.length)].trim();
return this.sendReplyBox(import_lib.Utils.html`We randomly picked: ${pickedOption}`);
},
pickrandomhelp: [`/pick [option], [option], ... - Randomly selects an item from a list containing 2 or more elements.`],
shuffle(target, room, user) {
if (!target?.includes(","))
return this.parse("/help shuffle");
const args = target.split(",");
if (!this.runBroadcast(true))
return false;
const results = import_lib.Utils.shuffle(args.map((arg) => arg.trim()));
return this.sendReplyBox(import_lib.Utils.html`Shuffled: ${results.join(", ")}`);
},
shufflehelp: [
`/shuffle [option], [option], [option], ... - Randomly shuffles a list of 2 or more elements.`
],
showimage(target, room, user) {
return this.errorReply(`/showimage has been deprecated - use /show instead.`);
},
async requestshow(target, room, user) {
room = this.requireRoom();
this.checkChat();
if (!room.settings.requestShowEnabled) {
return this.errorReply(`Media approvals are disabled in this room.`);
}
if (user.can("showmedia", null, room, "show"))
return this.errorReply(`Use !show instead.`);
if (room.pendingApprovals?.has(user.id))
return this.errorReply("You have a request pending already.");
if (!toID(target))
return this.parse(`/help requestshow`);
let [link, comment] = this.splitOne(target);
if (!/^https?:\/\//.test(link))
link = `https://${link}`;
link = encodeURI(link);
let dimensions;
if (!/^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.be)(\/|$)/i.test(link)) {
if (link.includes("data:image/png;base64")) {
throw new Chat.ErrorMessage("Please provide an actual link (you probably copied the URL wrong?).");
}
try {
dimensions = await Chat.fitImage(link);
} catch {
throw new Chat.ErrorMessage("Invalid link.");
}
}
if (comment && this.checkChat(comment) !== comment) {
return this.errorReply(`You cannot use filtered words in comments.`);
}
if (!room.pendingApprovals)
room.pendingApprovals = /* @__PURE__ */ new Map();
room.pendingApprovals.set(user.id, {
name: user.name,
link,
comment,
dimensions
});
this.sendReply(`You have requested to show the link: ${link}${comment ? ` (with the comment ${comment})` : ""}.`);
const message = `|tempnotify|pendingapprovals|Pending media request!|${user.name} has requested to show media in ${room.title}.|new media request`;
room.sendRankedUsers(message, "%");
room.sendMods(
import_lib.Utils.html`|uhtml|request-${user.id}|
${user.name} wants to show ${link} ` + (comment ? import_lib.Utils.html`Comment: ${comment} ` : "") + `
`
);
},
requestshowhelp: [`/requestshow [link], [comment] - Requests permission to show media in the room.`],
async approveshow(target, room, user) {
room = this.requireRoom();
this.checkCan("mute", null, room);
if (!room.settings.requestShowEnabled) {
return this.errorReply(`Media approvals are disabled in this room.`);
}
const userid = toID(target);
if (!userid)
return this.parse(`/help approveshow`);
const request = room.pendingApprovals?.get(userid);
if (!request)
return this.errorReply(`${userid} has no pending request.`);
if (userid === user.id) {
return this.errorReply(`You can't approve your own /show request.`);
}
room.pendingApprovals.delete(userid);
room.sendMods(`|uhtmlchange|request-${target}|`);
room.sendRankedUsers(`|tempnotifyoff|pendingapprovals`, "%");
let buf;
if (request.dimensions) {
const [width, height, resized] = request.dimensions;
buf = import_lib.Utils.html``;
if (resized)
buf += import_lib.Utils.html` full-size image`;
} else {
buf = await import_youtube.YouTube.generateVideoDisplay(request.link, false);
if (!buf)
return this.errorReply("Could not get YouTube video");
}
buf += import_lib.Utils.html`
(Requested by ${request.name})`;
if (request.comment) {
buf += import_lib.Utils.html` ${request.comment}
`;
} else {
buf += ``;
}
room.add(`|c| ${request.name}|/raw ${buf}`);
this.privateModAction(`${user.name} approved showing media from ${request.name}.`);
},
approveshowhelp: [`/approveshow [user] - Approves the media display request of [user]. Requires: % @ # ~`],
denyshow(target, room, user) {
room = this.requireRoom();
this.checkCan("mute", null, room);
if (!room.settings.requestShowEnabled) {
return this.errorReply(`Media approvals are disabled in this room.`);
}
target = toID(target);
if (!target)
return this.parse(`/help denyshow`);
const entry = room.pendingApprovals?.get(target);
if (!entry)
return this.errorReply(`${target} has no pending request.`);
room.pendingApprovals.delete(target);
room.sendMods(`|uhtmlchange|request-${target}|`);
room.sendRankedUsers(`|tempnotifyoff|pendingapprovals`, "%");
this.privateModAction(`${user.name} denied ${target}'s request to display ${entry.link}.`);
const targetUser = Users.get(target);
if (!targetUser)
return;
room.sendUser(targetUser, `|raw|
Your media request was denied.
`);
room.sendUser(targetUser, `|notify|Media request denied`);
},
denyshowhelp: [`/denyshow [user] - Denies the media display request of [user]. Requires: % @ # ~`],
approvallog(target, room, user) {
room = this.requireRoom();
return this.parse(`/sl approved showing media from, ${room.roomid}`);
},
approvalloghelp: [`/approvallog - View a log of past media approvals in the current room. Requires: ~`],
viewapprovals(target, room, user) {
room = this.requireRoom();
return this.parse(`/join view-approvals-${room.roomid}`);
},
viewapprovalshelp: [
`/viewapprovals - View a list of users who have requested to show media in the current room.`,
`Requires: % @ # ~`
],
async show(target, room, user, connection) {
if (!room?.persist && !this.pmTarget && !room?.roomid.startsWith("help-")) {
return this.errorReply(`/show cannot be used in temporary rooms.`);
}
if (!toID(target).trim())
return this.parse(`/help show`);
if (Monitor.countNetRequests(connection.ip)) {
return this.errorReply(`You are using this command too quickly. Wait a bit and try again.`);
}
const [link, comment] = import_lib.Utils.splitFirst(target, ",").map((f) => f.trim());
this.checkBroadcast();
if (this.broadcastMessage) {
if (room) {
this.checkCan("show", null, room);
} else {
this.checkCan("altsself");
}
}
this.runBroadcast();
let buf;
if (import_youtube.YouTube.linkRegex.test(link)) {
buf = await import_youtube.YouTube.generateVideoDisplay(link, false);
this.message = this.message.replace(/&ab_channel=(.*)(&|)/ig, "").replace(/https:\/\/www\./ig, "");
} else if (import_youtube.Twitch.linkRegex.test(link)) {
const channelId = import_youtube.Twitch.linkRegex.exec(link)?.[2]?.trim();
if (!channelId)
return this.errorReply(`Specify a Twitch channel.`);
buf = import_lib.Utils.html`Watching ${channelId}... `;
buf += ``;
} else {
if (Chat.linkRegex.test(link)) {
if (/^https?:\/\/(.*)\.(mp4|mov)\b(\?|$)/i.test(link)) {
buf = import_lib.Utils.html``;
} else if (/^https?:\/\/(.*)\.(mp3|wav)\b(\?|$)/i.test(link)) {
buf = import_lib.Utils.html``;
}
}
if (link.includes("data:image/png;base64")) {
throw new Chat.ErrorMessage("Please provide an actual link (you probably copied it wrong?).");
}
if (!buf) {
try {
const [width, height, resized] = await Chat.fitImage(link);
buf = import_lib.Utils.html``;
if (resized)
buf += import_lib.Utils.html` full-size image`;
} catch {
return this.errorReply("Invalid image, audio, or video URL.");
}
}
}
if (comment) {
if (this.checkChat(comment) !== comment) {
return this.errorReply(`You cannot use filtered words in comments.`);
}
buf += import_lib.Utils.html` (${comment})`;
}
this.sendReplyBox(buf);
},
showhelp: [
`/show [url] - Shows you an image, audio clip, video file, or YouTube video.`,
`!show [url] - Shows an image, audio clip, video file, or YouTube video to everyone in a chatroom. Requires: whitelist % @ # ~`
],
rebroadcast(target, room, user, connection) {
if (!target || !target.startsWith("!") || !this.shouldBroadcast()) {
return this.parse("/help rebroadcast");
}
room = this.requireRoom();
room.lastBroadcast = "";
this.parse(target, { broadcastPrefix: "!rebroadcast " });
},
rebroadcasthelp: [
`!rebroadcast ![command] - Bypasses the broadcast cooldown to broadcast a command.`
],
regdate: "registertime",
regtime: "registertime",
async registertime(target, room, user, connection) {
this.runBroadcast();
if (Monitor.countNetRequests(connection.ip)) {
return this.errorReply(`You are using this command too quickly. Wait a bit and try again.`);
}
if (!user.autoconfirmed)
return this.errorReply(`Only autoconfirmed users can use this command.`);
target = toID(target);
if (!target)
target = user.id;
let rawResult;
try {
rawResult = await (0, import_lib.Net)(`https://${Config.routes.root}/users/${target}.json`).get();
} catch (e) {
if (e.message.includes("Not found"))
throw new Chat.ErrorMessage(`User '${target}' is unregistered.`);
throw new Chat.ErrorMessage(e.message);
}
const result = JSON.parse(rawResult);
const date = new Date(result.registertime * 1e3);
const duration = Date.now() - date.getTime();
const regTimeAgo = duration > 24 * 60 * 60 * 1e3 ? Chat.toDurationString(duration, { precision: 1 }) : "less than a day";
this.sendReplyBox(import_lib.Utils.html`The user '${target}' registered ${regTimeAgo} ago, on the date ${date.toDateString()}.`);
},
registertimehelp: [`/registertime OR /regtime [user] - Find out when [user] registered.`],
pi(target, room, user) {
if (!this.runBroadcast())
return false;
return this.sendReplyBox(
'Did you mean: 1. 3.1415926535897932384626... (Decimal) 2. 3.184809493B91866... (Duodecimal) 3. 3.243F6A8885A308D... (Hexadecimal)
How many digits of pi do YOU know? Test it out here!'
);
},
pihelp: [`/pi - Displays the first several digits of pi in several notation types.`],
code(target, room, user, connection) {
target = this.message.substr(this.cmdToken.length + this.cmd.length + (this.message.includes(" ") ? 1 : 0)).trimRight();
if (!target)
return this.parse("/help code");
if (target.length >= 8192)
return this.errorReply("Your code must be under 8192 characters long!");
if (target.length < 80 && !target.includes("\n") && !target.includes("```") && this.shouldBroadcast()) {
return this.checkChat(`\`\`\`${target}\`\`\``);
}
if (this.room?.settings.isPersonal !== false && this.shouldBroadcast()) {
target = this.filter(target);
if (!target)
return this.errorReply(`Invalid code.`);
}
this.checkBroadcast(true, "!code");
this.runBroadcast(true);
if (this.broadcasting) {
return `/raw
${Chat.getReadmoreCodeBlock(target)}
`;
} else {
this.sendReplyBox(Chat.getReadmoreCodeBlock(target));
}
},
codehelp: [
`!code [code] - Broadcasts code to a room. Accepts multi-line arguments. Requires: + % @ ~ #`,
`/code [code] - Shows you code. Accepts multi-line arguments.`
],
buildformat(target, room, user) {
target = toID(target);
if (target && this.connection.openPages?.has("buildformat")) {
this.closePage("buildformat");
}
return this.parse(`/j view-buildformat${target ? `-${target}` : ""}`);
},
makecustomchallenge(target, room, user) {
target = target.trim();
if (!target.length) {
return this.popupReply(`No parameters given.`);
}
const args = Chat.parseArguments(target, " | ", {
allowEmpty: true,
useIDs: false
});
const format = Dex.formats.get(toID(args.format[0]));
if (format.effectType !== "Format") {
return this.popupReply(`The format '${format}' does not exist.`);
}
delete args.format;
const targetUserID = toID(args.user[0]);
if (targetUserID) {
this.checkChat();
if (!Users.get(targetUserID)) {
return this.popupReply(`User '${targetUserID}' not found.`);
}
}
delete args.user;
const challengeBuf = [];
if (args.bans?.[0]) {
const bans = args.bans[0].split(",").map((f) => f.trim());
challengeBuf.push(...bans);
}
delete args.bans;
for (const k in args) {
if (k.endsWith("-enabled"))
continue;
let name = k;
if (name.endsWith("-val")) {
name = name.slice(0, -4);
}
const rule = Dex.data.Rulesets[name];
if (!rule || rule.effectType === "Format") {
return this.popupReply(`Invalid rule or modifier: ${name}`);
}
const id = rule.id || toID(rule.name);
let val = args[k][0];
if (val.startsWith("{")) {
val = "";
}
const ruleTable = Dex.formats.getRuleTable(format);
if (rule.hasValue) {
const enabled = args[`${id}-enabled`][0] || "";
val = args[`${id}-val`][0] || "";
if (enabled) {
const current = ruleTable.valueRules.get(id);
if (typeof current !== "undefined") {
if (current !== val) {
challengeBuf.push(`!! ${rule.name} = ${val}`);
}
} else {
challengeBuf.push(`${rule.name} = ${val}`);
}
} else {
if (ruleTable.valueRules.has(id)) {
challengeBuf.push(`!${rule.name}`);
}
}
} else {
if (val && ruleTable.has(id)) {
continue;
}
if (!val && !ruleTable.has(id)) {
continue;
}
challengeBuf.push(`${!val ? "!" : ""}${rule.name}`);
}
}
const fullFormat = `${format.id}@@@${challengeBuf.join(",")}`;
try {
Dex.formats.validate(fullFormat);
} catch (e) {
this.refreshPage(`buildformat-${format.id}`);
return this.popupReply(e.message);
}
if (targetUserID) {
this.closePage(`buildformat`);
return this.parse(`/challenge ${targetUserID},${fullFormat}`);
} else {
this.connection.send(
`>view-buildformat-${format.id}
|selectorhtml|#output|Here's the string for your desired rules! ${fullFormat} Use /challenge [user],${fullFormat} to challenge someone with it!`
);
}
},
adminhelp(target, room, user) {
this.checkCan("rangeban");
let cmds = Chat.allCommands();
const canExecute = (perm) => !// gotta make sure no lower group has it
Object.values(Config.groups).slice(1).some((f) => f[perm]);
cmds = cmds.filter(
(f) => f.requiredPermission && canExecute(f.requiredPermission) && f.fullCmd !== this.handler?.fullCmd
);
cmds = import_lib.Utils.sortBy(cmds, (f) => f.fullCmd);
let namespaces = /* @__PURE__ */ new Map();
for (const cmd of cmds) {
const namespace = cmd.fullCmd.split(" ")[0];
const list = namespaces.get(namespace) || [];
list.push(cmd.fullCmd.trim());
namespaces.set(namespace, list);
}
let buf = `Admin commands: `;
namespaces = new Map(import_lib.Utils.sortBy([...namespaces], ([, cmdList]) => cmdList.length === 1));
for (const [namespace, cmdList] of namespaces) {
if (cmdList.length > 1 || cmdList[0].includes(" ")) {
buf += `${namespace}`;
buf += cmdList.map((f) => `• /${f}`).join(" ");
buf += ``;
} else {
buf += `• ${cmdList[0]}`;
const help = Chat.commands[namespace + "help"];
if (help) {
const text = Array.isArray(help) ? help.join(" | ") : typeof help === "function" ? `` : "";
buf += text ? ` (${text})` : ` (no help found)`;
}
}
buf += ` `;
}
this.sendReplyBox(buf);
},
adminhelphelp: [`/adminhelp - Programmatically generates a list of all administrator commands. Requires: ~`],
altlog: "altslog",
altslog(target, room, user) {
this.checkCan("lock");
target = toID(target);
if (!target) {
return this.parse(`/help altslog`);
}
return this.parse(`/join view-altslog-${target}`);
},
altsloghelp: [
`/altslog [userid] - View the alternate account history for the given [userid]. Requires: % @ ~`
],
randtopic(target, room, user) {
room = this.requireRoom();
if (!room.settings.topics?.length) {
return this.errorReply(`This room has no random topics to select from.`);
}
this.runBroadcast();
this.sendReply(import_lib.Utils.html`|html|
`);
},
randtopichelp: [
`/randtopic - Randomly selects a topic from the room's discussion topic pool and displays it.`,
`/addtopic [target] - Adds the [target] to the pool of random discussion topics. Requires: % @ # ~`,
`/removetopic [index] - Removes the topic from the room's topic pool. Requires: % @ # ~`,
`/randomtopics - View the discussion topic pool for the current room.`
],
addtopic(target, room, user) {
room = this.requireRoom();
this.checkCan("mute", null, room);
target = target.trim();
if (!toID(target).length) {
return this.parse(`/help randtopic`);
}
if (!room.settings.topics)
room.settings.topics = [];
room.settings.topics.push(target);
this.privateModAction(`${user.name} added the topic "${target}" to the random topic pool.`);
this.modlog("ADDTOPIC", null, target);
room.saveSettings();
},
addtopichelp: [`/addtopic [target] - Adds the [target] to the pool of random discussion topics. Requires: % @ # ~`],
removetopic(target, room, user) {
room = this.requireRoom();
this.checkCan("mute", null, room);
if (!toID(target)) {
return this.parse(`/help randtopic`);
}
const index = Number(toID(target)) - 1;
if (isNaN(index)) {
return this.errorReply(`Invalid topic index: ${target}. Must be a number.`);
}
if (!room.settings.topics?.[index]) {
return this.errorReply(`Topic ${index + 1} not found.`);
}
const topic = room.settings.topics.splice(index, 1)[0];
room.saveSettings();
this.privateModAction(`${user.name} removed topic ${index + 1} from the random topic pool.`);
this.modlog("REMOVETOPIC", null, topic);
},
removetopichelp: [`/removetopic [index] - Removes the topic from the room's topic pool. Requires: % @ # ~`],
listtopics: "randomtopics",
randtopics: "randomtopics",
randomtopics(target, room, user) {
room = this.requireRoom();
return this.parse(`/join view-topics-${room}`);
}
};
const handlers = {
onRename(user, oldID, newID) {
if (oldID === newID || !Config.usesqlite || [oldID, newID].some((f) => f.startsWith("guest")))
return;
void Chat.database.run(
`REPLACE INTO alts_log (to_id, from_id, ip) VALUES (?, ?, ?)`,
[newID, oldID, user.latestIp]
);
}
};
const pages = {
async altslog(query, user) {
this.checkCan("lock");
this.title = "[Alts Log]";
const target = toID(query.shift());
if (!target) {
return this.errorReply(`Please specify a user to find alternate accounts for.`);
}
this.title += ` ${target}`;
if (!Config.usesqlite) {
return this.errorReply(`The alternate account log is currently disabled.`);
}
const rawLimit = query.shift() || "100";
const num = parseInt(rawLimit);
if (num > 3e3) {
return this.errorReply(`3000 is the maximum number of results from the alternate account log.`);
}
if (isNaN(num) || num < 1) {
return this.errorReply(`The max results must be a real number that is at least one (received "${rawLimit}")`);
}
const showIPs = user.can("globalban");
const results = await Chat.database.all(
"SELECT to_id, from_id, ip FROM alts_log WHERE (to_id = ? OR from_id = ?) LIMIT ?",
[target, target, num]
);
let buf = `
Alternate accounts for ${target}
`;
buf += `${results.length} found.`;
const ipTable = {};
const userids = /* @__PURE__ */ new Set();
const useridToIp = /* @__PURE__ */ new Map();
for (const result of results) {
const id = result.from_id === target ? result.to_id : result.from_id;
userids.add(id);
let prevIps = useridToIp.get(id);
if (!prevIps) {
prevIps = [];
}
if (!prevIps.includes(result.ip)) {
prevIps.push(result.ip);
}
useridToIp.set(id, prevIps);
if (!ipTable[result.ip])
ipTable[result.ip] = 0;
ipTable[result.ip]++;
}
buf += `
Userid
${showIPs ? `
Latest IP
` : ""}
`;
for (const id of userids) {
const ips = useridToIp.get(id) || [];
buf += `
Bans are just a - followed by the thing you want to ban.
`,
`
Individual bans
`,
`
- Arceus: Ban a Pokémon (including all formes)
`,
`
- Arceus-Flying or - Giratina-Altered: Ban a Pokémon forme
`,
`
- Baton Pass: Ban a move/item/ability/etc
`,
`
Group bans
`,
`
- OU or - DUU: Ban a tier
`,
`
- Mega or - CAP: Ban a Pokémon category
`,
`
Complex bans
`,
`
- Blaziken + Speed Boost: Ban a combination of things in a single Pokemon (you can have a Blaziken, and you can have Speed Boost on the same team, but the Blaziken can't have Speed Boost)
`,
`
- Drizzle ++ Swift Swim: Ban a combination of things in a team (if any Pok\xE9mon on your team have Drizzle, no Pok\xE9mon can have Swift Swim)
The following rules can be added to challenges/tournaments to modify the style of play. Alternatively, already present rules can be removed from formats by preceding the rule name with !
`,
`
However, some rules, like Obtainable, are made of subrules, that can be individually turned on and off.
`,
`
Rule Name
Description
`
];
for (const rule of rules) {
if (rule.hasValue)
continue;
const desc = rule.desc ? rule.desc : "No description.";
rulesets.push(`
${rule.name}
${desc}
`);
}
rulesets.push(
`
`,
`
Value rules
`,
`
Value rules are formatted like [Name] = [value], e.g. "Force Monotype = Water" or "Min Team Size = 4"
`,
`
To remove a value rule, use ![rule name].
`,
`
To override another value rule, use !! [Name] = [new value]. For example, overriding the Min Source Gen on [Gen 8] VGC 2021 from 8 to 3 would look like !! Min Source Gen = 3.
`,
`
Rule Name
Description
`
);
for (const rule of rules) {
if (!rule.hasValue)
continue;
const desc = rule.desc ? rule.desc : "No description.";
rulesets.push(`
`;
buffer += `