Files
burrow-server/lib/moderation.js
T
Burrowdev 33f56074a4 feat: discord linking, @tags, music and sfx sliders, required device ids
- Discord: the account page links a player's Discord account through
  Discord's sign-in (lib/discord.js); only linked names are shown on cards
  (typed ones are cleared). A bot keeps the Server Booster badge on linked
  accounts that boost. The game tells the client where the player is, for
  the client's Discord rich presence (flashvars discordAppId).
- @username tags in chat, chat balloons and wall posts: only real players'
  names (asked of the server, "xmn"), names with spaces too, drawn on a
  blue box; a click opens the player's card.
- Settings: separate Music and SFX volume sliders for the old one.
- Device ids required: a launcher that sends none (before 1.3.0) is told
  at the game's login "Your client is outdated. Update at
  https://burrow.moe/download". AJ_REQUIRE_DEVICE=0 turns it off.
- Panels: clear a player's Jammer Wall posts; turning away masterpieces
  and player items asks first.
- Item Giver: negative colour ids (the same colour written signed).
- buildVersion 71; the client rebuilt with Snipzil's sitting fix.
2026-10-18 19:35:51 +03:00

314 lines
12 KiB
JavaScript

"use strict";
const accounts = require("./accounts.js");
const achievements = require("./achievements.js");
const bans = require("./bans.js");
const dens = require("./dens.js");
const config = require("../config.js");
const {CURRENCIES} = require("./player.js");
// moderation: kick, ban, silence, clear a den, grant gems, message a player.
// these are done from the admin panel (lib/panel.js). no game account has
// them: the client's own moderator requests (FacilitatorXtCommManager) are
// always refused.
const PERMANENT = -1;
const SECONDS_PER_MINUTE = 60;
const CURRENCY_GEMS = 0;
// ItemXtCommManager.currencyUpdateResponse: with this as the reason the
// client says "You earned N ..." in a popup when the amount went up.
const REASON_ANNOUNCE = 3;
// a warning's reason, and the client's own warning popup for it
// (FacilitatorXtCommManager.showContextualWarningPopup, "fw"): its artwork
// and its words, which this server's strings already say in its own name.
const WARNINGS = {
behavior: 4, // "Inappropriate Behavior"
bullying: 1, // "Bullying"
personal: 3, // "Personal Information"
scamming: 9, // "Scamming"
// in the staff member's own words: its note is what the player is shown,
// in a message box (there is no popup for it), and it cannot be left out.
custom: null,
};
const CUSTOM_WARNING = "custom";
const MAX_WARNINGS_KEPT = 100;
const MAX_WARNING_NOTE = 200;
const SECONDS_PER_DAY = 86400;
const now = () => Math.floor(Date.now() / 1000);
// seconds of ban left, PERMANENT, or 0 when not banned.
const banRemaining = account => {
if (account.bannedUntil === PERMANENT) {
return PERMANENT;
}
return Math.max(0, (account.bannedUntil || 0) - now());
};
// the ban an account is under, for whoever may know why (the banned player,
// and whoever runs the server): {seconds, reason, by, since}, or null.
const banOf = account => {
const seconds = banRemaining(account);
return seconds === 0 ? null : {seconds, reason: account.banReason || bans.NO_REASON, by: account.bannedBy || "", since: account.bannedAt || null};
};
// the warnings an account has had in the last config.warningSilence.days
// (all of them when that is 0).
const recentWarnings = account => {
const days = (config.warningSilence || {}).days || 0;
const since = now() - days * SECONDS_PER_DAY;
return (account.warnings || []).filter(entry => !days || entry.at >= since).length;
};
// the minutes of silence a warning brings when it is the Nth recent one
// (config.warningSilence.steps, [[N, minutes], ...]); 0 for none.
const silenceForWarning = count => {
const step = ((config.warningSilence || {}).steps || []).find(([warnings]) => warnings === count);
return step ? step[1] : 0;
};
const isSilenced = account => account.silencedUntil === PERMANENT || (account.silencedUntil || 0) > now();
// seconds of silence left, PERMANENT, or 0 when the account may chat.
const silenceRemaining = account => {
if (account.silencedUntil === PERMANENT) {
return PERMANENT;
}
return Math.max(0, (account.silencedUntil || 0) - now());
};
module.exports = ({findOnline}) => {
// FacilitatorXtCommManager.facilitatorDisciplineResponse: what the affected
// player's client is told.
const discipline = (session, ...fields) => session.sendXt("fd", -1, ...fields);
// A "message from moderator" popup; also used to answer chat commands.
const notify = (session, text) => discipline(session, "fp", text, 0);
// a warning as the player sees it: the game's popup for its reason, or a
// custom one's words.
const showWarning = (session, entry) => {
if (entry.reason === CUSTOM_WARNING && entry.note) {
notify(session, `Warning: ${entry.note}`);
}
else {
discipline(session, "fw", WARNINGS[entry.reason] ?? WARNINGS.behavior);
}
};
const actions = {
kick(target) {
const session = findOnline(target.username);
if (!session) {
return false;
}
discipline(session, "fk", 0);
session.close();
return true;
},
// duration in seconds, or PERMANENT. the reason is for the banned
// player and whoever runs the server, nobody else; `by` is who gave it.
ban(target, duration, reason = "", by = "") {
target.bannedUntil = duration === PERMANENT ? PERMANENT : now() + duration;
target.banReason = bans.reasonText(reason);
target.bannedBy = by;
target.bannedAt = now();
accounts.save(target);
bans.record({account: target, action: "ban", seconds: duration, reason: target.banReason, by});
const session = findOnline(target.username);
if (session) {
discipline(session, "fb", 1, duration);
session.close();
}
return true;
},
unban(target, by = "") {
const was = banRemaining(target) !== 0;
delete target.bannedUntil;
delete target.banReason;
delete target.bannedBy;
delete target.bannedAt;
accounts.save(target);
if (was) {
bans.record({account: target, action: "unban", by});
}
return true;
},
// another reason for the ban they are under; its length stays.
banReason(target, reason, by = "") {
if (banRemaining(target) === 0) {
return false;
}
target.banReason = bans.reasonText(reason);
accounts.save(target);
bans.record({account: target, action: "reason", reason: target.banReason, by});
return true;
},
// duration in seconds, PERMANENT, or 0 to lift
silence(target, duration) {
target.silencedUntil = duration === PERMANENT ? PERMANENT : (duration > 0 ? now() + duration : 0);
accounts.save(target);
const session = findOnline(target.username);
if (session) {
// minutes, negative for "until further notice", 0 for "you may type again"
discipline(session, "fs", duration === PERMANENT ? PERMANENT : Math.ceil(duration / SECONDS_PER_MINUTE));
}
return true;
},
// their username will not do: they are put out, every saved sign-in
// ends, and the next sign-in asks for another name before it lets them
// in (lib/http.js, lib/manage.js). the name itself stays until then.
rejectName(target, by = "") {
target.nameRejected = {by, at: now()};
accounts.revokeTokens(target);
accounts.save(target);
actions.kick(target);
return true;
},
// taken back: the name will do after all.
acceptName(target) {
delete target.nameRejected;
accounts.save(target);
return true;
},
clearDen(target) {
dens.clearDen(target, findOnline);
return true;
},
// every post they wrote on anyone's Jammer Wall (lib/walls.js), their
// own included, and the replies to those, as deleting a post in the game
// takes its replies. returns {posts, replies, walls}.
clearWallPosts(author) {
const changed = [];
let posts = 0;
let replies = 0;
for (const owner of accounts.all()) {
const {wall} = owner;
const gone = new Set(wall.posts.filter(post => post.uid === author.id).map(post => post.x));
if (!gone.size) {
continue;
}
const kept = wall.posts.filter(post => !gone.has(post.x) && !gone.has(post.pp));
posts += gone.size;
replies += wall.posts.length - kept.length - gone.size;
const left = new Set(kept.map(post => post.x));
wall.posts = kept;
wall.hidden = wall.hidden.filter(id => left.has(id));
wall.modified = Date.now();
changed.push(owner);
}
if (changed.length) {
accounts.save(...changed);
}
return {posts, replies, walls: changed.length};
},
grantGems(target, amount) {
return actions.grantCurrency(target, CURRENCY_GEMS, amount, false);
},
// adds to (or with a negative amount takes from) one of a player's
// currencies: an index into CURRENCIES. `announce` has their game say so.
grantCurrency(target, currencyType, amount, announce = true) {
const name = CURRENCIES[currencyType];
if (!name) {
return false;
}
const before = target.currency[name] || 0;
target.currency[name] = Math.max(0, before + amount);
achievements.currencyChanged(target, name, target.currency[name] - before);
accounts.save(target);
const session = findOnline(target.username);
if (session) {
// ItemXtCommManager.currencyUpdateResponse: [currencyType, newAmount, reason]
session.sendXt("cu", -1, currencyType, target.currency[name], announce ? REASON_ANNOUNCE : 0);
}
return true;
},
message(target, text) {
const session = findOnline(target.username);
if (!session) {
return false;
}
notify(session, text);
return true;
},
// a warning: kept on the account (who, when, why and a note for staff),
// and shown with the game's own warning popup: now if they are in a
// room, else once they are next (greet). the Nth warning within
// config.warningSilence.days may also silence them for a while; a
// longer silence already on them is left alone.
// returns {count, online, silencedMinutes}, or null for a reason that
// is not one (or a custom warning with nothing to say).
warn(target, reason, by, note = "") {
const text = String(note).trim().slice(0, MAX_WARNING_NOTE);
if (!Object.hasOwn(WARNINGS, reason) || (reason === CUSTOM_WARNING && !text)) {
return null;
}
const session = findOnline(target.username);
const seen = Boolean(session && session.greeted);
const entry = {at: now(), by, reason, note: text, seen};
target.warnings = [...(target.warnings || []), entry].slice(-MAX_WARNINGS_KEPT);
accounts.save();
if (seen) {
showWarning(session, entry);
}
let silencedMinutes = silenceForWarning(recentWarnings(target));
const left = silenceRemaining(target);
if (silencedMinutes && left !== PERMANENT && left < silencedMinutes * SECONDS_PER_MINUTE) {
actions.silence(target, silencedMinutes * SECONDS_PER_MINUTE);
}
else {
silencedMinutes = 0;
}
return {count: target.warnings.length, online: Boolean(session), silencedMinutes};
},
// takes back their latest warning (one given by mistake). a silence it
// brought stays; that is lifted on its own (silence 0). returns the
// warning taken back, or null when there is none.
unwarn(target) {
const list = target.warnings || [];
if (!list.length) {
return null;
}
const removed = list[list.length - 1];
target.warnings = list.slice(0, -1);
accounts.save();
return removed;
},
};
// the client's moderator requests, refused whoever sends them. each
// expects [0] for failure; "fc" (clear den) has no reply at all.
const refuse = reply => session => session.sendXt(reply, -1, 0);
const handlers = {fk: refuse("fk"), fb: refuse("fb"), fs: refuse("fs"), fm: refuse("fm"), fg: refuse("fg"), fp: refuse("fp"), fc() {}};
// the first room has loaded (lib/world.js): a warning given while they
// were away is shown now, the latest only (the game has one warning
// popup), and all of them count as seen.
const greet = session => {
const unseen = (session.account.warnings || []).filter(entry => entry.seen === false);
if (!unseen.length) {
return;
}
unseen.forEach(entry => { entry.seen = true; });
accounts.save();
showWarning(session, unseen[unseen.length - 1]);
};
return {handlers, actions, greet, banRemaining, banOf, isSilenced, silenceRemaining, PERMANENT, WARNINGS: Object.keys(WARNINGS)};
};
Object.assign(module.exports, {isSilenced, banRemaining, banOf});