mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-18 17:27:50 -05:00
Add owner/developer room-effect controls and chat shortcuts, staff movement that bypasses full or locked destinations, in-game moderation entry points, theatre video synchronization, and shared room effects. Restore game and trade popups, reliably award refreshments and game rewards, support pet play outside parties, correct den placement categories, improve den item persistence, and refresh custom-item and masterpiece behavior. Harden room, party, pet, minigame, and item state handling with matching feature and restored-system regression coverage.
861 lines
37 KiB
JavaScript
861 lines
37 KiB
JavaScript
"use strict";
|
|
|
|
const accounts = require("./accounts.js");
|
|
const achievements = require("./achievements.js");
|
|
const defpacks = require("./defpacks.js");
|
|
const buddyGames = require("./buddygames.js");
|
|
const masterpieces = require("./masterpieces.js");
|
|
const dens = require("./dens.js");
|
|
const limits = require("./limits.js");
|
|
const {activeAvatar, addClothing, sendClothingAdded} = require("./player.js");
|
|
|
|
// minigames (client side: MinigameManager, MinigameXtCommManager and the
|
|
// game.* classes). the games themselves are compiled into the client; what
|
|
// the official server kept was the table saying which game def id is which
|
|
// game (the "game" defPack is gone from the CDN) and the session around a
|
|
// game: the room it runs in, the start signal, gem awards, and for some
|
|
// games a few messages of their own.
|
|
//
|
|
// lib/games.json is that table, put back together from what still names the
|
|
// ids: arcade-machine den items (gameDefId and a name), the room files (which
|
|
// id stands where), the names GameCardPopup has for each game class, and the
|
|
// achievement defs (which user vars a game counts in). entries:
|
|
// id game def id
|
|
// swf the game's key in game.IncludeMinigames
|
|
// title its name; sent as the id of the localization string that says so
|
|
// type 0 runs in a window over the room ("in-room"), 1 replaces the room
|
|
// vars user vars: games played, and two the game uses as it likes
|
|
// pet pet species the player must have out (the pet games)
|
|
// start what the game waits for after it says "ready": see START
|
|
// ready false: needs more from the server than is here yet; not playable
|
|
// tickets a carnival game: how many points of its score make one ticket
|
|
// icon media id of its picture in the HUD's Games window; the games with
|
|
// one are the ones that window lists
|
|
// buddy true: one of the eight games two players play from a player's
|
|
// card (lib/buddygames.js). their ids are ours: nothing in the
|
|
// client names them, and the official table is gone.
|
|
// card a buddy game's picture, on the card's game tab and in the
|
|
// invitation
|
|
//
|
|
// every other game is played alone (minPlayers = maxPlayers = 1): the
|
|
// multiplayer ones each have a protocol of their own between the players.
|
|
|
|
const games = new Map(require("./games.json").map(game => [game.id, game]));
|
|
|
|
const IN_ROOM = 0;
|
|
const MAX_GEMS_PER_AWARD = 5000;
|
|
const MAX_MASTERY_PER_AWARD = 100;
|
|
const MASTERY_FULL = 100;
|
|
const CURRENCY_GEMS = 0;
|
|
const CLAW_COST = 5; // gems a go
|
|
const CLAW_WIN_CHANCE = 0.4;
|
|
const SKY_HIGH_PRIZE_CHANCE = 0.5;
|
|
const SAFETY_QUIZ_PRIZE = 1179; // den item, SafetyQuiz.init
|
|
const TOUCH_POOL_PRIZES = [867, 869, 872, 868, 870, 871]; // den items, TouchPool.init
|
|
const LANG_ENG = 0;
|
|
const FALLBACK_TITLE = "Games";
|
|
const MAX_INFO_REQUEST = 100;
|
|
// A game id the table does not have: it still gets its sign, and says
|
|
// "not ready" when clicked.
|
|
const UNKNOWN_GAME = {swf: "", title: FALLBACK_TITLE, type: 0, ready: false};
|
|
const INVASION_WIN = 11; // MicroGameInvasion.keptItem
|
|
const CARNIVAL_COST = 5; // gems a go
|
|
const MAX_TICKETS_PER_GO = 300;
|
|
const CURRENCY_TICKETS = 1;
|
|
const INVASION_COST = 10; // gems a go, as the machine's own screen says
|
|
const SMOOTHIE_COLOURS = new Set(["purple", "orange", "red", "yellow"]);
|
|
// The game's attachment state is client-defined (for example, the cocoa
|
|
// recipe). It is not an item id and must never become protocol markup.
|
|
const attachmentExtra = value => String(value ?? "").replace(/[\r\n%,]/g, "").slice(0, 128);
|
|
|
|
const awardsPerMinute = limits.limiter(120, 60000);
|
|
const invitesPerMinute = limits.limiter(20, 60000);
|
|
const LEFT_NOTICE_DELAY_MS = 2500;
|
|
const GAME_PAINTING = 51;
|
|
const GAME_PIXEL_PAINTING = 139;
|
|
// marbles sends the shooter's aim four times a second; nothing needs more.
|
|
const messagesPerMinute = limits.limiter(900, 60000);
|
|
|
|
// the "start" message a game waits for once it has said it is ready.
|
|
const START = {
|
|
seed: () => [serial()],
|
|
// then each player's sfs id and a field the game skips: a game knows
|
|
// which player is its own by the id (GemBreakerPlayer.init), and only
|
|
// that one aims and shoots.
|
|
seedAndPlayers: game => [serial(), game.players.length, ...game.players.flatMap(player => [player.id, 0])],
|
|
};
|
|
|
|
// the room games several players play together: "Multiplayer" on the
|
|
// game's waiting list (MinigameManager.setupWaitListPopup), for players in
|
|
// the same room. each client plays the same game from the same start, and
|
|
// the server passes each player's moves on to the others: `relay` names
|
|
// the messages passed on, true for those that go with the sender's sfs id
|
|
// first. a full list starts the game.
|
|
const MULTIPLAYER = {
|
|
// GemBreaker.message: "pos" [sfsUserId, cannon angle], "shoot" [the shot's
|
|
// nine numbers], "playerLost" [the next round's seed]. two players, a
|
|
// field each, first to win two rounds.
|
|
GemBreaker: {max: 2, relay: {pos: true, shoot: false, playerLost: false}},
|
|
};
|
|
const MAX_RELAYED_FIELDS = 12;
|
|
const RELAYED_FIELD = /^[-0-9a-zA-Z.]{1,32}$/;
|
|
|
|
// serial numbers the client mixes into its award messages; any number will do.
|
|
function serial() {
|
|
return 1 + Math.floor(Math.random() * 1000000);
|
|
}
|
|
|
|
let nextGameRoomId = 500000; // well clear of the world's room ids
|
|
|
|
module.exports = ({tell, leaveRoom, findOnline, blocks, watchers}) => {
|
|
// MinigameInfo.init, the 19 fields the "mi" reply carries for a game.
|
|
const info = game => [
|
|
game.id,
|
|
// never 0: the client throws on a string it cannot find.
|
|
defpacks.stringId(game.title) || defpacks.stringId(FALLBACK_TITLE),
|
|
game.swf, // extName
|
|
game.swf, // swfName
|
|
// min and max players: more than one gives the game a waiting list
|
|
// with "Single Player" and "Multiplayer" (lib/minigames.js MULTIPLAYER).
|
|
game.buddy ? 2 : MULTIPLAYER[game.swf] ? MULTIPLAYER[game.swf].max : 1,
|
|
game.buddy ? 2 : MULTIPLAYER[game.swf] ? MULTIPLAYER[game.swf].max : 1,
|
|
0, // max spectators
|
|
game.type,
|
|
// the game card: the title picture on the "play" popup (not known), and
|
|
// for a buddy game the picture in the invitation.
|
|
game.card || 0,
|
|
...(game.vars || [0, 0, 0]),
|
|
game.buddy ? 1 : 0, // ready for player-versus-player: listed on players' cards
|
|
1, // gem multiplier
|
|
game.pet || 0,
|
|
0, // pro mode user var
|
|
0, // leaderboard user var
|
|
game.icon || game.card || 0, // its picture in the Games window or on a card's game tab
|
|
0, // required avatar type
|
|
];
|
|
|
|
// an invitation to a buddy game that has not been answered: both players
|
|
// have {def, sender, target} as `invite`. dropping it tells the other
|
|
// side "no" (MinigameManager.pvpResponse: [gameDefId, 1]).
|
|
const dropInvite = (session, tellOther = true) => {
|
|
const {invite} = session;
|
|
if (!invite) {
|
|
return;
|
|
}
|
|
invite.sender.invite = invite.target.invite = null;
|
|
const other = invite.sender === session ? invite.target : invite.sender;
|
|
if (tellOther) {
|
|
other.sendXt("mp", -1, invite.def.id, 1);
|
|
}
|
|
};
|
|
|
|
// A buddy game's bubble over a player's head, which anyone else in the
|
|
// room can click to play them (UserCommXtCommManager.sendCustomPVPMessage:
|
|
// a chat line "on|off" of type 12 with the game's id after it). the client
|
|
// reads it back as "on|<gameDefId>" or "off", and its sender waits for
|
|
// their own before going on. `session.pvpBubble` is the game's id.
|
|
const BUBBLE = "12";
|
|
const bubbleLine = session => [`on|${session.pvpBubble}`, BUBBLE, 0];
|
|
const bubbleSeers = session => watchers(session).filter(other => !blocks.either(other.account, session.account));
|
|
// the bubble goes for everyone else. the player's own "off" waits, when
|
|
// they are in a game, till they are out of it: it would end the game the
|
|
// client has only just set up (MinigameManager.readySelfForPvpGame).
|
|
const dropBubble = session => {
|
|
if (!session.pvpBubble) {
|
|
return;
|
|
}
|
|
session.pvpBubble = null;
|
|
if (session.room) {
|
|
for (const other of bubbleSeers(session)) {
|
|
other.sendXt("uc", session.room.id, session.id, "off", BUBBLE);
|
|
}
|
|
}
|
|
};
|
|
const bubbleOff = session => {
|
|
if (session.game) {
|
|
session.bubbleOffOwed = true;
|
|
}
|
|
else if (session.room) {
|
|
session.bubbleOffOwed = false;
|
|
session.sendXt("uc", session.room.id, session.id, "off", BUBBLE);
|
|
}
|
|
};
|
|
const bubble = (session, word, gameDefId) => {
|
|
if (word !== "on") {
|
|
dropBubble(session);
|
|
bubbleOff(session);
|
|
return;
|
|
}
|
|
const def = games.get(Number(gameDefId));
|
|
if (!def || !def.buddy || !Object.hasOwn(buddyGames, def.swf) || !session.room || session.game || session.invite
|
|
|| session.invisible || !accounts.featureOn(session.account, "gameInvites")) {
|
|
if (session.room && !session.game) {
|
|
tell(session, session.invisible ? "Nobody can see you to play with you." : "You cannot ask for a game right now.");
|
|
}
|
|
dropBubble(session);
|
|
bubbleOff(session);
|
|
return;
|
|
}
|
|
session.pvpBubble = def.id;
|
|
for (const other of [session, ...bubbleSeers(session)]) {
|
|
other.sendXt("uc", session.room.id, session.id, ...bubbleLine(session));
|
|
}
|
|
};
|
|
// a bubble that is up, for a player who has just been shown its owner.
|
|
const showBubble = (to, owner) => {
|
|
if (owner.pvpBubble && owner.room && to !== owner && !blocks.either(to.account, owner.account)) {
|
|
to.sendXt("uc", owner.room.id, owner.id, ...bubbleLine(owner));
|
|
}
|
|
};
|
|
|
|
// Food-machine games reward a short-lived avatar attachment. Replying
|
|
// with "_a" is important: MinigameManager turns it into the same local
|
|
// attachment action used by den objects, which then sends the normal
|
|
// user-communication packet to the room. Sending that packet ourselves
|
|
// skips the local state and leaves the player with nothing visible.
|
|
const grantAttachment = (session, game, reply, emoticonDefId, extra = "") => {
|
|
if (game.attachmentGranted) {
|
|
return;
|
|
}
|
|
const state = attachmentExtra(extra);
|
|
if (!defpacks.emoticonMediaId(emoticonDefId)) {
|
|
return;
|
|
}
|
|
game.attachmentGranted = true;
|
|
reply("_a", emoticonDefId, state);
|
|
};
|
|
|
|
// takes the player out of the game they are in, if any, and out of an
|
|
// invitation.
|
|
const leave = session => {
|
|
dropInvite(session);
|
|
const {game} = session;
|
|
if (!game) {
|
|
return;
|
|
}
|
|
session.game = null;
|
|
if (session.bubbleOffOwed) {
|
|
bubbleOff(session);
|
|
}
|
|
game.players = game.players.filter(player => player !== session);
|
|
if (game.lobby) {
|
|
if (game.players.length === 0) {
|
|
lobbies.delete(game.lobby);
|
|
}
|
|
tellLobby(game);
|
|
return;
|
|
}
|
|
// the games' own "player left": [sfsUserId]. A buddy game takes it for
|
|
// a win, so the one still looking at the result of a game that has been
|
|
// decided is not told. three of them only the clients know the end of
|
|
// (lib/buddygames.js), and at their end both players leave within a
|
|
// moment of each other: there the news waits a little, and reaches
|
|
// only a player who is still in the game by then.
|
|
const tellOthers = () => {
|
|
for (const other of game.players.filter(player => player.game === game)) {
|
|
other.sendXt("ml", game.roomId, session.id);
|
|
}
|
|
};
|
|
if (!game.match) {
|
|
tellOthers();
|
|
}
|
|
else if (!game.match.finished) {
|
|
setTimeout(() => {
|
|
try {
|
|
tellOthers();
|
|
}
|
|
catch (err) {
|
|
console.error(`[minigames] could not tell of a player leaving: ${err.message}`);
|
|
}
|
|
}, LEFT_NOTICE_DELAY_MS).unref();
|
|
}
|
|
};
|
|
|
|
// MinigameManager.startGame: [playerCount, sfsUserId..., then for each
|
|
// player an id and their username, then whatever the game adds], which
|
|
// the game reads as "ms". the id is the animal's (perUserAvId): the games
|
|
// that draw their players ask for that animal by it.
|
|
const start = game => {
|
|
game.started = true;
|
|
for (const player of game.players) {
|
|
player.sendXt("ms", game.roomId, game.players.length, ...game.players.map(other => other.id),
|
|
...game.players.flatMap(other => [activeAvatar(other.account).perUserAvId, other.account.username]),
|
|
...(game.startData || []));
|
|
}
|
|
};
|
|
|
|
// RoomXtCommManager.roomJoinResponse for a game's own room: a temporary
|
|
// game room, which for a game that runs in a window is a "sub room"
|
|
// beside the room the player stays in. then the serial numbers the game's
|
|
// first awards are to be signed with (MinigameManager.minigameGems,
|
|
// minigamePetMastery) and who is in the game (joinGameResponse).
|
|
const seat = (session, game, music) => {
|
|
const avatar = activeAvatar(session.account);
|
|
// off to a game: a bubble still up goes (and its owner is told after).
|
|
if (session.pvpBubble) {
|
|
dropBubble(session);
|
|
session.bubbleOffOwed = true;
|
|
}
|
|
session.game = game;
|
|
session.sendXt("rj", -1, 1, `game${game.def.id}_${game.roomId}`, game.roomId, game.players.length, game.players.length, 0, 0,
|
|
0, 1, 0, 1, game.def.type === IN_ROOM ? 1 : 0, // isPrivate, isGame, isLimbo, isTemp, isSubRoom
|
|
"", 0, avatar.perUserAvId, avatar.petInvId, LANG_ENG, music, 1);
|
|
session.gemSerial = serial();
|
|
session.masterySerial = serial();
|
|
session.sendXt("mg", game.roomId, session.gemSerial, 1);
|
|
session.sendXt("ma", game.roomId, session.masterySerial, 0);
|
|
session.sendXt("mj", game.roomId, ...game.players.map(player => player.id));
|
|
};
|
|
|
|
// the waiting lists of multiplayer room games: "<gameDefId> <room>" -> a
|
|
// game not started yet. one is answered "mj" from the room the players
|
|
// wait in, with who waits: the client draws them from that room, so they
|
|
// stay in it till the list is full.
|
|
const lobbies = new Map();
|
|
const tellLobby = game => {
|
|
for (const player of game.players) {
|
|
player.sendXt("mj", game.waitRoom.id, ...game.players.map(other => other.id));
|
|
}
|
|
};
|
|
const joinLobby = (session, def, multi) => {
|
|
const key = `${def.id} ${session.room.name}`;
|
|
let game = lobbies.get(key);
|
|
if (game && game.players.some(player => blocks.either(player.account, session.account))) {
|
|
session.sendXt("mj", -1, "as", 0);
|
|
tell(session, "Someone already waiting for that game is not someone you play with. Try again later.");
|
|
return;
|
|
}
|
|
if (!game) {
|
|
game = {roomId: nextGameRoomId++, def, multi, players: [], started: false, ready: new Set(), lobby: key, waitRoom: session.room};
|
|
lobbies.set(key, game);
|
|
}
|
|
game.players.push(session);
|
|
session.game = game;
|
|
tellLobby(game);
|
|
if (game.players.length >= multi.max) {
|
|
lobbies.delete(key);
|
|
game.lobby = null;
|
|
for (const player of game.players) {
|
|
const music = player.room ? player.room.customMusicDef : 0;
|
|
if (def.type !== IN_ROOM) {
|
|
leaveRoom(player);
|
|
}
|
|
seat(player, game, music);
|
|
}
|
|
start(game);
|
|
}
|
|
};
|
|
|
|
// a move in a multiplayer room game, passed on to the other players.
|
|
const relay = (session, game, word, params) => {
|
|
const withId = game.multi.relay[word];
|
|
if (!game.started || params.length > MAX_RELAYED_FIELDS || !params.every(field => RELAYED_FIELD.test(String(field)))
|
|
|| !messagesPerMinute.allow(session.account.id)) {
|
|
return;
|
|
}
|
|
for (const other of game.players) {
|
|
if (other !== session) {
|
|
other.sendXt("mm", game.roomId, word, ...(withId ? [session.id] : []), ...params);
|
|
}
|
|
}
|
|
};
|
|
|
|
// starts a buddy game between two players (lib/buddygames.js says what
|
|
// `match` is). it runs in a window over whatever room each is in.
|
|
const startMatch = (def, sender, target) => {
|
|
const referee = buddyGames[def.swf];
|
|
const game = {roomId: nextGameRoomId++, def, players: [sender, target], started: false, ready: new Set(),
|
|
startData: referee.startData ? referee.startData() : []};
|
|
const seats = [sender, target];
|
|
game.match = {
|
|
ids: seats.map(session => session.id),
|
|
state: null,
|
|
finished: false,
|
|
ready: new Set(),
|
|
send: (player, ...fields) => seats[player].sendXt("mm", game.roomId, ...fields),
|
|
broadcast: (...fields) => seats.forEach(session => session.sendXt("mm", game.roomId, ...fields)),
|
|
over() {
|
|
game.match.finished = true;
|
|
},
|
|
seatOf: session => seats.indexOf(session),
|
|
};
|
|
for (const session of seats) {
|
|
seat(session, game, session.room ? session.room.customMusicDef : 0);
|
|
}
|
|
start(game);
|
|
};
|
|
|
|
const matchMessage = (session, game, word, params) => {
|
|
const {match} = game;
|
|
const referee = buddyGames[game.def.swf];
|
|
const player = match.seatOf(session);
|
|
// nothing more is refereed once the game is decided or a player has gone.
|
|
if (player === -1 || match.finished || game.players.length < 2 || !messagesPerMinute.allow(session.account.id)) {
|
|
return;
|
|
}
|
|
if (word === "ready") {
|
|
// both say so before the first round, and again before each further one.
|
|
if (match.ready.add(player).size === 2) {
|
|
match.ready.clear();
|
|
referee.ready(match);
|
|
}
|
|
}
|
|
else if (Object.hasOwn(referee.messages, word)) {
|
|
referee.messages[word](match, player, params);
|
|
}
|
|
};
|
|
|
|
// den items a claw machine can drop: the plushies, of the machine's own
|
|
// animal when it is named for one ("The Wolf Claw").
|
|
let plushies = null;
|
|
const clawPrizes = game => {
|
|
plushies = plushies || defpacks.denItemIds().filter(id => /plush/i.test(defpacks.denItemDef(id).abbrName));
|
|
const item = defpacks.denItemIds().map(id => defpacks.denItemDef(id)).find(def => Number(def.gameDefId) === game.id);
|
|
const animal = item ? /^ArcCraneGame(.+)$/.exec(item.abbrName) : null;
|
|
const own = animal ? plushies.filter(id => defpacks.denItemDef(id).abbrName.toLowerCase().includes(animal[1].toLowerCase())) : [];
|
|
return own.length ? own : plushies;
|
|
};
|
|
|
|
// what Phantom Invasion gives: den items named for phantoms, the arcade
|
|
// machines aside.
|
|
let phantomItems = null;
|
|
const invasionPrizes = () => {
|
|
phantomItems = phantomItems || defpacks.denItemIds().filter(id => /phantom/i.test(defpacks.denItemDef(id).abbrName)
|
|
&& !/^Arc/.test(defpacks.denItemDef(id).abbrName) && defpacks.string(defpacks.denItemDef(id).nameStrId));
|
|
return phantomItems.length ? phantomItems : defpacks.denItemIds().slice(0, 1);
|
|
};
|
|
|
|
// the Summer Carnival's games (Skeeball and the rest share one protocol):
|
|
// the server opens with "pz" and a serial number, "pg" pays for a go and
|
|
// brings a second one, and "gr" reports the score, signed with both, and
|
|
// is answered with the tickets it earned. how many points make a ticket
|
|
// was the official server's to know; games.json has a guess per game.
|
|
const hideSerial = sn => (sn + 5) * 3 - 7; // undone by the games as (x + 7) / 3 - 5
|
|
const carnival = {
|
|
pg(session, game, params, reply) {
|
|
const {account} = session;
|
|
if ((account.currency.gems || 0) < CARNIVAL_COST) {
|
|
reply("pg", "0");
|
|
return;
|
|
}
|
|
account.currency.gems -= CARNIVAL_COST;
|
|
achievements.currencyChanged(account, "gems", -CARNIVAL_COST);
|
|
accounts.save(account);
|
|
session.sendXt("cu", -1, CURRENCY_GEMS, account.currency.gems, 0);
|
|
game.serial2 = serial();
|
|
reply("pg", "1", hideSerial(game.serial2));
|
|
},
|
|
gr(session, game, [a, b, c], reply) {
|
|
const {account} = session;
|
|
const score = (Number(a) - (game.serial1 + 49) * 5) / 7 - 29;
|
|
const valid = game.serial2 !== undefined && Number.isInteger(score) && score >= 0
|
|
&& Number(b) === (score + 49) * 3 + (game.serial2 + 83) * 5
|
|
&& Number(c) === (game.serial1 + score) * 3 + score * 3
|
|
&& awardsPerMinute.allow(account.id);
|
|
game.serial2 = undefined; // one score a go
|
|
const tickets = valid ? Math.min(MAX_TICKETS_PER_GO, Math.ceil(score / game.def.tickets)) : 0;
|
|
if (tickets > 0) {
|
|
account.currency.tickets = (account.currency.tickets || 0) + tickets;
|
|
achievements.currencyChanged(account, "tickets", tickets);
|
|
accounts.save(account);
|
|
session.sendXt("cu", -1, CURRENCY_TICKETS, account.currency.tickets, 0);
|
|
}
|
|
reply("gr", tickets);
|
|
},
|
|
};
|
|
|
|
const uploadToken = (session, game, [, purpose], reply) => {
|
|
reply("tkn", 1, 0, masterpieces.issueToken(session.account), 0, purpose === undefined ? 1 : Number(purpose) || 1);
|
|
};
|
|
|
|
// what a game asks of the server while it runs, by game class and then by
|
|
// the message's first word. `reply` answers the asker as an "mm".
|
|
const MESSAGES = {
|
|
// These machines do not give an inventory item. They award temporary
|
|
// Holdable Icons: popcorn (emoticon 1), smoothies (2), and hot cocoa
|
|
// (5). The final field carries the selected visual state.
|
|
MicroPopcorn: {
|
|
_a(session, game, [kind], reply) {
|
|
if (kind === "1") {
|
|
grantAttachment(session, game, reply, 1);
|
|
}
|
|
},
|
|
},
|
|
MicroSmoothie: {
|
|
_a(session, game, [kind, colour], reply) {
|
|
const selected = String(colour || "").toLowerCase();
|
|
if (kind === "2" && SMOOTHIE_COLOURS.has(selected)) {
|
|
grantAttachment(session, game, reply, 2, selected);
|
|
}
|
|
},
|
|
},
|
|
MicroHotCocoa: {
|
|
_a(session, game, [kind, cocoaInfo], reply) {
|
|
if (kind === "5") {
|
|
grantAttachment(session, game, reply, 5, cocoaInfo);
|
|
}
|
|
},
|
|
},
|
|
CottonCandy: {
|
|
_a(session, game, [kind, emoticonInfo], reply) {
|
|
if (kind === "30") {
|
|
grantAttachment(session, game, reply, 30, emoticonInfo);
|
|
}
|
|
},
|
|
},
|
|
BradyChemistrySet: {
|
|
_a(session, game, [kind, emoticonInfo], reply) {
|
|
if (kind === "6") {
|
|
grantAttachment(session, game, reply, 6, emoticonInfo);
|
|
}
|
|
},
|
|
},
|
|
// the claw machines: "cp" pays for a go and learns whether the claw
|
|
// will hold and what on ([won, isDenItem, defId, ?, version]; anything
|
|
// but 1 or 0 for `won` means "not enough gems"); "cd" keeps (1) or
|
|
// leaves (0) what came out.
|
|
MicroCrane: {
|
|
cp(session, game, params, reply) {
|
|
const {account} = session;
|
|
if ((account.currency.gems || 0) < CLAW_COST) {
|
|
reply("cp", "2");
|
|
return;
|
|
}
|
|
account.currency.gems -= CLAW_COST;
|
|
achievements.currencyChanged(account, "gems", -CLAW_COST);
|
|
accounts.save(account);
|
|
session.sendXt("cu", -1, CURRENCY_GEMS, account.currency.gems, 0);
|
|
const prizes = clawPrizes(game.def);
|
|
const won = prizes.length > 0 && Math.random() < CLAW_WIN_CHANCE;
|
|
session.clawPrize = won ? prizes[Math.floor(Math.random() * prizes.length)] : null;
|
|
reply("cp", won ? "1" : "0", "1", session.clawPrize || 0, 0, 0);
|
|
},
|
|
cd(session, game, [keep]) {
|
|
if (keep === "1" && session.clawPrize) {
|
|
dens.giveDenItem(session.account, session.clawPrize);
|
|
dens.sendDenItems(session);
|
|
}
|
|
session.clawPrize = null;
|
|
},
|
|
},
|
|
// sky High: "gw" on reaching the top -> [won, clothingDefId, ?, colour];
|
|
// "gd" keeps (1) or leaves (0) the prize.
|
|
WindRider: {
|
|
go() {},
|
|
gw(session, game, params, reply) {
|
|
const ids = defpacks.clothingIds();
|
|
const def = Math.random() < SKY_HIGH_PRIZE_CHANCE ? defpacks.itemDef(ids[Math.floor(Math.random() * ids.length)]) : null;
|
|
session.gamePrize = def ? {def: Number(def.id), color: Number(String(def.colors).split(",")[0])} : null;
|
|
reply("gw", def ? "1" : "0", def ? def.id : 0, 0, def ? session.gamePrize.color : 0);
|
|
},
|
|
gd(session, game, [keep]) {
|
|
if (keep === "1" && session.gamePrize) {
|
|
sendClothingAdded(session, addClothing(session.account, session.gamePrize.def, session.gamePrize.color));
|
|
accounts.save(session.account);
|
|
}
|
|
session.gamePrize = null;
|
|
},
|
|
},
|
|
// the safety quiz: "hs" asks for a serial number, and "hp", signed with
|
|
// it, claims the quiz's one prize.
|
|
SafetyQuiz: {
|
|
hs(session, game, params, reply) {
|
|
session.prizeSerial = serial();
|
|
reply("hs", session.prizeSerial);
|
|
},
|
|
hp(session, game, [, check]) {
|
|
if (session.prizeSerial !== undefined && Number(check) === (session.prizeSerial + session.id) * 3) {
|
|
dens.giveDenItem(session.account, SAFETY_QUIZ_PRIZE);
|
|
dens.sendDenItems(session);
|
|
}
|
|
session.prizeSerial = undefined;
|
|
},
|
|
},
|
|
// brady Barr's expeditions ask for the same serial; their prizes hang on
|
|
// the theatre's films and are not given.
|
|
BradyExpeditions: {
|
|
hs(session, game, params, reply) {
|
|
reply("hs", serial());
|
|
},
|
|
hp() {},
|
|
},
|
|
// the touch pool: the same again, with six prizes; which one is in the
|
|
// first number.
|
|
TouchPool: {
|
|
ts(session, game, params, reply) {
|
|
session.prizeSerial = serial();
|
|
reply("ts", session.prizeSerial);
|
|
},
|
|
tp(session, game, [signed, check]) {
|
|
const sn = session.prizeSerial;
|
|
const prize = sn === undefined ? -1 : (Number(signed) - (session.id + 99) * 3 - (sn + 49) * 5) / 5;
|
|
if (TOUCH_POOL_PRIZES[prize] !== undefined && Number(check) === (sn + session.id + prize) * 3 + prize * 3) {
|
|
dens.giveDenItem(session.account, TOUCH_POOL_PRIZES[prize]);
|
|
dens.sendDenItems(session);
|
|
}
|
|
session.prizeSerial = undefined; // one prize a serial number
|
|
},
|
|
},
|
|
// phantom Invasion: "cp" pays for a go and names the prize a win will
|
|
// bring, [ok, serial, isDenItem, defId, ?, version]; the game itself
|
|
// decides whether it was won. "cd", signed with the serial, keeps it;
|
|
// "cd 2" leaves it and "cd 0" is a lost round.
|
|
MicroGameInvasion: {
|
|
cp(session, game, params, reply) {
|
|
const {account} = session;
|
|
if ((account.currency.gems || 0) < INVASION_COST) {
|
|
reply("cp", "2");
|
|
return;
|
|
}
|
|
account.currency.gems -= INVASION_COST;
|
|
achievements.currencyChanged(account, "gems", -INVASION_COST);
|
|
accounts.save(account);
|
|
session.sendXt("cu", -1, CURRENCY_GEMS, account.currency.gems, 0);
|
|
const prizes = invasionPrizes();
|
|
session.prizeSerial = serial();
|
|
session.gamePrize = prizes[Math.floor(Math.random() * prizes.length)];
|
|
reply("cp", "1", session.prizeSerial, "1", session.gamePrize, 0, 0);
|
|
},
|
|
cd(session, game, [signed, check]) {
|
|
const sn = session.prizeSerial;
|
|
const won = sn !== undefined && session.gamePrize
|
|
&& Number(signed) === INVASION_WIN * 5 + (session.id + 99) * 3 + (sn + 49) * 5
|
|
&& Number(check) === (sn + session.id + INVASION_WIN) * 3 + INVASION_WIN * 3;
|
|
if (won) {
|
|
dens.giveDenItem(session.account, session.gamePrize);
|
|
dens.sendDenItems(session);
|
|
}
|
|
session.prizeSerial = undefined;
|
|
session.gamePrize = null;
|
|
},
|
|
},
|
|
// the Art Studio's two easels: "gmtkn" asks for a token to post a
|
|
// painting with (lib/masterpieces.js). the game reads [word, ok, ?,
|
|
// token, ?, what the token is for], the last as it was sent.
|
|
ArtStudioPainting: {gmtkn: uploadToken},
|
|
ArtStudioGridDrawing: {gmtkn: uploadToken},
|
|
// the Phantom Vortex's prize machine: anything but "0" is "no prize".
|
|
MicroPhantom: {
|
|
pi(session, game, params, reply) {
|
|
reply("cp", "1");
|
|
},
|
|
},
|
|
};
|
|
|
|
const handlers = {
|
|
// MinigameXtCommManager.handleMinigameInfo: [count, 19 fields a game...].
|
|
// RoomManagerWorld asks for every game standing in a room at once and
|
|
// draws none of their signs unless it hears about all of them.
|
|
mi(session, roomId, ids) {
|
|
const asked = ids.slice(0, MAX_INFO_REQUEST).map(Number).filter(id => Number.isInteger(id) && id > 0);
|
|
// the easel's "play" popup offers both painting games and reads the
|
|
// second one's description without having asked for it
|
|
// (GameCardPopup, for game 51): it goes along.
|
|
if (asked.includes(GAME_PAINTING) && !asked.includes(GAME_PIXEL_PAINTING)) {
|
|
asked.push(GAME_PIXEL_PAINTING);
|
|
}
|
|
const known = asked.map(id => games.get(id) || {...UNKNOWN_GAME, id});
|
|
session.sendXt("mi", -1, known.length, ...known.flatMap(info));
|
|
},
|
|
|
|
// MinigameManager.launchGame: [gameDefId, multiplayer, proModeId, ?].
|
|
mj(session, roomId, [gameDefId, multiplayer]) {
|
|
leave(session); // a game left without a word, if any
|
|
const def = games.get(Number(gameDefId));
|
|
if (!def || def.ready === false || def.buddy || !session.room) {
|
|
// "as": the one refusal that puts the client back as it was. it
|
|
// comes with a popup about switching animals, hence one of our own.
|
|
session.sendXt("mj", -1, "as", 0);
|
|
tell(session, "That game is not ready on this server yet.");
|
|
return;
|
|
}
|
|
if (multiplayer === "1" && Object.hasOwn(MULTIPLAYER, def.swf)) {
|
|
joinLobby(session, def, MULTIPLAYER[def.swf]);
|
|
return;
|
|
}
|
|
const game = {roomId: nextGameRoomId++, def, players: [session], started: false, ready: new Set()};
|
|
const music = session.room.customMusicDef; // the client takes this from every room join
|
|
if (def.type !== IN_ROOM) {
|
|
// the game takes the room's place: the player is gone from the
|
|
// world until they come back with an ordinary room join.
|
|
game.returnTo = session.room.name;
|
|
leaveRoom(session);
|
|
}
|
|
seat(session, game, music);
|
|
start(game);
|
|
if (def.tickets) {
|
|
game.serial1 = serial();
|
|
session.sendXt("mm", game.roomId, "pz", hideSerial(game.serial1));
|
|
}
|
|
},
|
|
|
|
// "Start now", from a waiting list; nobody waits here.
|
|
ms() {},
|
|
|
|
// MinigameManager.msg: [gameDefId, word, ...]. the game's own protocol.
|
|
mm(session, roomId, [gameDefId, word, ...params]) {
|
|
const {game} = session;
|
|
if (!game || game.def.id !== Number(gameDefId)) {
|
|
return;
|
|
}
|
|
if (game.match) {
|
|
matchMessage(session, game, String(word), params);
|
|
return;
|
|
}
|
|
if (game.multi && Object.hasOwn(game.multi.relay, String(word))) {
|
|
relay(session, game, String(word), params);
|
|
return;
|
|
}
|
|
const reply = (...fields) => session.sendXt("mm", game.roomId, ...fields);
|
|
const own = game.def.tickets ? carnival : MESSAGES[game.def.swf];
|
|
if (own && Object.hasOwn(own, word)) {
|
|
own[word](session, game, params, reply);
|
|
}
|
|
else if (word === "ready" && game.def.start && Object.hasOwn(START, game.def.start)) {
|
|
game.ready.add(session);
|
|
if (game.ready.size === game.players.length) {
|
|
for (const player of game.players) {
|
|
player.sendXt("mm", game.roomId, "start", ...START[game.def.start](game));
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
// leaving an in-room game: [subRoomId]. (A game that took the room's
|
|
// place is left by joining a room again.)
|
|
rl(session) {
|
|
leave(session);
|
|
},
|
|
ml(session) {
|
|
leave(session);
|
|
},
|
|
|
|
// MinigameManager.sendGemAward: three numbers made of the amount, the
|
|
// game, the player's sfs id and the serial number last handed out (the
|
|
// second, which names the game, is not checked: not every game says
|
|
// which it is). the reply is the next serial number.
|
|
mg(session, roomId, [a, , c]) {
|
|
const {account, game} = session;
|
|
const sn = session.gemSerial;
|
|
const amount = (Number(a) - (session.id + 99) * 3 - (sn + 49) * 5) / 7 - 29;
|
|
const valid = game && sn !== undefined && Number.isInteger(amount) && amount > 0 && amount <= MAX_GEMS_PER_AWARD
|
|
&& Number(c) === (sn + session.id + amount) * 3 + amount * 3
|
|
&& awardsPerMinute.allow(account.id);
|
|
if (valid) {
|
|
account.currency.gems = (account.currency.gems || 0) + amount;
|
|
achievements.currencyChanged(account, "gems", amount);
|
|
accounts.save(account);
|
|
}
|
|
session.gemSerial = serial();
|
|
session.sendXt("mg", -1, session.gemSerial, 0);
|
|
},
|
|
|
|
// MinigameManager.sendMasteryPoints, the same for the pet's mastery. the
|
|
// second field of the reply says its mastery is now full.
|
|
ma(session, roomId, [a, b, c]) {
|
|
const {account, game} = session;
|
|
const sn = session.masterySerial;
|
|
const amount = (Number(a) - (session.id + 99) * 3 - (sn + 49) * 5) / 7 - 29;
|
|
const pet = account.pets.find(candidate => candidate.inv === activeAvatar(account).petInvId);
|
|
const valid = game && pet && sn !== undefined && Number.isInteger(amount) && amount > 0 && amount <= MAX_MASTERY_PER_AWARD
|
|
&& Number(c) === (sn + session.id + amount) * 3 + amount * 3 && Number(b) === (game.def.id + 49) * 3 + (sn + 83) * 5;
|
|
let nowFull = false;
|
|
if (valid && (pet.mastery || 0) < MASTERY_FULL) {
|
|
pet.mastery = Math.min(MASTERY_FULL, (pet.mastery || 0) + amount);
|
|
nowFull = pet.mastery === MASTERY_FULL;
|
|
accounts.save(account);
|
|
}
|
|
session.masterySerial = serial();
|
|
session.sendXt("ma", -1, session.masterySerial, nowFull ? 1 : 0);
|
|
},
|
|
|
|
// high scores for the leaderboards, which are not kept.
|
|
msv() {},
|
|
// MinigameManager.leaderBoardResponse: [gameDefId, count, ...]
|
|
mlb(session, roomId, [gameDefId]) {
|
|
session.sendXt("mlb", -1, gameDefId, 0);
|
|
},
|
|
// the buddy games (MinigameXtCommManager.sendMinigamePvpMsg): [gameDefId,
|
|
// 0, username] invites that player; [gameDefId, 0] from the invited
|
|
// player says yes, and [gameDefId, 1] from either says no or never mind.
|
|
// MinigameManager.pvpResponse reads [gameDefId, 0, who is asking, their
|
|
// name may be shown] and [gameDefId, 1] for "no".
|
|
mp(session, roomId, [gameDefId, status, username]) {
|
|
const def = games.get(Number(gameDefId));
|
|
if (status !== "0") {
|
|
dropInvite(session);
|
|
return;
|
|
}
|
|
if (username === undefined || username === "") {
|
|
const {invite} = session;
|
|
if (invite && invite.target === session && invite.def === def && !invite.sender.game && !session.game) {
|
|
dropInvite(session, false);
|
|
startMatch(def, invite.sender, session);
|
|
}
|
|
else {
|
|
dropInvite(session);
|
|
}
|
|
return;
|
|
}
|
|
const target = findOnline(username);
|
|
const free = other => other && other.room && !other.game && !other.invite;
|
|
if (!def || !def.buddy || !free(session) || !free(target) || target === session
|
|
|| blocks.either(session.account, target.account) || !invitesPerMinute.allow(session.account.id)
|
|
|| !accounts.featureOn(session.account, "gameInvites") || !accounts.featureOn(target.account, "gameInvites")) {
|
|
// "They said no" is all the client has for an invitation that cannot be made.
|
|
dropInvite(session);
|
|
session.sendXt("mp", -1, def ? def.id : Number(gameDefId) || 0, 1);
|
|
return;
|
|
}
|
|
session.invite = target.invite = {def, sender: session, target};
|
|
target.sendXt("mp", -1, def.id, 0, session.account.username, 1);
|
|
},
|
|
// a click on another player's game bubble (MinigameXtCommManager
|
|
// .sendMinigameCustomPvpJoinMsg): [gameDefId, 0, their username]. the
|
|
// game starts at once, as an invitation said yes to; a bubble that is
|
|
// gone by now is answered as an invitation said no to
|
|
// (MinigameManager.pvpResponse), which puts the clicker back as they were.
|
|
mcp(session, roomId, [gameDefId, , username]) {
|
|
const def = games.get(Number(gameDefId));
|
|
const host = findOnline(String(username || ""));
|
|
const free = player => player && player.room && !player.game && !player.invite;
|
|
if (!def || !host || host === session || host.pvpBubble !== def.id || host.room !== session.room
|
|
|| !free(session) || !free(host) || blocks.either(session.account, host.account)
|
|
|| !accounts.featureOn(session.account, "gameInvites")) {
|
|
session.sendXt("mp", -1, def ? def.id : Number(gameDefId) || 0, 1);
|
|
return;
|
|
}
|
|
startMatch(def, host, session);
|
|
},
|
|
};
|
|
|
|
// the HUD's Games window (GameJoinPopup, generic list 341): the playable
|
|
// games that have a picture for it, by name. A buddy game's card picture
|
|
// is drawn the same way, and picking one there puts its bubble up.
|
|
const library = [...games.values()].filter(game => (game.icon || (game.buddy && game.card)) && game.ready !== false)
|
|
.sort((one, other) => one.title.localeCompare(other.title)).map(game => game.id);
|
|
|
|
// the buddy games' descriptions, sent unasked when a player arrives: a
|
|
// player's card lists whichever games the client has heard are ready to
|
|
// be played against another player (MinigameInfoCache.getAllReadyForPvpGameDefs).
|
|
const greet = session => {
|
|
const buddy = [...games.values()].filter(game => game.buddy && Object.hasOwn(buddyGames, game.swf));
|
|
session.sendXt("mi", -1, buddy.length, ...buddy.flatMap(info));
|
|
};
|
|
|
|
return {
|
|
handlers,
|
|
leave,
|
|
greet,
|
|
bubble,
|
|
showBubble,
|
|
// out of the room: nobody there is left to see the bubble.
|
|
roomLeft: session => {
|
|
session.pvpBubble = null;
|
|
},
|
|
library: () => library,
|
|
// the room a player in a room-replacing game came from, for the panel.
|
|
playing: session => (session.game ? session.game.def.title : null),
|
|
};
|
|
};
|