Files
burrow-server/lib/walls.js
T
Burrowdev c7efda7030 fix: eco items, wall, photo booth, chat emoji, den fixes
- the eco den items work: the Eco Shop sells the real eco items, solar
  panels and wind turbines placed in the den in use earn eco credits, lamps
  switch on while there is power for them, and the eco score earns the
  three eco plaques; a first look gives an account its first credits
- the item giver row opens the web item giver
- a painting that cannot be shown is the Burrow logo, not a wait for good
- Jammer Central's buttons work; What's New shows the newest Jamaa Journal
- the Jammer Wall opens even while the HUD is checking the player's own; a
  photo of an animal wearing nothing is kept; a wall photo of an animal the
  game does not know no longer stops the wall
- the photo booth's paid picture is answered
- emoji no longer push the line off centre; "\" keeps an emote or a
  ":name:" as typed; a repeated line with emoji is sent as it was said
- the emoji button hides with the HUD, not a moment after
- the join date on a player's card stays in its corner
- den items whose def is gone no longer garble the den and the inventory;
  custom pictures in a den no longer stop walking
- the den editor's switch and recycle buttons are always there
- the den inventory scrolls to an eleventh item
2026-10-23 23:00:00 +03:00

379 lines
15 KiB
JavaScript

"use strict";
const {logText} = require("./logtext.js");
const crypto = require("crypto");
const fs = require("fs");
const path = require("path");
const accounts = require("./accounts.js");
const chatFilter = require("./chatfilter.js");
const chatlog = require("./chatlog.js");
const masterpieces = require("./masterpieces.js");
const limits = require("./limits.js");
const {isUint} = require("./player.js");
const {isSilenced} = require("./moderation.js");
// Jammer Walls (client side: PlayerWallManager, PlayerWallGui,
// PlayerWallXtCommManager): a page per player where they and their visitors
// leave short messages, decorated by its owner.
//
// the client does this in two parts. over the game socket it asks for a
// token for one player's wall ("wt"); with that token it then talks JSON
// over HTTP to the address in the playerWallHost flashvar (POST /wall here):
// CHK "has it changed?", GET, PUT a message, DEL one, and a few more.
//
// A wall is account.wall: {privacy, posts, params, visits, hidden, modified,
// readAt}; a new account's empty one is made in lib/accounts.js.
// who may open a wall (BuddyCard.onPlayerWallPrivacyGet), as for dens.
const NOBODY = 0;
const BUDDIES = 1;
const EVERYONE = 2;
// PlayerWallManager.handleTokenResponse
const TOKEN_OK = 1;
const WALL_LOCKED = -1;
const BUDDIES_ONLY = -2;
const UNAVAILABLE = 0;
const TOKEN_MINUTES = 60;
const MAX_TOKENS = 20000;
const MAX_WALLS_OPEN = 20; // walls one player holds a token for at a time
const MAX_POSTS = 100;
const MAX_MESSAGE = 200; // the client's own box stops at 70
const MAX_PARAMS_JSON = 8000;
const MAX_HIDDEN = 500;
const USERNAME_SHOWN = 1;
// what an owner may set about their wall (PlayerWallGui.checkForWallParameterChanges):
// background, stickers, masterpieces, the photo booth picture, status line.
const OWNER_PARAMS = ["bg", "stk", "mp", "pb", "tag", "langId"];
// generic lists the wall window asks for: the wallpapers' buttons in the
// "customize" popup, the wallpapers themselves (a wall's "bg" parameter is a
// place in this list, 19 until its owner picks another), and stickers.
// like the Jam-A-Gram cards these lists only existed on the official
// servers; lib/wall-art.json holds what tools/find-art.py found on the
// CDN. without the wallpaper list a wall never appears at all.
const LIST_WALLPAPER_BUTTONS = 313;
const LIST_WALLPAPERS = 314;
const LIST_STICKERS = 646;
const RESOURCE_WALL_LIKES = "jammerwall";
const RESOURCE_MASTERPIECE_LIKES = "masterpiece";
const art = JSON.parse(fs.readFileSync(path.join(__dirname, "wall-art.json"), "utf8"));
const postsPerTenMinutes = limits.limiter(60, 600000);
const clean = text => String(text).replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, MAX_MESSAGE);
// A wall parameter is read by every visitor's game: a number or a short
// text, or a short list of those or of small flat objects of those (the
// stickers and paintings on a wall). nothing nested deeper, nothing long.
const MAX_PARAM_TEXT = 300;
const MAX_PARAM_ENTRIES = 60;
const scalar = value => value === null || typeof value === "boolean" || (typeof value === "number" && Number.isFinite(value))
|| (typeof value === "string" && value.length <= MAX_PARAM_TEXT);
const flat = value => scalar(value) || (typeof value === "object" && !Array.isArray(value)
&& Object.keys(value).length <= 12 && Object.values(value).every(scalar));
const plainParam = value => flat(value) || (Array.isArray(value) && value.length <= MAX_PARAM_ENTRIES && value.every(flat));
const whole = value => (Number.isInteger(Number(value)) ? Number(value) : 0);
// the photo booth picture ("pb", PlayerWallGui): one level deeper than the
// rest, {avatar: {id, color1.., eyes, pattern}, bgid, pet: {ts, lbits, ..} |
// null, items: [{id, color}, ..]}. it was turned away as too deep, and the
// owner's whole change with it: the photo never stayed. an animal wearing
// nothing has no items list at all (null), which was turned away too.
const MAX_PHOTO_ITEMS = 30;
const photoParam = value => value === null || (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length <= 6
&& Object.entries(value).every(([key, part]) => (key === "items" ? part === null || (Array.isArray(part) && part.length <= MAX_PHOTO_ITEMS && part.every(flat))
: key === "avatar" || key === "pet" ? part === null || flat(part) : scalar(part))));
module.exports = ({blocks, findOnline}) => {
const tokens = new Map(); // token -> {viewer: account id, owner: account id, expires}
const mayOpen = (owner, viewer) => {
if (owner === viewer) {
return TOKEN_OK;
}
if (owner.wall.privacy === NOBODY || blocks.either(owner, viewer) || !accounts.featureOn(owner, "wall") || !accounts.featureOn(viewer, "wall")) {
return WALL_LOCKED;
}
if (owner.wall.privacy === BUDDIES && !owner.buddies.includes(viewer.username.toLowerCase())) {
return BUDDIES_ONLY;
}
return TOKEN_OK;
};
// one token for a viewer and a wall, given again while it is good, and
// tokens for no more than MAX_WALLS_OPEN walls a viewer: asking in a loop
// gets the same few back and pushes nobody else's out.
const issue = (viewer, owner) => {
const mine = [];
for (const [token, entry] of tokens) {
if (entry.expires < Date.now()) {
tokens.delete(token);
}
else if (entry.viewer === viewer.id) {
mine.push([token, entry]);
}
}
const same = mine.find(([, entry]) => entry.owner === owner.id);
if (same) {
same[1].expires = Date.now() + TOKEN_MINUTES * 60000;
return same[0];
}
for (const [token] of mine.sort((one, other) => one[1].expires - other[1].expires).slice(0, Math.max(0, mine.length - MAX_WALLS_OPEN + 1))) {
tokens.delete(token);
}
if (tokens.size >= MAX_TOKENS) {
tokens.delete(tokens.keys().next().value);
}
const token = crypto.randomBytes(18).toString("hex");
tokens.set(token, {viewer: viewer.id, owner: owner.id, expires: Date.now() + TOKEN_MINUTES * 60000});
return token;
};
// {viewer, owner} accounts for a token still good, else null.
const resolve = token => {
const entry = typeof token === "string" ? tokens.get(token) : null;
if (!entry || entry.expires < Date.now()) {
return null;
}
const viewer = accounts.byId(entry.viewer);
const owner = accounts.byId(entry.owner);
return viewer && owner && mayOpen(owner, viewer) === TOKEN_OK ? {viewer, owner} : null;
};
// PlayerWallXtCommManager.getResponse: r = posts, n = notifications (replies
// to the viewer elsewhere; not kept here), p = the wall's parameters with
// the visit count and the time its owner last read it, t = last change.
const getReply = (owner, viewer) => {
const {wall} = owner;
const hidden = new Set(wall.hidden);
const reply = {
s: true,
r: wall.posts.filter(post => !hidden.has(post.x)),
n: [],
p: {...wall.params, visits: wall.visits, rdt: wall.readAt},
t: wall.modified,
};
if (viewer === owner) {
wall.readAt = Date.now();
}
return reply;
};
const put = (owner, viewer, body) => {
const colours = Array.isArray(body.ac) ? body.ac.slice(0, 3).map(String) : [];
const message = clean(body.m === undefined ? "" : body.m);
// the server's filter (lib/chatfilter.js) too.
const rule = message ? chatFilter.broken(message) : null;
if (rule) {
console.log(`[filter] ${logText(viewer.username)} on ${logText(owner.username)}'s wall: "${logText(message)}" (${logText(rule)})`);
chatlog.recordTo(viewer, chatlog.WALL, owner.username, chatlog.NOT_SENT + message);
const session = findOnline(viewer.username);
if (session) {
chatFilter.warn(session);
}
}
if (!message || rule || isSilenced(viewer) || !colours.every(isUint) || !postsPerTenMinutes.allow(viewer.id)) {
// PlayerWallGui.onMessageSent: cs -1 = "could not be posted"
return {PUT: {s: false, cs: -1}};
}
const post = {
x: crypto.randomBytes(8).toString("hex"),
m: message,
uid: viewer.id,
un: viewer.username,
um: USERNAME_SHOWN,
u: viewer.uuid,
s: whole(body.s), // pattern behind the message
c: whole(body.c), // its colour
t: Date.now(),
ai: whole(body.ai), // the poster's animal, for the little portrait
ac: colours.map(Number),
ae: whole(body.ae),
ap: whole(body.ap),
l: whole(body.l),
aci: whole(body.aci),
};
if (typeof body.pp === "string" && owner.wall.posts.some(other => other.x === body.pp)) {
post.pp = body.pp; // a reply to that post
}
// for the panels (lib/chatlog.js), as typed chat is.
chatlog.recordTo(viewer, chatlog.WALL, owner.username, message);
owner.wall.posts.push(post);
owner.wall.posts = owner.wall.posts.slice(-MAX_POSTS);
owner.wall.modified = post.t;
accounts.save(owner);
return {PUT: {s: true}, x: post.x, t: post.t, GET: getReply(owner, viewer)};
};
// POST /wall: one JSON command, one JSON answer.
const http = body => {
const cmd = String(body && body.cmd);
const who = resolve(body && body.t);
if (!who) {
// any command but PUT reads "e" at the top; PUT reads it inside PUT.
return cmd === "PUT" ? {PUT: {s: false, e: "token"}} : {s: false, e: "token"};
}
const {owner, viewer} = who;
const {wall} = owner;
const mine = owner === viewer;
switch (cmd) {
case "CHK":
return {s: true, t: wall.modified};
case "GET":
return getReply(owner, viewer);
case "PUT":
return put(owner, viewer, body);
case "DEL": {
// the owner may remove anything; anyone may remove what they wrote.
const post = wall.posts.find(candidate => candidate.x === body.x);
if (!post || !(mine || post.uid === viewer.id)) {
return {s: false};
}
wall.posts = wall.posts.filter(candidate => candidate !== post && candidate.pp !== post.x);
wall.modified = Date.now();
accounts.save(owner);
return {s: true};
}
case "GMB": // posts the owner chose to hide
return {s: true, r: mine ? wall.hidden : []};
case "AMB":
if (!mine || typeof body.x !== "string" || !wall.posts.some(post => post.x === body.x)) {
return {s: false};
}
wall.hidden = [...new Set([...wall.hidden, body.x])].slice(-MAX_HIDDEN);
accounts.save(owner);
return {s: true};
case "CLW":
if (!mine) {
return {s: false};
}
wall.posts = [];
wall.hidden = [];
wall.modified = Date.now();
accounts.save(owner);
return {s: true};
case "RMP": // masterpieces taken off the wall; there are none
case "ACK": // notifications marked as read; there are none
return {s: true};
default:
return {s: false, e: "unavailable"};
}
};
const byUuid = uuid => accounts.all().find(account => account.uuid === uuid) || null;
const likes = owner => owner.wall.likes || [];
const handlers = {
// the wall's like button (ResourceArrayXtCommManager): ["jammerwall",
// ownerUuid, myUuid, ...] -> [success, likedByMe, likes].
crg(session, roomId, [resource, ownerUuid]) {
if (resource === RESOURCE_MASTERPIECE_LIKES) {
// A masterpiece's likes: the second field is the painting's id.
const painting = masterpieces.get(ownerUuid);
session.sendXt("crg", -1, painting ? 1 : 0, painting && painting.likes.includes(session.account.id) ? 1 : 0, painting ? painting.likes.length : 0);
return;
}
const owner = resource === RESOURCE_WALL_LIKES ? byUuid(ownerUuid) : null;
session.sendXt("crg", -1, owner ? 1 : 0, owner && likes(owner).includes(session.account.id) ? 1 : 0, owner ? likes(owner).length : 0);
},
// the same, pressed: -> [success]. one like a player, and not one's own wall.
crp(session, roomId, [resource, ownerUuid]) {
if (resource === RESOURCE_MASTERPIECE_LIKES) {
session.sendXt("crp", -1, masterpieces.like(ownerUuid, session.account) ? 1 : 0);
return;
}
const owner = resource === RESOURCE_WALL_LIKES ? byUuid(ownerUuid) : null;
const allowed = Boolean(owner) && owner !== session.account && !likes(owner).includes(session.account.id)
&& mayOpen(owner, session.account) === TOKEN_OK;
if (allowed) {
owner.wall.likes = [...likes(owner), session.account.id];
accounts.save(owner);
}
session.sendXt("crp", -1, allowed ? 1 : 0);
},
// [username] -> [status, token, mayRead, mayWrite, username]
wt(session, roomId, [username]) {
const owner = accounts.byName(username);
const status = owner ? mayOpen(owner, session.account) : UNAVAILABLE;
if (status !== TOKEN_OK) {
session.sendXt("wt", -1, status);
return;
}
session.sendXt("wt", -1, TOKEN_OK, issue(session.account, owner), 1, 1, owner.username);
},
// [setting]: who may open my wall -> [success]
wss(session, roomId, [setting]) {
const value = Number(setting);
const valid = [NOBODY, BUDDIES, EVERYONE].includes(value);
if (valid) {
session.account.wall.privacy = value;
accounts.save(session.account);
}
session.sendXt("wss", -1, valid ? 1 : 0);
},
// [username] -> that player's setting
wsg(session, roomId, [username]) {
const owner = accounts.byName(username);
session.sendXt("wsg", -1, owner ? owner.wall.privacy : NOBODY);
},
// [JSON of the parameters that changed] -> [success]
wps(session, roomId, params) {
const {wall} = session.account;
let changes;
try {
// "%" cannot travel inside a field, so nothing was split apart.
changes = JSON.parse(params.join("%"));
}
catch (err) {
changes = null;
}
const merged = changes && typeof changes === "object" && !Array.isArray(changes) ? {...wall.params} : null;
for (const key of merged ? OWNER_PARAMS : []) {
if (changes[key] !== undefined) {
if (!(key === "pb" ? photoParam(changes[key]) : plainParam(changes[key]))) {
session.sendXt("wps", -1, 0);
return;
}
merged[key] = changes[key];
}
}
if (!merged || JSON.stringify(merged).length > MAX_PARAMS_JSON) {
session.sendXt("wps", -1, 0);
return;
}
wall.params = merged;
wall.modified = Date.now();
accounts.save(session.account);
session.sendXt("wps", -1, 1);
},
// [username]: "I looked at that wall" -> [success]
wci(session, roomId, [username]) {
const owner = accounts.byName(username);
if (owner && owner !== session.account && mayOpen(owner, session.account) === TOKEN_OK) {
owner.wall.visits++;
accounts.save(owner);
}
session.sendXt("wci", -1, owner ? 1 : 0);
},
};
// GenericListXtCommManager.handleMediaResponse: (mediaId, name) pairs;
// null when `listId` is not one of the wall window's lists.
const list = listId => {
const ids = {
[LIST_WALLPAPER_BUTTONS]: art.wallpapers.map(wallpaper => wallpaper.button),
[LIST_WALLPAPERS]: art.wallpapers.map(wallpaper => wallpaper.media),
[LIST_STICKERS]: art.stickers,
}[Number(listId)];
return ids ? ids.flatMap(id => [id, 0]) : null;
};
return {handlers, http, list};
};