Files
SnipzilandClaude Opus 5.5 e05565787f feat(server): staff tools, player-made items, picture safety, chat, multiplayer games
Staff and moderation
- Invisible staff (!invisible, "xiv"): hidden from players, half see-through
  to other staff, cannot chat while hidden. New permission staff.invisible.
- Summon and goto land on the player's exact spot ("xgt" before the move).
- Custom warnings (!warn PLAYER custom TEXT), shown in the warning popup.
- Mod notes (!note, !notes; lib/modnotes.js), on the player page and the
  dashboard.
- Granular permissions: per-role overrides (setting rolePermissions) and
  per-account grants and denies, applied live to staff who are playing
  (refreshStaff re-sends "xsp").
- Item control (lib/itemcontrol.js): lock items out of the item finder
  (!lock, !unlock, !locked), take an item from a player (!take), delete a
  custom item from the game and every inventory.
- GET items/find: search any item by name or id, marked locked, for the
  dashboards' quick lock.

Player-made items (lib/playeritems.js, "xcm")
- The Item Maker: make, rename, set the worn look, delete. 5 a day, 20 in all;
  names go through the name filter.
- Admin switches: Item Maker on/off, new items wait for approval, and a
  separate switch (on by default) that holds every player-uploaded picture
  for a moderator. Review queue for items.approve (moderator and up).
- Pictures (lib/itemart.js): PNG, JPEG and GIF cleaned of metadata, BMP
  converted to PNG; 512px and 300KB at most once cleaned.
- Worn as the maker chooses: a sticker (the picture) or a texture (the
  item's shape painted with the picture).

Picture safety
- A picture waiting for approval is never served publicly: /itemart/ 404s it,
  and it is only shown through /account|/mod|/admin/api/itemart to its maker
  and to staff who review or make items.
- A picture turned away or taken off is remembered by SHA-256 and cannot be
  uploaded again.
- Three strikes: three pictures turned away stops a player's uploads until a
  moderator lets them again. Staff can stop or allow uploads by hand.
- Accounts under 24 hours old cannot upload pictures (AJ_ITEM_ART_MIN_HOURS);
  uploads capped at 10 a day.
- Optional Google Cloud Vision SafeSearch (lib/image-moderation.js) for item
  pictures and Art Studio paintings when AJ_GOOGLE_VISION_API_KEY is set;
  fails closed when the scanner is unreachable.

Chat
- Emoji: Twemoji pictures served at /emoji/<codepoints>.png and cached in
  data/emoji (lib/emoji.js).
- Smart spam filtering before the word filter (lib/chatspam.js): long runs of
  one character, repeated words and lines, huge words and emoji floods are
  tidied, and repeats within 20 seconds are dropped.
- Typing indicator: "xty" is passed on to everyone in the room who can see
  the player, at most every 2 seconds.

Games (lib/minigames.js)
- Room games can be played together: a MULTIPLAYER table gives a game a
  waiting list (Single Player / Multiplayer). Players in the same room are
  matched, taken into the game together, and each one's moves are relayed to
  the others. Gem Breaker is the first: two players, "pos", "shoot" and
  "playerLost" relayed.
- Gem Breaker's start message now lists each player's id. Without it no
  player counted as local, so even single player could not aim.

Other
- Players stay connected through the client's new 75-minute AFK limit
  (idleTimeoutMs 80 minutes).
- Jam-a-Grams carry custom items and colours; Jammer Wall avatar photos are
  validated (walls.js photoParam).
- Weak passwords refused (common words, or containing the username).
- Code-scanning fixes: every logged value goes through logText
  (lib/logtext.js) against log injection, HSTS, path-only error logs, a
  single file read in lib/names.js.

Tests: items (pictures, approval, strikes, re-upload refusal, the hidden
waiting picture, the dashboard search), staff (invisibility, goto and summon
spots, custom warnings, notes), buddygames (two-player Gem Breaker, the
typing relay), and updates for main's verified badge and spawn rooms.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 21:44:10 -04:00

358 lines
14 KiB
JavaScript

"use strict";
const {logText} = require("./logtext.js");
// adventures. the engine is in the client (quest/QuestManager): it places
// the actors named in the room file and plays them. what happens when was
// decided by scripts on the official server, which no file holds, so each
// adventure here is a script written by hand from a recording of the
// official game (tools/recorder.js): lib/adventures/<name>.js says what to
// send when the player triggers an actor, answers one, and so on.
//
// one player to an adventure, each in rooms of their own.
const accounts = require("./accounts.js");
const achievements = require("./achievements.js");
const config = require("../config.js");
const dens = require("./dens.js");
const {activeAvatar} = require("./player.js");
const scripts = new Map([
require("./adventures/training-grounds.js"),
require("./adventures/return-of-the-phantoms.js"),
].map(script => [script.defId, script]));
const LIST_ADVENTURES = 201; // the adventure list's rows: script def ids
const ROOM_TYPE_QUEST = 7;
const CURRENCY_GEMS = 0;
const MAX_LEVEL = 100;
const HEARTS = 6; // a player's health, and what a phantom's zap takes of it
const ZAP = 2;
const GIFT_DEN_ITEM = 1;
const GIFT_GEMS = 3;
// the XP a level starts at. the recordings show three levels: 50 XP to
// level 1, 200 more to level 2, and about 450 more to level 3 (5 XP into
// level 2 shown as 1%, 55 as 12%). that is 50 times the level squared, and
// the levels after are taken to go on so.
const levelXp = level => 50 * level * (level + 1) * (2 * level + 1) / 6;
const levelFor = xp => {
let level = 0;
while (level < MAX_LEVEL && xp >= levelXp(level + 1)) {
level++;
}
return level;
};
const xpOf = avatar => Math.max(avatar.questXp || 0, levelXp(avatar.questLevel || 0));
// how far through its level, in percent (QuestManager.handleXpUpdate).
const percent = xp => {
const level = levelFor(xp);
return Math.round((xp - levelXp(level)) * 100 / (levelXp(level + 1) - levelXp(level)));
};
module.exports = ({enterRoom, joinRoom, tell}) => {
const playing = session => (session.quest && session.room === session.quest.room ? session.quest : null);
const tools = (session, quest) => {
const q = {
me: session.id,
vars: quest.vars,
send(cmd, ...fields) {
if (playing(session) === quest) {
session.sendXt(cmd, -1, ...fields);
}
},
after(ms, action) {
setTimeout(() => {
try {
if (playing(session) === quest) {
action();
}
}
catch (err) {
console.error(`[adventure] ${quest.script.title}: a timed step failed: ${err.stack}`);
}
}, ms).unref();
},
// QuestManager.handleXpUpdate: [earned, total, level before, level
// now, percent, the actor the number floats over].
xp(amount, actor = "") {
const avatar = activeAvatar(session.account);
const before = xpOf(avatar);
const level = levelFor(before);
avatar.questXp = before + amount;
avatar.questLevel = levelFor(avatar.questXp);
if (amount > 0) {
accounts.save(session.account);
}
q.send("quxp", amount, avatar.questXp, level, avatar.questLevel, percent(avatar.questXp), actor);
if (avatar.questLevel > level) {
// A new level: full health, the animal's numbers, then the level.
quest.hearts = HEARTS;
q.send("quhp", session.id, 100, HEARTS, HEARTS, HEARTS);
q.send("qusu", 10, 200, 1, 200);
q.send("qulu", session.id, avatar.questLevel);
}
},
// what the player carries (an actor's name), and using it up:
// command 7 takes it out of their hands.
held: () => quest.held,
use() {
quest.held = null;
q.send("qcmd", 7);
},
// goes to another of the adventure's rooms, to stand at `spawn`.
room(key, spawn) {
const place = quest.script.rooms[key];
q.send("qcmd", 14, 0, spawn);
const room = enter(session, quest.script, place);
if (room) {
quest.room = room;
q.send("qmusic", place.music);
}
},
// the prizes to choose from at the end: [GIFT_DEN_ITEM, def id, 0]
// or [GIFT_GEMS, amount, amount] each (QuestManager.handlePickGift).
offer(gifts) {
quest.gifts = gifts;
q.send("qpgift", gifts.length, 0, ...gifts.flat());
},
level: () => levelFor(xpOf(activeAvatar(session.account))),
gems(amount) {
const {account} = session;
account.currency.gems = (account.currency.gems || 0) + amount;
achievements.currencyChanged(account, "gems", amount);
accounts.save(account);
session.sendXt("cu", -1, CURRENCY_GEMS, account.currency.gems, 0);
},
};
return q;
};
const run = (session, kind, key, ...args) => {
const quest = playing(session);
if (!quest) {
return;
}
const table = quest.script.on[kind];
// A script may answer a whole family of actors: [pattern, handler] in
// "<kind>Like", the handler given the actor's name.
const family = key === null ? null : (quest.script.on[`${kind}Like`] || []).find(([pattern]) => pattern.test(key));
const handler = key === null ? table : (table || {})[key];
if (handler) {
handler(tools(session, quest), ...args);
}
else if (family) {
family[1](tools(session, quest), key, ...args);
}
else if (key !== null && kind !== "pickedUp") {
console.log(`[adventure] ${logText(quest.script.title)}: nothing written for "${logText(kind)} ${logText(key)}"`);
}
};
// QuestXtCommManager.questStartResponse: [script def, players, actor
// count, when the script was written, then for each actor its name,
// type, def id (a name for type 16), state, visible, needs a click, path,
// and the state of its artwork]. the room join follows it.
const enter = (session, script, place) => enterRoom(session, `quest_${session.id}_${script.defId}_${Date.now()}__${place.room}`,
place.room, place.name, config.shards[0].id, {roomType: ROOM_TYPE_QUEST, secondaryDefId: script.defId, nameStringId: place.nameStringId,
joinFlags: [0, 1, 0, 1, 0]}); // a game room, and temporary
const start = (session, script) => {
const returnTo = session.room.name;
session.questLobby = null;
session.sendXt("qs", session.room.id, script.defId, 1, script.actors.length, script.written, ...script.actors.flat());
session.sendXt("qcmd", -1, 38, script.objective);
session.sendXt("qmusic", -1, script.rooms.start.music);
const room = enter(session, script, script.rooms.start);
if (!room) {
return;
}
session.quest = {script, room, returnTo, vars: {}, loaded: false, held: null, hearts: HEARTS, gifts: null, gift: null};
tools(session, session.quest).xp(0);
};
const handlers = {
// QuestXtCommManager.sendQuestCreateJoinPublic: [room, script def,
// difficulty, 0]. A refusal is [0, reason]; "NV" is "Failed to join!".
qj(session, roomId, [, defId]) {
const script = scripts.get(Number(defId));
if (!script || !session.room || playing(session)) {
session.sendXt("qj", -1, 0, "NV");
if (!script) {
tell(session, "That adventure is not on this server yet.");
}
return;
}
if (!script.lobby) {
start(session, script);
return;
}
// an adventure for several waits for its players: [1, 1, script
// def, 0], then who is waiting ("qw"). the player's own Start
// button, or the client by itself, then asks to begin ("qs").
session.questLobby = script;
session.sendXt("qj", session.room.id, 1, 1, script.defId, 0);
session.sendXt("qw", session.room.id, session.id);
},
// QuestXtCommManager.sendQuestStartRequest: [room]
qs(session) {
if (session.questLobby && session.room && !playing(session)) {
start(session, session.questLobby);
}
},
// ... and leaving the wait
qjx(session) {
session.questLobby = null;
session.sendXt("qjx", -1, 1);
},
// the private lobby asks the same way: [room, script def, difficulty].
qjc(session, roomId, params) {
handlers.qj(session, roomId, params);
},
// "What was moved?", once the room is up: nothing is answered, and it
// is where a script begins.
qmi(session) {
const quest = playing(session);
if (quest && !quest.loaded) {
quest.loaded = true;
run(session, "loaded", null);
}
},
// [actor, 0]: walked into, or clicked
qat(session, roomId, [actor]) {
run(session, "trigger", String(actor));
},
// [actor, ?, answer]: a talk read to its end
qaskr(session, roomId, [actor]) {
run(session, "answer", String(actor));
},
// [actor, state]: an actor's own change of mind (a phantom noticing the
// player, giving up), which the server only passes round:
// QuestManager.handleQuestActorRequestSeekResponse [actor, state, who].
qas(session, roomId, [actor, state]) {
if (playing(session) && /^-?\d+$/.test(state)) {
session.sendXt("qas", -1, String(actor), Number(state), session.id);
}
},
// QuestXtCommManager.questPickUpItem: [actor, who]. answered [1, actor,
// who] (QuestManager.handlePickUpItem); with something in hand already
// it is [0, actor], which has the client ask whether to drop that.
qpup(session, roomId, [actor]) {
const quest = playing(session);
const name = String(actor);
if (!quest || !quest.script.actors.some(row => row[0] === name)) {
return;
}
const refill = quest.script.refills;
if (quest.held && !(refill && refill.test(quest.held) && refill.test(name))) {
session.sendXt("qpup", -1, 0, name, "null");
return;
}
quest.held = name;
session.sendXt("qpup", -1, 1, name, session.id);
run(session, "pickedUp", name);
},
// "Yes, drop it": [x, y, the actor wanted, who]. what was held is put
// down there ([4, actor, who, x, y, 0, 150, who, the one wanted]) and
// the other picked up.
qdroppup(session, roomId, [x, y, actor]) {
const quest = playing(session);
const name = String(actor);
if (!quest || !quest.held || ![x, y].every(value => /^-?\d+$/.test(value)) || !quest.script.actors.some(row => row[0] === name)) {
return;
}
session.sendXt("qpup", -1, 4, quest.held, session.id, Number(x), Number(y), 0, 150, session.id, name);
quest.held = name;
session.sendXt("qpup", -1, 1, name, session.id);
run(session, "pickedUp", name);
},
// A phantom has zapped the player: [phantom, who, x, y], which goes
// back after the player's health, [who, percent, change, hearts, of]
// (QuestManager.handleHealthUpdate). at none the player is down ("qpd").
qpzap(session, roomId, [phantom, , x, y]) {
const quest = playing(session);
if (!quest || quest.hearts <= 0 || ![x, y].every(value => /^-?\d+$/.test(value))) {
return;
}
quest.hearts = Math.max(0, quest.hearts - ZAP);
session.sendXt("quhp", -1, session.id, Math.floor(quest.hearts * 100 / HEARTS), -ZAP, quest.hearts, HEARTS);
if (quest.hearts === 0) {
session.sendXt("qpd", -1, session.id);
}
session.sendXt("qpzap", -1, String(phantom), session.id, Number(x), Number(y));
},
// ... and asks to get up again: [0, x, y], a place of the client's
// choosing. [who, percent, hearts three times, x, y], then "qprr" 6.
qprr(session, roomId, [, x, y]) {
const quest = playing(session);
if (!quest || quest.hearts > 0 || ![x, y].every(value => /^-?\d+$/.test(value))) {
return;
}
quest.hearts = HEARTS;
session.sendXt("qrspn", -1, session.id, 100, HEARTS, HEARTS, HEARTS, Number(x), Number(y));
session.sendXt("qprr", -1, HEARTS);
},
// the prize picked from those offered: [which, ?, ?], then "done".
qpgift(session, roomId, [index]) {
const quest = playing(session);
if (quest && quest.gifts && quest.gift === null && /^\d+$/.test(index) && Number(index) < quest.gifts.length) {
quest.gift = quest.gifts[Number(index)];
}
},
qpgiftdone(session) {
const quest = playing(session);
if (!quest || !quest.gift) {
return;
}
const [kind, value] = quest.gift;
quest.gifts = quest.gift = null;
if (kind === GIFT_DEN_ITEM) {
dens.giveDenItem(session.account, value);
dens.sendDenItems(session);
}
else if (kind === GIFT_GEMS) {
tools(session, quest).gems(value);
}
run(session, "gifted", null);
},
// [plant, phantom]: a chomper plant has caught one. nothing comes back.
qpa() {},
// [plant, phantom, x, y]: ... and eaten it
qep(session, roomId, [plant, phantom, x, y]) {
if (playing(session) && [x, y].every(value => /^-?\d+$/.test(value))) {
run(session, "eaten", null, String(plant), String(phantom), Number(x), Number(y));
}
},
// [actor, 0] is answered by the script when the chest is triggered
// ("qat"); [actor, 1] is the chest opened.
qatt(session, roomId, [actor, opened]) {
if (opened === "1") {
run(session, "opened", String(actor));
}
},
// QuestXtCommManager.sendQuestExit. the official game goes to the
// Adventure Base Camp; here it is back to where the player came from.
qx(session) {
const quest = playing(session);
if (quest) {
session.quest = null;
joinRoom(session, quest.returnTo);
}
},
};
return {
handlers,
list: listId => (Number(listId) === LIST_ADVENTURES ? [...scripts.keys()] : null),
};
};
Object.assign(module.exports, {levelXp, MAX_LEVEL});